diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 000000000..1a4608179
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,26 @@
+# EditorConfig — https://editorconfig.org
+# Aligns with .gitattributes (LF in repo). Cursor/VS Code apply this on save when
+# the EditorConfig extension is enabled (built into Cursor/VS Code by default).
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.go]
+indent_style = tab
+indent_size = 4
+
+[*.{bat,cmd}]
+end_of_line = crlf
+
+[Makefile]
+indent_style = tab
diff --git a/AGENTS.md b/AGENTS.md
index a0f08d97a..9647d7db5 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -39,7 +39,7 @@ flowchart LR
 | Profile | Typical focus | Where to work |
 |--------|----------------|---------------|
 | **Platform developer** | You are editing **this repo**: RN, Go, React, shared packages, CI. | Package `AGENTS.md` below. |
-| **Custom app author** | You ship an **HTML/JS/CSS** app bundle and JSON forms for Formulus; you may **not** clone this monorepo. | [Custom app template (AI + author context)](https://github.com/OpenDataEnsemble/custom_app) and [documentation](https://opendataensemble.org/docs/). |
+| **Custom app author** | You ship an **HTML/JS/CSS** app bundle and JSON forms for Formulus; you may **not** clone this monorepo. | [Custom app template (AI + author context)](https://github.com/OpenDataEnsemble/custom_app), [documentation](https://opendataensemble.org/docs/), and [FORM_LOCALIZATION_GUIDE.md](FORM_LOCALIZATION_GUIDE.md) for form i18n. |
 
 Do not assume custom app authors have local checkouts of **ODE** or internal example repos.
 
@@ -135,13 +135,14 @@ git push origin v1.1.1-alpha.3
 - **Custom app bridge (v1.1.0+):** `persistObservation` (headless write), `sync`, `getConnectivityStatus`, `getCurrentDataRevisionCount`, and `openFormplayer` options `skipFinalize` / `skipDraftSelection` — contract in [`FormulusInterfaceDefinition.ts`](formulus/src/webview/FormulusInterfaceDefinition.ts); run `pnpm run sync-interface` in formplayer after changes.
 - **Sub-observations:** Each nested Formplayer session validates its own schema; `skipFinalize` only skips the Finalize page. Custom validators are per-session — see [Custom Extensions — nested sessions](https://opendataensemble.org/docs/guides/custom-extensions#nested-sessions-and-custom-validators) (docs site).
 - **Shared UI tokens:** Install **tokens** before **components** / **formplayer** where the docs require it (see package READMEs and formplayer AGENTS).
+- **i18n (two layers):** ODE-owned locales (`en`/`pt`/`fr`) for Formulus + Formplayer chrome via Settings → Language; form-owned copy via optional `translations` on `ui.json` elements (preprocessed at form init). See [FORM_LOCALIZATION_GUIDE.md](FORM_LOCALIZATION_GUIDE.md) (monorepo) and [form translations guide](https://opendataensemble.org/docs/guides/form-translations) (published).
 
 ---
 
 ## CI and code quality
 
 - **Pipelines:** [.github/CICD.md](.github/CICD.md).
-- **Lint/format:** Run the relevant scripts in the **package you touch** (see root [README.md](README.md) and each package).
+- **Lint/format:** Run the relevant scripts in the **package you touch** (see root [README.md](README.md) and each package). On Windows, use LF line endings — root [`.editorconfig`](.editorconfig) and [`.gitattributes`](.gitattributes) match Prettier/CI; run `pnpm run format` in the package if you see `Delete ␍` lint errors.
 - **Pre-flight before opening a PR:** each package `AGENTS.md` lists the local `lint` / `format` / `format:check` / `test` / `build` commands that match CI — run them in every package you changed (e.g. [formulus-formplayer/AGENTS.md](formulus-formplayer/AGENTS.md#pre-flight-before-a-pr)).
 - **Commits/PRs:** Conventional Commits and PR expectations are documented in [formulus-formplayer/AGENTS.md](formulus-formplayer/AGENTS.md) (project-wide convention).
 
@@ -157,4 +158,6 @@ ODE Desktop ships in [`desktop/`](desktop/) (see [desktop/AGENTS.md](desktop/AGE
 
 Authoritative **public** documentation: [opendataensemble.org](https://opendataensemble.org/docs/).
 
+Form localization (embedded `ui.json` translations): [FORM_LOCALIZATION_GUIDE.md](FORM_LOCALIZATION_GUIDE.md).
+
 Optional **AI-focused** context (no ODE clone required): [custom_app](https://github.com/OpenDataEnsemble/custom_app) on GitHub (`README.md`, `AGENTS.md`, `CONTEXT_*.md`).
diff --git a/FORM_LOCALIZATION_GUIDE.md b/FORM_LOCALIZATION_GUIDE.md
new file mode 100644
index 000000000..00acaa419
--- /dev/null
+++ b/FORM_LOCALIZATION_GUIDE.md
@@ -0,0 +1,247 @@
+# Form localization guide
+
+How **user-defined forms** (JSON Schema + `ui.json` in custom app bundles) support multiple languages in ODE.
+
+**Audience:** platform developers editing Formplayer/Formulus, and custom app authors shipping forms in app bundles.
+
+**Published user guide:** [Form translations](https://opendataensemble.org/docs/guides/form-translations) on opendataensemble.org (kept in sync conceptually; this file is the monorepo implementation reference).
+
+---
+
+## Two i18n layers (do not mix them up)
+
+| Layer | Who owns it | Where strings live | When it applies |
+|-------|-------------|-------------------|-----------------|
+| **ODE chrome** | ODE platform | `formulus-formplayer/src/locales/{en,pt,fr}.json`, Formulus i18n catalogs | Next/Back, validation errors, sub-obs “+ Add …” template, loading text |
+| **Form copy** | Form / app author | `ui.json` base fields + optional `translations` blocks | Field labels, descriptions, SwipeLayout headers, custom widget copy |
+
+Form authors **do not** edit ODE locale JSON. They embed translations in each form’s `ui.json`. ODE developers extend chrome strings when adding new platform UI.
+
+---
+
+## How form locale is chosen
+
+1. User setting in Formulus **Settings → Language** (`auto`, `en`, `pt`, `fr`)
+2. **Auto** → device language; if unsupported, bundle `defaultLocale` from `app.config.json`
+3. Fallback `en`
+
+The host passes the resolved tag as **`params.locale`** when opening Formplayer. Formplayer merges form translations **once at init** (`applyFormUiTranslations()` in `formulus-formplayer/src/i18n/applyFormUiTranslations.ts`).
+
+```json
+// app/public/app.config.json (custom app bundle)
+{
+  "defaultLocale": "pt"
+}
+```
+
+Use `defaultLocale` when the study’s primary language is not English so **Auto** prefers the right default on devices whose language ODE does not ship.
+
+---
+
+## Authoring pattern: base string + `translations`
+
+Put the **default** copy on the element (`label`, `description`, `text`, …). Add **`translations.<locale>`** only for locales that differ.
+
+```json
+{
+  "type": "Control",
+  "scope": "#/properties/participant_name",
+  "label": "Participant name",
+  "description": "Full legal name",
+  "translations": {
+    "pt": {
+      "label": "Nome do participante",
+      "description": "Nome legal completo"
+    },
+    "fr": {
+      "label": "Nom du participant"
+    }
+  }
+}
+```
+
+**Rules:**
+
+- Base `label` is required for every user-visible control — do not rely on `schema.json` `title` for display text in multi-locale forms.
+- `translations` keys are **partial**; missing keys fall back to the base string.
+- Locale lookup tries the full BCP-47 tag then the language subtag (`pt-BR` → `pt`).
+- `translations.<locale>.title` is accepted as an alias for `label` in that block (legacy convenience).
+
+### Portuguese-primary study with English override
+
+Base language can be anything; merge logic is symmetric.
+
+```json
+{
+  "type": "Control",
+  "scope": "#/properties/codigo",
+  "label": "Digitalizar código do envelope",
+  "translations": {
+    "en": { "label": "Scan the envelope code" }
+  }
+}
+```
+
+| Active UI locale | Shown label |
+|------------------|-------------|
+| `pt` | Base (`label`) |
+| `en` | `translations.en.label` |
+| `fr` (no block) | Base (`label`) |
+
+---
+
+## `schema.title` vs `ui.json` `label`
+
+| | `schema.json` → `properties.*.title` | `ui.json` → `Control.label` |
+|---|--------------------------------------|-----------------------------|
+| Translated at runtime? | No | Yes |
+| Primary on-screen label? | Fallback only | Yes |
+
+```json
+// schema.json — keep for validation / exports; not your i18n source of truth
+{
+  "properties": {
+    "codigo": { "type": "string", "title": "Código" }
+  }
+}
+```
+
+```json
+// ui.json — what the user actually reads
+{
+  "type": "Control",
+  "scope": "#/properties/codigo",
+  "label": "Digitalizar código do envelope",
+  "translations": { "en": { "label": "Scan the envelope code" } }
+}
+```
+
+Formplayer resolves labels in order: **`Control.label`** (after translation merge) → JsonForms default → **`schema.title`** → field key. All built-in renderers, SwipeLayout header chips, Finalize summaries, and sub-observation column headers use this path (`controlDisplayText.ts`).
+
+---
+
+## SwipeLayout chrome
+
+Put button and header copy in **`options`**. Override per locale via top-level keys in the translation block (merged into `options`) or nested `translations.<locale>.options`:
+
+```json
+{
+  "type": "SwipeLayout",
+  "elements": [],
+  "options": {
+    "headerTitle": "Household interview",
+    "nextButtonLabel": "Next",
+    "finalizeButtonLabel": "Finish"
+  },
+  "translations": {
+    "pt": {
+      "headerTitle": "Entrevista ao agregado",
+      "nextButtonLabel": "Seguinte",
+      "finalizeButtonLabel": "Concluir"
+    }
+  }
+}
+```
+
+---
+
+## Sub-observations
+
+**Add button:** if `options.addButtonLabel` is omitted, Formplayer composes `+ Add {itemLabel}` from schema `itemLabel` using ODE chrome strings (`subObservation.addItem`). Override when you need custom wording:
+
+```json
+{
+  "type": "Control",
+  "scope": "#/properties/quartos",
+  "label": "Quartos",
+  "options": {
+    "addButtonLabel": "+ Adicionar quarto"
+  },
+  "translations": {
+    "en": {
+      "addButtonLabel": "+ Add room"
+    }
+  }
+}
+```
+
+**Table columns:** list columns by **`key` only** in `schema.json`. Headers come from the **linked child form**’s `ui.json` labels (after translation), not from hardcoded schema column titles:
+
+```json
+"x-subObservation": {
+  "formType": "censo_milda_quarto",
+  "itemLabel": "quarto",
+  "columns": [{ "key": "quarto_num" }, { "key": "quarto_display" }]
+}
+```
+
+Child forms need their own `Control.label` + `translations` for those fields. Optional static `column.label` / `options.columns[].label` overrides all locales.
+
+---
+
+## Custom question types
+
+Widget-specific copy belongs in **`Control.options`**, not hardcoded in `question_types/.../renderer.js`:
+
+```json
+{
+  "type": "Control",
+  "scope": "#/properties/confidence",
+  "label": "How confident are you?",
+  "options": {
+    "lowLabel": "Not at all",
+    "highLabel": "Very",
+    "oneOf": [{ "const": "yes", "title": "Yes" }]
+  },
+  "translations": {
+    "pt": {
+      "label": "Qual é a sua confiança?",
+      "options": {
+        "lowLabel": "Nada",
+        "highLabel": "Muito",
+        "oneOf": [{ "const": "yes", "title": "Sim" }]
+      }
+    }
+  }
+}
+```
+
+Behavioral config (`maxStars`, filters, …) stays in **`schema.json`** (`config` / validation), not in translated UI copy.
+
+---
+
+## Translatable properties (v1)
+
+| Element | Properties |
+|---------|------------|
+| `Control` | `label`, `description`; nested `options.*` |
+| `Group`, `Category` | `label` |
+| `Label` | `text` |
+| `SwipeLayout` (root) | `options.headerTitle`, `options.nextButtonLabel`, `options.finalizeButtonLabel` |
+| Sub-observation | `options.addButtonLabel`; optional `options.columns[].label` |
+
+---
+
+## Platform implementation map
+
+| Concern | Location |
+|---------|----------|
+| Merge `translations` into UI schema at init | `formulus-formplayer/src/i18n/applyFormUiTranslations.ts` |
+| Label resolution at render time | `formulus-formplayer/src/utils/controlDisplayText.ts` |
+| Form init + `params.locale` | `formulus-formplayer/src/App.tsx` |
+| ODE chrome catalogs | `formulus-formplayer/src/locales/*.json` |
+| UI locale preference (host) | `formulus/src/lib/locale.ts`, Settings → Language |
+| Linked child specs for sub-obs columns | `FormInitData.linkedFormSpecs` (built in Formulus / ODE Desktop) |
+
+When changing merge rules or label resolution, update **`applyFormUiTranslations.test.ts`**, affected renderers, and the [published form translations guide](https://opendataensemble.org/docs/guides/form-translations) in **ode-docs**.
+
+---
+
+## Author checklist
+
+- [ ] Every visible field has `Control.label` in `ui.json` (not only `schema.title`)
+- [ ] Base `label` set; `translations` added for other ODE UI locales you ship (`en`, `pt`, `fr`)
+- [ ] SwipeLayout headers/buttons translated where needed
+- [ ] Sub-obs columns use `key` only; labels live on linked child forms
+- [ ] Custom question type strings in `options`, not in renderer JS
+- [ ] `defaultLocale` in `app.config.json` when the study default is not English
diff --git a/desktop/AGENTS.md b/desktop/AGENTS.md
index 9498708cb..02f2fe803 100644
--- a/desktop/AGENTS.md
+++ b/desktop/AGENTS.md
@@ -85,7 +85,7 @@ Developer mode on with missing/invalid folder → blocking error in UI; no silen
 ## Bridge and bundles
 
 - **Contract source of truth:** [`formulus/src/webview/FormulusInterfaceDefinition.ts`](../formulus/src/webview/FormulusInterfaceDefinition.ts).
-- **Form preview:** `formPreviewBridge.ts` handles injection `postMessage` types; device APIs stubbed; observations/attachments use Tauri.
+- **Form preview:** `formPreviewBridge.ts` handles injection `postMessage` types; device APIs stubbed; observations/attachments use Tauri. **`linkedFormSpecs`** on `FormInitData` is populated via `buildLinkedFormSpecs` (see `buildFormPreviewInit.ts`) so sub-observation column headers match Formulus.
 - **Extensions:** `bundleExtensionLoader.ts` merges `forms/ext.json` like Formulus `ExtensionService`; pass `developerMode` for path prefix.
 
 ---
diff --git a/desktop/src/lib/__tests__/buildFormPreviewInit.test.ts b/desktop/src/lib/__tests__/buildFormPreviewInit.test.ts
index 27874fe38..5aa6182f7 100644
--- a/desktop/src/lib/__tests__/buildFormPreviewInit.test.ts
+++ b/desktop/src/lib/__tests__/buildFormPreviewInit.test.ts
@@ -29,6 +29,21 @@ describe('buildFormPreviewInit', () => {
     });
     expect(init.subObservationMode).toBe(true);
   });
+
+  it('forwards linkedFormSpecs when provided', () => {
+    const linked = {
+      child: { schema: { type: 'object' }, uiSchema: {} },
+    };
+    const init = buildFormPreviewInit({
+      formType: 'Parent',
+      params: {},
+      savedData: {},
+      formSchema: {},
+      uiSchema: {},
+      linkedFormSpecs: linked,
+    });
+    expect(init.linkedFormSpecs).toEqual(linked);
+  });
 });
 
 describe('inferObservationIdFromSavedData', () => {
diff --git a/desktop/src/lib/__tests__/buildLinkedFormSpecs.test.ts b/desktop/src/lib/__tests__/buildLinkedFormSpecs.test.ts
new file mode 100644
index 000000000..1d1ba5165
--- /dev/null
+++ b/desktop/src/lib/__tests__/buildLinkedFormSpecs.test.ts
@@ -0,0 +1,71 @@
+import { describe, expect, it, vi } from 'vitest';
+import { collectLinkedFormIds } from '../collectLinkedFormIds';
+import { buildLinkedFormSpecs } from '../buildLinkedFormSpecs';
+
+describe('collectLinkedFormIds', () => {
+  it('collects linkedForm from nested properties', () => {
+    const ids = collectLinkedFormIds({
+      properties: {
+        quartos: {
+          type: 'array',
+          linkedForm: 'censo_milda_quarto',
+        },
+      },
+    });
+    expect([...ids]).toEqual(['censo_milda_quarto']);
+  });
+});
+
+describe('buildLinkedFormSpecs', () => {
+  it('loads linked forms and follows nested chains', async () => {
+    const loadSpec = vi.fn(async (formType: string) => {
+      if (formType === 'parent') {
+        return {
+          formSchema: {
+            properties: {
+              items: { linkedForm: 'child' },
+            },
+          },
+          uiSchema: { type: 'VerticalLayout' },
+        };
+      }
+      if (formType === 'child') {
+        return {
+          formSchema: {
+            properties: { name: { type: 'string', title: 'Name' } },
+          },
+          uiSchema: {
+            type: 'Control',
+            scope: '#/properties/name',
+            label: 'Child label',
+          },
+        };
+      }
+      throw new Error('missing');
+    });
+
+    const specs = await buildLinkedFormSpecs(
+      { properties: { items: { linkedForm: 'parent' } } },
+      loadSpec,
+    );
+
+    expect(loadSpec).toHaveBeenCalledWith('parent');
+    expect(loadSpec).toHaveBeenCalledWith('child');
+    expect(specs?.parent?.schema).toBeTruthy();
+    expect(specs?.child?.uiSchema).toEqual({
+      type: 'Control',
+      scope: '#/properties/name',
+      label: 'Child label',
+    });
+  });
+
+  it('returns undefined when no linked forms', async () => {
+    const loadSpec = vi.fn();
+    const specs = await buildLinkedFormSpecs(
+      { type: 'object', properties: { a: { type: 'string' } } },
+      loadSpec,
+    );
+    expect(specs).toBeUndefined();
+    expect(loadSpec).not.toHaveBeenCalled();
+  });
+});
diff --git a/desktop/src/lib/buildFormPreviewInit.ts b/desktop/src/lib/buildFormPreviewInit.ts
index f7fc8c38a..518f29c97 100644
--- a/desktop/src/lib/buildFormPreviewInit.ts
+++ b/desktop/src/lib/buildFormPreviewInit.ts
@@ -1,5 +1,11 @@
 import type { FormInitData } from './formplayerHost';
 import { sanitizePortableAttachmentsInFormData } from './sanitizeFormSavedData';
+import { resolveDesktopUiLocale } from './uiLocale';
+import {
+  buildLinkedFormSpecs,
+  type LoadLinkedFormSpec,
+} from './buildLinkedFormSpecs';
+import type { BundleFormSpec } from '../types/domain';
 
 /** Infer SQLite observation id from embedded saved row data (matches Workbench navigate-from-custom-app). */
 export function inferObservationIdFromSavedData(
@@ -30,11 +36,16 @@ export function buildFormPreviewInit(args: {
   skipDraftSelection?: boolean;
   extensions?: FormInitData['extensions'];
   customQuestionTypes?: FormInitData['customQuestionTypes'];
+  linkedFormSpecs?: FormInitData['linkedFormSpecs'];
 }): FormInitData {
+  const locale =
+    typeof args.params.locale === 'string'
+      ? resolveDesktopUiLocale(args.params.locale)
+      : resolveDesktopUiLocale();
   const init: FormInitData = {
     formType: args.formType,
     observationId: args.observationId ?? null,
-    params: args.params,
+    params: { ...args.params, locale },
     savedData: sanitizePortableAttachmentsInFormData(args.savedData),
     formSchema: args.formSchema,
     uiSchema: args.uiSchema,
@@ -50,9 +61,47 @@ export function buildFormPreviewInit(args: {
   if (args.skipDraftSelection) {
     init.skipDraftSelection = true;
   }
+  if (args.linkedFormSpecs) {
+    init.linkedFormSpecs = args.linkedFormSpecs;
+  }
   return init;
 }
 
+/**
+ * Build preview init from a bundle form spec, including linked child forms for sub-obs columns.
+ */
+export async function buildFormPreviewInitFromBundleSpec(args: {
+  spec: BundleFormSpec;
+  params: Record<string, unknown>;
+  savedData: Record<string, unknown>;
+  observationId?: string | null;
+  subObservationMode?: boolean;
+  skipFinalize?: boolean;
+  skipDraftSelection?: boolean;
+  extensions?: FormInitData['extensions'];
+  customQuestionTypes?: FormInitData['customQuestionTypes'];
+  loadLinkedFormSpec: LoadLinkedFormSpec;
+}): Promise<FormInitData> {
+  const linkedFormSpecs = await buildLinkedFormSpecs(
+    args.spec.formSchema,
+    args.loadLinkedFormSpec,
+  );
+  return buildFormPreviewInit({
+    formType: args.spec.formType,
+    observationId: args.observationId ?? null,
+    params: args.params,
+    savedData: args.savedData,
+    formSchema: args.spec.formSchema,
+    uiSchema: args.spec.uiSchema,
+    extensions: args.extensions,
+    customQuestionTypes: args.customQuestionTypes,
+    subObservationMode: args.subObservationMode,
+    skipFinalize: args.skipFinalize,
+    skipDraftSelection: args.skipDraftSelection,
+    linkedFormSpecs,
+  });
+}
+
 export function parseJsonObject(
   text: string,
   label: string,
diff --git a/desktop/src/lib/buildLinkedFormSpecs.ts b/desktop/src/lib/buildLinkedFormSpecs.ts
new file mode 100644
index 000000000..5cebca6d7
--- /dev/null
+++ b/desktop/src/lib/buildLinkedFormSpecs.ts
@@ -0,0 +1,47 @@
+import { collectLinkedFormIds } from './collectLinkedFormIds';
+import type { FormInitData } from './formplayerHost';
+
+export type LoadLinkedFormSpec = (formType: string) => Promise<{
+  formSchema: unknown;
+  uiSchema?: unknown;
+}>;
+
+/**
+ * Load schema/ui for all forms referenced by `linkedForm` (including nested chains).
+ * Matches Formulus FormplayerModal behaviour for sub-observation column labels.
+ */
+export async function buildLinkedFormSpecs(
+  rootSchema: unknown,
+  loadSpec: LoadLinkedFormSpec,
+): Promise<FormInitData['linkedFormSpecs']> {
+  const pending = [...collectLinkedFormIds(rootSchema)];
+  const loaded = new Set<string>();
+  const specs: NonNullable<FormInitData['linkedFormSpecs']> = {};
+
+  while (pending.length > 0) {
+    const id = pending.pop()!;
+    if (loaded.has(id)) continue;
+    loaded.add(id);
+
+    try {
+      const spec = await loadSpec(id);
+      if (!spec.formSchema) continue;
+      specs[id] = {
+        schema: spec.formSchema,
+        uiSchema: spec.uiSchema ?? {},
+      };
+      for (const nested of collectLinkedFormIds(spec.formSchema)) {
+        if (!loaded.has(nested) && !pending.includes(nested)) {
+          pending.push(nested);
+        }
+      }
+    } catch (error) {
+      console.warn(
+        `[buildLinkedFormSpecs] Failed to load linked form "${id}":`,
+        error,
+      );
+    }
+  }
+
+  return Object.keys(specs).length > 0 ? specs : undefined;
+}
diff --git a/desktop/src/lib/collectLinkedFormIds.ts b/desktop/src/lib/collectLinkedFormIds.ts
new file mode 100644
index 000000000..677308804
--- /dev/null
+++ b/desktop/src/lib/collectLinkedFormIds.ts
@@ -0,0 +1,35 @@
+/** Collect linkedForm ids from a form schema (recursive). */
+export function collectLinkedFormIds(
+  schema: unknown,
+  out: Set<string> = new Set(),
+): Set<string> {
+  if (!schema || typeof schema !== 'object') return out;
+  const obj = schema as Record<string, unknown>;
+
+  if (typeof obj.linkedForm === 'string' && obj.linkedForm.trim()) {
+    out.add(obj.linkedForm.trim());
+  }
+
+  if (obj.properties && typeof obj.properties === 'object') {
+    for (const val of Object.values(
+      obj.properties as Record<string, unknown>,
+    )) {
+      collectLinkedFormIds(val, out);
+    }
+  }
+
+  if (obj.items && typeof obj.items === 'object') {
+    collectLinkedFormIds(obj.items, out);
+  }
+
+  for (const key of ['allOf', 'anyOf', 'oneOf'] as const) {
+    const branch = obj[key];
+    if (Array.isArray(branch)) {
+      for (const sub of branch) {
+        collectLinkedFormIds(sub, out);
+      }
+    }
+  }
+
+  return out;
+}
diff --git a/desktop/src/lib/formplayerHost.ts b/desktop/src/lib/formplayerHost.ts
index 6f380f5d1..d467d330a 100644
--- a/desktop/src/lib/formplayerHost.ts
+++ b/desktop/src/lib/formplayerHost.ts
@@ -43,6 +43,17 @@ export interface FormInitData {
   skipDraftSelection?: boolean;
   extensions?: ExtensionMetadata;
   customQuestionTypes?: unknown;
+  /**
+   * Linked child form specs for sub-observation column label resolution.
+   * Populated by the host at open time (Formulus / ODE Desktop preview).
+   */
+  linkedFormSpecs?: Record<
+    string,
+    {
+      schema: unknown;
+      uiSchema: unknown;
+    }
+  >;
 }
 
 /** @deprecated Use `FormInitData` */
diff --git a/desktop/src/lib/uiLocale.ts b/desktop/src/lib/uiLocale.ts
new file mode 100644
index 000000000..6cf31b636
--- /dev/null
+++ b/desktop/src/lib/uiLocale.ts
@@ -0,0 +1,75 @@
+/** Desktop UI locale — mirrors Formulus Settings key and resolution rules. */
+
+const STORAGE_KEY = '@ode/uiLocale';
+const ODE_UI_LOCALES = ['en', 'pt', 'fr'] as const;
+export type DesktopUiLocale = (typeof ODE_UI_LOCALES)[number];
+export type UiLocalePreference = 'auto' | DesktopUiLocale;
+
+function normalizeLocaleTag(tag: string): string {
+  return tag.trim().replace(/_/g, '-').toLowerCase();
+}
+
+function localeLookupCandidates(tag: string): string[] {
+  const normalized = normalizeLocaleTag(tag);
+  if (!normalized) return ['en'];
+  const parts = normalized.split('-');
+  const candidates: string[] = [normalized];
+  if (parts.length > 1) candidates.push(parts[0]!);
+  return candidates;
+}
+
+function matchOdeCatalogLocale(tag: string): DesktopUiLocale | null {
+  for (const candidate of localeLookupCandidates(tag)) {
+    if ((ODE_UI_LOCALES as readonly string[]).includes(candidate)) {
+      return candidate as DesktopUiLocale;
+    }
+  }
+  return null;
+}
+
+export function getDesktopLocalePreference(): UiLocalePreference {
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    if (
+      stored === 'auto' ||
+      stored === 'en' ||
+      stored === 'pt' ||
+      stored === 'fr'
+    ) {
+      return stored;
+    }
+  } catch {
+    // ignore
+  }
+  return 'auto';
+}
+
+export function setDesktopLocalePreference(
+  preference: UiLocalePreference,
+): void {
+  localStorage.setItem(STORAGE_KEY, preference);
+}
+
+export function resolveDesktopUiLocale(
+  sessionOverride?: string | null,
+  bundleDefaultLocale?: string | null,
+): DesktopUiLocale {
+  if (sessionOverride) {
+    const matched = matchOdeCatalogLocale(sessionOverride);
+    if (matched) return matched;
+  }
+
+  const preference = getDesktopLocalePreference();
+  if (preference !== 'auto') return preference;
+
+  const device = navigator.language || 'en';
+  const fromDevice = matchOdeCatalogLocale(device);
+  if (fromDevice) return fromDevice;
+
+  if (bundleDefaultLocale) {
+    const fromBundle = matchOdeCatalogLocale(bundleDefaultLocale);
+    if (fromBundle) return fromBundle;
+  }
+
+  return 'en';
+}
diff --git a/desktop/src/pages/FormPreviewPage.tsx b/desktop/src/pages/FormPreviewPage.tsx
index 317745108..ffd5144b2 100644
--- a/desktop/src/pages/FormPreviewPage.tsx
+++ b/desktop/src/pages/FormPreviewPage.tsx
@@ -6,7 +6,7 @@ import {
   type FormplayerEmbedHandle,
 } from '../components/FormplayerEmbed';
 import {
-  buildFormPreviewInit,
+  buildFormPreviewInitFromBundleSpec,
   inferObservationIdFromSavedData,
   parseJsonObject,
 } from '../lib/buildFormPreviewInit';
@@ -28,6 +28,11 @@ import {
   dropPendingSubObservationOpen,
   registerPendingSubObservationOpen,
 } from '../lib/formPreviewSubObservationBridge';
+import {
+  getDesktopLocalePreference,
+  setDesktopLocalePreference,
+  type UiLocalePreference,
+} from '../lib/uiLocale';
 
 const DEFAULT_JSON = '{}';
 
@@ -68,6 +73,8 @@ export function FormPreviewPage() {
   const [previewObservationId, setPreviewObservationId] = useState<
     string | null
   >(null);
+  const [uiLocalePreference, setUiLocalePreference] =
+    useState<UiLocalePreference>(() => getDesktopLocalePreference());
 
   const [formInitData, setFormInitData] = useState<FormInitData | null>(null);
 
@@ -148,6 +155,8 @@ export function FormPreviewPage() {
     }
   }, []);
 
+  const prevDevMirrorGenerationRef = useRef(devMirrorGeneration);
+
   useEffect(() => {
     void loadForms();
   }, [loadForms, devMirrorGeneration]);
@@ -163,20 +172,60 @@ export function FormPreviewPage() {
         s.formType,
         developerMode,
       );
-      return buildFormPreviewInit({
-        formType: s.formType,
+      return buildFormPreviewInitFromBundleSpec({
+        spec: s,
         observationId,
         params,
         savedData,
-        formSchema: s.formSchema,
-        uiSchema: s.uiSchema,
         extensions: ext.extensions,
         customQuestionTypes: ext.customQuestionTypes,
+        loadLinkedFormSpec: ft => tauriClient.readBundleFormSpec(ft),
       });
     },
     [developerMode],
   );
 
+  /** Re-read schema/ui/extensions from the (dev) bundle and remount formplayer. */
+  const reloadActivePreview = useCallback(async () => {
+    const formType = selectedFormType.trim();
+    if (!formType) {
+      return;
+    }
+    const p = parseJsonObject(paramsJson, 'params');
+    const sv = parseJsonObject(savedJson, 'savedData');
+    if (!p.ok || !sv.ok) {
+      return;
+    }
+    try {
+      const s = await tauriClient.readBundleFormSpec(formType);
+      setSpec(s);
+      setSpecError(null);
+      setFormInitData(
+        await buildInitFromSpec(s, p.value, sv.value, previewObservationId),
+      );
+    } catch (e) {
+      setSpecError(e instanceof Error ? e.message : String(e));
+    }
+  }, [
+    selectedFormType,
+    paramsJson,
+    savedJson,
+    previewObservationId,
+    buildInitFromSpec,
+  ]);
+
+  useEffect(() => {
+    if (prevDevMirrorGenerationRef.current === devMirrorGeneration) {
+      return;
+    }
+    prevDevMirrorGenerationRef.current = devMirrorGeneration;
+    nestedEmbedByMessageIdRef.current.clear();
+    nestedIframeByMessageIdRef.current.clear();
+    nestedContentWindowByMessageIdRef.current.clear();
+    setNestedSessions([]);
+    void reloadActivePreview();
+  }, [devMirrorGeneration, reloadActivePreview]);
+
   const loadSpec = useCallback(
     async (formType: string) => {
       if (!formType.trim()) {
@@ -345,18 +394,17 @@ export function FormPreviewPage() {
             developerMode,
           );
           const observationId = inferObservationIdFromSavedData(savedData);
-          const initData = buildFormPreviewInit({
-            formType,
+          const initData = await buildFormPreviewInitFromBundleSpec({
+            spec: s,
             observationId,
             params,
             savedData,
-            formSchema: s.formSchema,
-            uiSchema: s.uiSchema,
             extensions: ext.extensions,
             customQuestionTypes: ext.customQuestionTypes,
             subObservationMode: true,
             skipFinalize,
             skipDraftSelection,
+            loadLinkedFormSpec: ft => tauriClient.readBundleFormSpec(ft),
           });
           setNestedSessions(prev =>
             prev.map(sess =>
@@ -577,6 +625,39 @@ export function FormPreviewPage() {
               <option value="">{listLoading ? 'Loading…' : 'Form type'}</option>
               {formOptions}
             </select>
+            <label className="form-preview-label" htmlFor="ui-locale-select">
+              UI language
+            </label>
+            <select
+              id="ui-locale-select"
+              className="form-preview-type-select"
+              value={uiLocalePreference}
+              onChange={e => {
+                const v = e.target.value as UiLocalePreference;
+                setUiLocalePreference(v);
+                setDesktopLocalePreference(v);
+                if (spec) {
+                  void (async () => {
+                    const p = parseJsonObject(paramsJson, 'params');
+                    const sv = parseJsonObject(savedJson, 'savedData');
+                    if (p.ok && sv.ok) {
+                      setFormInitData(
+                        await buildInitFromSpec(
+                          spec,
+                          p.value,
+                          sv.value,
+                          previewObservationId,
+                        ),
+                      );
+                    }
+                  })();
+                }
+              }}>
+              <option value="auto">Auto (device)</option>
+              <option value="en">English</option>
+              <option value="pt">Português</option>
+              <option value="fr">Français</option>
+            </select>
             {listError ? (
               <p className="notice error">{listError}</p>
             ) : forms.length === 0 && !listLoading ? (
@@ -631,6 +712,7 @@ export function FormPreviewPage() {
 
         <div className="panel panel-form-preview-embed panel-embed-flush">
           <FormplayerEmbed
+            key={`${devMirrorGeneration}-${selectedFormType || 'none'}`}
             ref={iframeRef}
             onContentWindowReady={cw => {
               rootContentWindowRef.current = cw;
diff --git a/docs/custom-question-types.md b/docs/custom-question-types.md
index 054c1f66b..d5181c820 100644
--- a/docs/custom-question-types.md
+++ b/docs/custom-question-types.md
@@ -50,6 +50,9 @@ interface CustomQuestionTypeProps {
   // 3. Schema parameters. Any non-standard JSON Schema keys are passed here.
   config: Record<string, any>;
 
+  // 3b. Display strings from ui.json Control.options (after locale preprocess).
+  options?: Record<string, any>;
+
   // 4. Validation state for styling error cases
   validation: {
     error: boolean;
@@ -117,6 +120,29 @@ module.exports = {
 
 ---
 
+## Internationalization
+
+Custom question types use the **same** `ui.json` `translations` pattern as built-in controls. Put user-visible strings in `label`, `description`, and `Control.options` — not hardcoded in `renderer.js`:
+
+```json
+{
+  "type": "Control",
+  "scope": "#/properties/rating",
+  "label": "Rate this",
+  "options": { "hint": "Tap a star" },
+  "translations": {
+    "pt": {
+      "label": "Avalie",
+      "options": { "hint": "Toque numa estrela" }
+    }
+  }
+}
+```
+
+The renderer reads `props.options.hint`. Behavioral settings (`maxStars`, filters) stay in `schema.json` as `config`. See [Form translations](https://opendataensemble.org/docs/guides/form-translations).
+
+---
+
 ## Using it in your Form
 
 Once your custom question type is defined, use it in your form's `schema.json`.
diff --git a/formulus-formplayer/AGENTS.md b/formulus-formplayer/AGENTS.md
index ce0790119..002cdaf1a 100644
--- a/formulus-formplayer/AGENTS.md
+++ b/formulus-formplayer/AGENTS.md
@@ -58,6 +58,23 @@ This file gives AI assistants and developers enough context to work effectively
 3. **Custom question types**: Loaded from a **manifest** (source strings) from the RN app, evaluated in a sandbox with `React` and `MaterialUI` on `window`. They use **format** in the schema (e.g. `"format": "signature"`), not only `type`. Contract: `src/types/CustomQuestionTypeContract.ts`.
 4. **Design tokens**: Use `@ode/tokens` via `src/theme/tokens-adapter.ts` and the theme in `src/theme/theme.ts`; avoid hardcoding colors/spacing that exist in tokens.
 5. **Attachment-backed builtins** (`photo`, `audio`, `video`, `select_file`): Observation JSON stores **basename-only** `filename` plus portable metadata; RN writes files under **`attachments/draft/`** (etc.). Resolve previews with **`getAttachmentUri`** where applicable. **`select_file`** shows the chosen **name** only—no file preview.
+
+## Internationalization (i18n)
+
+Two **independent** layers:
+
+| Layer      | Owner       | Mechanism                                                                                 |
+| ---------- | ----------- | ----------------------------------------------------------------------------------------- |
+| ODE chrome | ODE         | `src/locales/{en,pt,fr}.json`, `createOdeI18n()`, JsonForms `i18n` prop, `useOdeT()` hook |
+| Form copy  | Form author | Optional `translations` on `ui.json`; `applyFormUiTranslations()` at init in `App.tsx`    |
+
+- Host passes `params.locale` (reserved bridge key, not observation data).
+- Custom question types receive localized `options` from `ui.json` via `CustomQuestionTypeAdapter`.
+- Display labels: `src/utils/controlDisplayText.ts` (`resolveControlLabel`, `resolveFieldLabel`) — use in renderers, SwipeLayout `headerFields`, Finalize, and error summaries instead of ad-hoc `uischema.label || schema.title`.
+- `translations.<locale>.title` aliases to `Control.label` when `label` is absent in that block.
+- Sub-observation column headers: `key` in schema; labels resolved from linked child form via `linkedFormSpecs` on `FormInitData` (Formulus loads at open). See `subObservationColumnLabels.ts`.
+- Docs: [form translations](https://opendataensemble.org/docs/guides/form-translations).
+
 6. **Numeric inputs** (`type: integer` / `type: number`): Built-in control is **`NumberStepperRenderer`** (`src/renderers/NumberStepperRenderer.tsx`) backed by **`useNumericDraftInput`** (`src/hooks/useNumericDraftInput.ts`). Policy: **draft text while focused** (`type="text"` + `inputMode` + `enterKeyHint` from `FormContext`); observation JSON stores **JSON numbers only** (parse on commit, never strings); **never clamp** to `minimum`/`maximum` while typing—surface AJV errors instead. Custom numeric question types must follow the same contract (see `CustomQuestionTypeContract.ts`).
 
 ## Adding or changing behavior
diff --git a/formulus-formplayer/README.md b/formulus-formplayer/README.md
index d25e8e7e8..04293ba41 100644
--- a/formulus-formplayer/README.md
+++ b/formulus-formplayer/README.md
@@ -31,6 +31,11 @@ If you run `pnpm install` only in formulus-formplayer, the tokens package’s `p
 
 Use `pnpm run build:copy` to build the project and copy the bundle into the Formulus app (Android + iOS) and ODE Desktop (`desktop/public/formplayer_dist/`).
 
+## Internationalization
+
+- **ODE chrome** — `src/locales/{en,pt,fr}.json`, wired via `createOdeI18n()` and JsonForms `i18n`. Host sets `params.locale`.
+- **Form copy** — optional `translations` objects on `ui.json`; merged once at init by `applyFormUiTranslations()`. See [form translations](https://opendataensemble.org/docs/guides/form-translations).
+
 ## Javascript interface
 
 The javascript interface made available to the custom app is as follows:
diff --git a/formulus-formplayer/src/App.tsx b/formulus-formplayer/src/App.tsx
index 7ea7fdb27..dfa85221e 100644
--- a/formulus-formplayer/src/App.tsx
+++ b/formulus-formplayer/src/App.tsx
@@ -14,7 +14,11 @@ import {
   materialRenderers,
   materialCells,
 } from '@jsonforms/material-renderers';
-import { JsonSchema7, JsonFormsRendererRegistryEntry } from '@jsonforms/core';
+import {
+  JsonSchema7,
+  JsonFormsRendererRegistryEntry,
+  UISchemaElement,
+} from '@jsonforms/core';
 import {
   Alert,
   Snackbar,
@@ -46,6 +50,12 @@ import {
   applyStickyDefaults,
 } from './utils/stickyFieldHelpers';
 import { stickyService } from './services/StickyService';
+import { applyFormUiTranslations } from './i18n/applyFormUiTranslations';
+import { LinkedFormSpecsMap } from './utils/controlDisplayText';
+import { createOdeI18n } from './i18n/createOdeI18n';
+import { odeT } from './i18n/createOdeI18n';
+import { resolveFormplayerLocale, type OdeUiLocale } from './i18n/localeUtils';
+import { FormplayerLocaleContext } from './i18n/FormplayerLocaleContext';
 
 import SwipeLayoutRenderer, {
   swipeLayoutTester,
@@ -152,6 +162,30 @@ function isMockActive(): boolean {
     (window as any).__FORMULUS_MOCK_ACTIVE__
   );
 }
+
+/** When formplayer runs outside a native WebView (and dev mock is off), fail fast without an effect. */
+function getStandaloneBrowserInitState(): {
+  isLoading: boolean;
+  loadError: string | null;
+} {
+  if (typeof window === 'undefined') {
+    return { isLoading: true, loadError: null };
+  }
+  if (window.ReactNativeWebView?.postMessage) {
+    return { isLoading: true, loadError: null };
+  }
+  if (isMockActive()) {
+    return { isLoading: true, loadError: null };
+  }
+  return {
+    isLoading: false,
+    loadError: odeT(
+      'en',
+      'form.noNativeHost',
+      'Cannot communicate with native host. Formplayer might be running in a standalone browser.',
+    ),
+  };
+}
 const DevTestbedLazy = import.meta.env.DEV
   ? React.lazy(() => import('./mocks/DevTestbed'))
   : null;
@@ -291,6 +325,27 @@ interface FormContextType {
    * debounce races where `handleChange` alone does not reach `onChange` in time.
    */
   commitFormData?: (data: Record<string, unknown>) => void;
+  /** Localized specs for linked child forms (sub-observation column labels). */
+  linkedFormSpecs?: LinkedFormSpecsMap;
+}
+
+function prepareLinkedFormSpecs(
+  raw: FormInitData['linkedFormSpecs'],
+  locale: string,
+): LinkedFormSpecsMap {
+  if (!raw || typeof raw !== 'object') return {};
+  const out: LinkedFormSpecsMap = {};
+  for (const [id, spec] of Object.entries(raw)) {
+    if (!spec || typeof spec !== 'object') continue;
+    const schema = spec.schema as JsonSchema7 | undefined;
+    const uiRaw = spec.uiSchema as UISchemaElement | undefined;
+    if (!schema || !uiRaw) continue;
+    out[id] = {
+      schema,
+      uiSchema: applyFormUiTranslations(uiRaw, locale) as UISchemaElement,
+    };
+  }
+  return out;
 }
 
 export const FormContext = createContext<FormContextType>({
@@ -298,6 +353,7 @@ export const FormContext = createContext<FormContextType>({
   keyboardEnterKeyHint: undefined,
   draftSessionKey: null,
   commitFormData: undefined,
+  linkedFormSpecs: undefined,
 });
 
 export const useFormContext = () => useContext(FormContext);
@@ -350,8 +406,12 @@ function App() {
   const [schema, setSchema] = useState<FormSchema | null>(null);
   const [uischema, setUISchema] = useState<FormUISchema | null>(null);
 
-  const [isLoading, setIsLoading] = useState<boolean>(true);
-  const [loadError, setLoadError] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState<boolean>(
+    () => getStandaloneBrowserInitState().isLoading,
+  );
+  const [loadError, setLoadError] = useState<string | null>(
+    () => getStandaloneBrowserInitState().loadError,
+  );
   const [showFinalizeMessage, setShowFinalizeMessage] = useState(false);
   const [submitError, setSubmitError] = useState<string | null>(null);
   const [formInitData, setFormInitData] = useState<FormInitData | null>(null);
@@ -391,10 +451,20 @@ function App() {
   const [validationMode, setValidationMode] = useState<
     'ValidateAndShow' | 'ValidateAndHide' | 'NoValidation'
   >('ValidateAndShow');
+  const [uiLocale, setUiLocale] = useState<OdeUiLocale>('en');
+  const uiLocaleRef = useRef(uiLocale);
+  uiLocaleRef.current = uiLocale;
+  const [linkedFormSpecs, setLinkedFormSpecs] = useState<
+    LinkedFormSpecsMap | undefined
+  >(undefined);
+
+  const odeI18n = useMemo(() => createOdeI18n(uiLocale), [uiLocale]);
 
   // Reference to the FormulusClient instance and loading state
   const formulusClient = useRef<FormulusClient>(FormulusClient.getInstance());
-  const isLoadingRef = useRef<boolean>(true); // Use a ref to track loading state for the timeout
+  const isLoadingRef = useRef<boolean>(
+    getStandaloneBrowserInitState().isLoading,
+  );
 
   // Separate function to handle actual form initialization
   const initializeForm = useCallback(
@@ -430,6 +500,14 @@ function App() {
 
         setFormInitData(initData);
 
+        const resolvedLocale = resolveFormplayerLocale(
+          (params as Record<string, unknown> | null)?.locale,
+        );
+        setUiLocale(resolvedLocale);
+        setLinkedFormSpecs(
+          prepareLinkedFormSpecs(initData.linkedFormSpecs, resolvedLocale),
+        );
+
         // Debug: log schema details, especially x-dynamicEnum usage
         try {
           const properties = (formSchema as any)?.properties || {};
@@ -571,26 +649,30 @@ function App() {
             'formSchema was not provided. Form rendering might fail or be incomplete.',
           );
           setLoadError(
-            'Form schema is missing. Form rendering might fail or be incomplete.',
+            odeT(
+              resolvedLocale,
+              'form.schemaMissing',
+              'Form schema is missing. Form rendering might fail or be incomplete.',
+            ),
           );
           setSchema({} as FormSchema); // Set to empty schema or handle as per requirements
           // First ensure SwipeLayout root, then process to ensure Finalize element is present
           const swipeLayoutUISchema = ensureSwipeLayoutRoot(null);
-          const processedUISchema = processUISchemaWithFinalize(
-            swipeLayoutUISchema,
-            skipFinalize,
+          const withLocale = applyFormUiTranslations(
+            processUISchemaWithFinalize(swipeLayoutUISchema, skipFinalize),
+            resolvedLocale,
           );
-          setUISchema(processedUISchema);
+          setUISchema(withLocale);
         } else {
           setSchema(formSchema as FormSchema);
           const swipeLayoutUISchema = ensureSwipeLayoutRoot(
             uiSchema as FormUISchema,
           );
-          const processedUISchema = processUISchemaWithFinalize(
-            swipeLayoutUISchema,
-            skipFinalize,
+          const withLocale = applyFormUiTranslations(
+            processUISchemaWithFinalize(swipeLayoutUISchema, skipFinalize),
+            resolvedLocale,
           );
-          setUISchema(processedUISchema);
+          setUISchema(withLocale);
         }
 
         const formSchemaTyped = formSchema as FormSchema | null;
@@ -693,7 +775,12 @@ function App() {
           error instanceof Error
             ? error.message
             : 'Unknown error during form initialization';
-        setLoadError(`Error initializing form: ${errorMessage}`);
+        const errorLocale = resolveFormplayerLocale(
+          (initData.params as Record<string, unknown> | null)?.locale,
+        );
+        setLoadError(
+          `${odeT(errorLocale, 'form.errorInitializing', 'Error initializing form')}: ${errorMessage}`,
+        );
         setIsLoading(false);
         isLoadingRef.current = false;
       }
@@ -721,7 +808,13 @@ function App() {
           console.error(
             'formType is crucial and was not provided in onFormInit. Cannot proceed.',
           );
-          setLoadError('Form ID is missing. Cannot initialize form.');
+          setLoadError(
+            odeT(
+              resolveFormplayerLocale(initData.params?.locale),
+              'form.missingFormId',
+              'Form ID is missing. Cannot initialize form.',
+            ),
+          );
           if (
             window.ReactNativeWebView &&
             window.ReactNativeWebView.postMessage
@@ -757,8 +850,12 @@ function App() {
             console.log(
               `Found ${availableDrafts.length} draft(s) for form ${receivedFormType}, showing draft selector`,
             );
-            // Apply theme from params so draft selector respects light/dark mode
+            // Apply theme and locale from params so draft selector matches the session
             const params = initData.params;
+            const resolvedLocale = resolveFormplayerLocale(
+              (params as Record<string, unknown> | null)?.locale,
+            );
+            setUiLocale(resolvedLocale);
             const isDarkMode = params?.darkMode === true;
             setDarkMode(isDarkMode);
             if (params?.themeColors && typeof params.themeColors === 'object') {
@@ -781,7 +878,9 @@ function App() {
           error instanceof Error
             ? error.message
             : 'Unknown error during form initialization';
-        setLoadError(`Error processing form data: ${errorMessage}`);
+        setLoadError(
+          `${odeT(resolveFormplayerLocale(initData.params?.locale), 'form.errorProcessing', 'Error processing form data')}: ${errorMessage}`,
+        );
         if (
           window.ReactNativeWebView &&
           window.ReactNativeWebView.postMessage
@@ -816,9 +915,7 @@ function App() {
 
     globalAny.__formplayerOnInitRegistered = true;
 
-    // eslint-disable-next-line react-hooks/set-state-in-effect
-    setIsLoading(true);
-    isLoadingRef.current = true;
+    // isLoading / isLoadingRef already start true (see useState/useRef above).
 
     console.log('Registering window.onFormInit handler.');
     globalAny.onFormInit = handleFormInitByNative;
@@ -840,26 +937,10 @@ function App() {
       console.log('Debug - NODE_ENV:', process.env.NODE_ENV);
       console.log('Debug - isMockActive():', isMockActive());
       console.log('Debug - isLoadingRef.current:', isLoadingRef.current);
-
-      // Potentially set an error or handle standalone mode if WebView context isn't available
-      // For example, if running in a standard browser for development
-      if (isLoadingRef.current) {
-        // Avoid setting error if already handled by timeout or success
-        if (isMockActive()) {
-          console.log(
-            'Development mode: WebView mock is active, continuing without error',
-          );
-          // Don't set error in development mode when mock is active
-        } else {
-          console.log(
-            'Setting error message because mock is not active or not in development',
-          );
-          setLoadError(
-            'Cannot communicate with native host. Formplayer might be running in a standalone browser.',
-          );
-          setIsLoading(false);
-          isLoadingRef.current = false;
-        }
+      if (!isMockActive() && isLoadingRef.current) {
+        console.log(
+          'Standalone browser without native host (load error set at init).',
+        );
       }
     }
 
@@ -884,7 +965,11 @@ function App() {
               '[Formplayer] onFormInit timeout: Form failed to initialize after extended wait.',
             );
             setLoadError(
-              'Failed to initialize form: No data received from native host. Please try again.',
+              odeT(
+                uiLocaleRef.current,
+                'form.initTimeout',
+                'Failed to initialize form: No data received from native host. Please try again.',
+              ),
             );
             setIsLoading(false);
             isLoadingRef.current = false;
@@ -915,7 +1000,7 @@ function App() {
         console.log('Unregistered window.onFormInit handler.');
       }
     };
-  }, [handleFormInitByNative]); // Dependency: re-run if handleFormInitByNative changes
+  }, [handleFormInitByNative]);
 
   // Attachment handling is now fully encapsulated within individual components
   // using the Promise-based media/action APIs exposed by Formulus.
@@ -1132,7 +1217,11 @@ function App() {
           '[App.tsx] Cannot finalize form: formInitData is missing',
         );
         setSubmitError(
-          'Cannot submit form because initialization data is missing.',
+          odeT(
+            uiLocale,
+            'form.submitMissingInit',
+            'Cannot submit form because initialization data is missing.',
+          ),
         );
         return;
       }
@@ -1149,7 +1238,11 @@ function App() {
       if (finalizeValidatorErrors.length > 0) {
         setCustomValidatorErrors(finalizeValidatorErrors);
         setSubmitError(
-          'Cannot submit form until custom validation errors are resolved.',
+          odeT(
+            uiLocale,
+            'form.submitValidatorErrors',
+            'Cannot submit form until custom validation errors are resolved.',
+          ),
         );
         return;
       }
@@ -1188,7 +1281,13 @@ function App() {
         })
         .catch(error => {
           console.error('[App.tsx] Error submitting form:', error);
-          setSubmitError('Failed to submit form. Please try again.');
+          setSubmitError(
+            odeT(
+              uiLocale,
+              'form.submitFailed',
+              'Failed to submit form. Please try again.',
+            ),
+          );
         });
     };
 
@@ -1227,7 +1326,15 @@ function App() {
         handleRevalidate as EventListener,
       );
     };
-  }, [formInitData, draftSessionKey, uischema, schema, ajv, refreshFormData]);
+  }, [
+    formInitData,
+    draftSessionKey,
+    uischema,
+    schema,
+    ajv,
+    refreshFormData,
+    uiLocale,
+  ]);
 
   // Create dynamic theme based on dark mode preference and custom app colors.
   // When a custom app provides themeColors, they override the default palette
@@ -1264,13 +1371,15 @@ function App() {
   if (showDraftSelector && pendingFormInit) {
     return (
       <ThemeProvider theme={currentTheme}>
-        <DraftSelector
-          formType={pendingFormInit.formType}
-          formVersion={(pendingFormInit.formSchema as any)?.version}
-          onResumeDraft={handleResumeDraft}
-          onStartNew={handleStartNewForm}
-          fullScreen={true}
-        />
+        <FormplayerLocaleContext.Provider value={uiLocale}>
+          <DraftSelector
+            formType={pendingFormInit.formType}
+            formVersion={(pendingFormInit.formSchema as any)?.version}
+            onResumeDraft={handleResumeDraft}
+            onStartNew={handleStartNewForm}
+            fullScreen={true}
+          />
+        </FormplayerLocaleContext.Provider>
       </ThemeProvider>
     );
   }
@@ -1288,10 +1397,14 @@ function App() {
         }}>
         <CircularProgress />
         <Typography variant="h6" sx={{ mt: 2 }}>
-          Loading form...
+          {odeT(uiLocale, 'form.loading', 'Loading form...')}
         </Typography>
         <Typography variant="body2" sx={{ mt: 1, color: 'text.secondary' }}>
-          Waiting for data from Formulus...
+          {odeT(
+            uiLocale,
+            'form.waitingForData',
+            'Waiting for data from Formulus...',
+          )}
         </Typography>
       </Box>
     );
@@ -1316,7 +1429,7 @@ function App() {
             variant="h6"
             color="error"
             sx={{ mb: 2, textAlign: 'center' }}>
-            Error Loading Form
+            {odeT(uiLocale, 'form.errorLoading', 'Error Loading Form')}
           </Typography>
           <Typography
             variant="body2"
@@ -1344,7 +1457,7 @@ function App() {
         }}>
         <CircularProgress />
         <Typography variant="h6" sx={{ mt: 2 }}>
-          Loading form...
+          {odeT(uiLocale, 'form.loading', 'Loading form...')}
         </Typography>
       </Box>
     );
@@ -1361,110 +1474,122 @@ function App() {
 
   return (
     <ThemeProvider theme={currentTheme}>
-      <FormContext.Provider
-        value={{ formInitData, draftSessionKey, commitFormData }}>
-        <div
-          className="App"
-          style={{
-            display: 'flex',
-            height: '100%', // Fill WebView; host resizes for keyboard (adjustResize)
-            width: '100%',
-            backgroundColor: currentTheme.palette.background.default, // Ensure dark background
-            color: currentTheme.palette.text.primary,
+      <FormplayerLocaleContext.Provider value={uiLocale}>
+        <FormContext.Provider
+          value={{
+            formInitData,
+            draftSessionKey,
+            commitFormData,
+            linkedFormSpecs,
           }}>
-          {/* Main app content - 60% width in development mode */}
           <div
+            className="App"
             style={{
-              width: process.env.NODE_ENV === 'development' ? '60%' : '100%',
-              overflow: 'hidden', // Prevent outer scrolling - FormLayout handles scrolling internally
-              padding: tokens.spacing[1],
-              boxSizing: 'border-box',
-              height: '100%', // Ensure it takes full height
-              backgroundColor: 'transparent', // Use theme background
+              display: 'flex',
+              height: '100%', // Fill WebView; host resizes for keyboard (adjustResize)
+              width: '100%',
+              backgroundColor: currentTheme.palette.background.default, // Ensure dark background
+              color: currentTheme.palette.text.primary,
             }}>
-            <ErrorBoundary>
-              {loadError ? (
-                <Box
-                  sx={{
-                    padding: tokens.spacing[5],
-                    backgroundColor: 'error.light',
-                    border: `${tokens.border.width.thin} solid`,
-                    borderColor: 'error.main',
-                    borderRadius: tokens.border.radius.md, // Match button border radius
-                    color: 'error.dark',
-                  }}>
-                  <Typography variant="h6" color="error">
-                    Error Loading Form
-                  </Typography>
-                  <Typography variant="body2" sx={{ mt: 1 }}>
-                    {loadError}
-                  </Typography>
-                </Box>
-              ) : (
-                <>
-                  <FormEvaluationProvider functions={extensionFunctions}>
-                    <JsonForms
-                      schema={schema}
-                      uischema={uischema}
-                      data={data}
-                      renderers={[
-                        ...shellMaterialRenderers,
-                        ...materialRenderers,
-                        ...customRenderers,
-                        ...customTypeRenderers, // Custom question types from custom_app
-                        ...extensionRenderers, // Extension renderers (highest priority)
-                      ]}
-                      cells={materialCells}
-                      onChange={handleDataChange}
-                      validationMode={validationMode}
-                      ajv={ajv}
-                      additionalErrors={customValidatorErrors}
-                    />
-                  </FormEvaluationProvider>
-                  {/* Success Snackbar */}
-                  <Snackbar
-                    open={showFinalizeMessage}
-                    autoHideDuration={6000}
-                    onClose={() => setShowFinalizeMessage(false)}>
-                    <Alert
-                      onClose={() => setShowFinalizeMessage(false)}
-                      severity="info">
-                      Form submitted successfully!
-                    </Alert>
-                  </Snackbar>
-                  {/* Error Snackbar for submit failures */}
-                  <Snackbar
-                    open={Boolean(submitError)}
-                    autoHideDuration={6000}
-                    onClose={() => setSubmitError(null)}>
-                    <Alert
-                      onClose={() => setSubmitError(null)}
-                      severity="error">
-                      {submitError}
-                    </Alert>
-                  </Snackbar>
-                </>
-              )}
-            </ErrorBoundary>
-          </div>
-
-          {/* Development testbed - 40% width in development mode (lazy-loaded, not in production bundle) */}
-          {DevTestbedLazy && (
+            {/* Main app content - 60% width in development mode */}
             <div
               style={{
-                width: '40%',
-                borderLeft: `${tokens.border.width.medium} solid ${tokens.color.neutral[200]}`,
-                backgroundColor: tokens.color.neutral[50],
+                width: process.env.NODE_ENV === 'development' ? '60%' : '100%',
+                overflow: 'hidden', // Prevent outer scrolling - FormLayout handles scrolling internally
+                padding: tokens.spacing[1],
+                boxSizing: 'border-box',
+                height: '100%', // Ensure it takes full height
+                backgroundColor: 'transparent', // Use theme background
               }}>
               <ErrorBoundary>
-                <React.Suspense fallback={null}>
-                  <DevTestbedLazy isVisible={true} />
-                </React.Suspense>
+                {loadError ? (
+                  <Box
+                    sx={{
+                      padding: tokens.spacing[5],
+                      backgroundColor: 'error.light',
+                      border: `${tokens.border.width.thin} solid`,
+                      borderColor: 'error.main',
+                      borderRadius: tokens.border.radius.md, // Match button border radius
+                      color: 'error.dark',
+                    }}>
+                    <Typography variant="h6" color="error">
+                      Error Loading Form
+                    </Typography>
+                    <Typography variant="body2" sx={{ mt: 1 }}>
+                      {loadError}
+                    </Typography>
+                  </Box>
+                ) : (
+                  <>
+                    <FormEvaluationProvider functions={extensionFunctions}>
+                      <JsonForms
+                        schema={schema}
+                        uischema={uischema}
+                        data={data}
+                        i18n={odeI18n}
+                        renderers={[
+                          ...shellMaterialRenderers,
+                          ...materialRenderers,
+                          ...customRenderers,
+                          ...customTypeRenderers, // Custom question types from custom_app
+                          ...extensionRenderers, // Extension renderers (highest priority)
+                        ]}
+                        cells={materialCells}
+                        onChange={handleDataChange}
+                        validationMode={validationMode}
+                        ajv={ajv}
+                        additionalErrors={customValidatorErrors}
+                      />
+                    </FormEvaluationProvider>
+                    {/* Success Snackbar */}
+                    <Snackbar
+                      open={showFinalizeMessage}
+                      autoHideDuration={6000}
+                      onClose={() => setShowFinalizeMessage(false)}>
+                      <Alert
+                        onClose={() => setShowFinalizeMessage(false)}
+                        severity="info">
+                        {odeT(
+                          uiLocale,
+                          'form.submitSuccess',
+                          'Form submitted successfully!',
+                        )}
+                      </Alert>
+                    </Snackbar>
+                    {/* Error Snackbar for submit failures */}
+                    <Snackbar
+                      open={Boolean(submitError)}
+                      autoHideDuration={6000}
+                      onClose={() => setSubmitError(null)}>
+                      <Alert
+                        onClose={() => setSubmitError(null)}
+                        severity="error">
+                        {submitError}
+                      </Alert>
+                    </Snackbar>
+                  </>
+                )}
               </ErrorBoundary>
             </div>
-          )}
-        </div>
-      </FormContext.Provider>
+
+            {/* Development testbed - 40% width in development mode (lazy-loaded, not in production bundle) */}
+            {DevTestbedLazy && (
+              <div
+                style={{
+                  width: '40%',
+                  borderLeft: `${tokens.border.width.medium} solid ${tokens.color.neutral[200]}`,
+                  backgroundColor: tokens.color.neutral[50],
+                }}>
+                <ErrorBoundary>
+                  <React.Suspense fallback={null}>
+                    <DevTestbedLazy isVisible={true} />
+                  </React.Suspense>
+                </ErrorBoundary>
+              </div>
+            )}
+          </div>
+        </FormContext.Provider>
+      </FormplayerLocaleContext.Provider>
     </ThemeProvider>
   );
 }
diff --git a/formulus-formplayer/src/components/DraftSelector.tsx b/formulus-formplayer/src/components/DraftSelector.tsx
index 454da4e59..aed60c4ee 100644
--- a/formulus-formplayer/src/components/DraftSelector.tsx
+++ b/formulus-formplayer/src/components/DraftSelector.tsx
@@ -21,6 +21,7 @@ import {
 import { Button } from '@ode/components/react-web';
 import { Delete as DeleteIcon } from '@mui/icons-material';
 import { draftService, DraftSummary } from '../services/DraftService';
+import { useOdeT } from '../i18n/useOdeT';
 
 interface DraftSelectorProps {
   /** The form type to show drafts for */
@@ -50,6 +51,7 @@ export const DraftSelector: React.FC<DraftSelectorProps> = ({
   fullScreen = false,
 }) => {
   const theme = useTheme();
+  const t = useOdeT();
   const [drafts, setDrafts] = useState<DraftSummary[]>([]);
   const [deleteConfirmOpen, setDeleteConfirmOpen] = useState(false);
   const [draftToDelete, setDraftToDelete] = useState<string | null>(null);
@@ -64,12 +66,19 @@ export const DraftSelector: React.FC<DraftSelectorProps> = ({
     const oldDraftCount = draftService.getOldDraftCount();
     if (oldDraftCount > 0) {
       setCleanupMessage(
-        `${oldDraftCount} draft${
-          oldDraftCount === 1 ? '' : 's'
-        } older than 7 days will be automatically removed.`,
+        oldDraftCount === 1
+          ? t(
+              'draft.cleanupOldOne',
+              '1 draft older than 7 days will be automatically removed.',
+            )
+          : t(
+              'draft.cleanupOldMany',
+              '{{count}} drafts older than 7 days will be automatically removed.',
+              { count: oldDraftCount },
+            ),
       );
     }
-  }, [formType, formVersion]);
+  }, [formType, formVersion, t]);
 
   useEffect(() => {
     // eslint-disable-next-line react-hooks/set-state-in-effect
@@ -111,7 +120,9 @@ export const DraftSelector: React.FC<DraftSelectorProps> = ({
         <Typography
           variant="subtitle2"
           sx={{ fontWeight: 600, mb: 0.75, textAlign: 'left' }}>
-          Recent drafts ({drafts.length})
+          {t('draft.recentDrafts', 'Recent drafts ({{count}})', {
+            count: drafts.length,
+          })}
         </Typography>
         <Box
           sx={{
@@ -139,7 +150,9 @@ export const DraftSelector: React.FC<DraftSelectorProps> = ({
                   color="text.primary"
                   noWrap
                   sx={{ textAlign: 'left' }}>
-                  Draft saved {formatDate(draft.updatedAt)}
+                  {t('draft.savedAtLine', 'Draft saved {{date}}', {
+                    date: formatDate(draft.updatedAt),
+                  })}
                 </Typography>
               </Box>
               <Box
@@ -153,7 +166,7 @@ export const DraftSelector: React.FC<DraftSelectorProps> = ({
                   variant="neutral"
                   size="small"
                   onPress={() => onResumeDraft(draft.id)}>
-                  Resume
+                  {t('draft.resume', 'Resume')}
                 </Button>
                 <IconButton
                   onClick={() => handleDeleteDraft(draft.id)}
@@ -169,7 +182,7 @@ export const DraftSelector: React.FC<DraftSelectorProps> = ({
     ) : (
       <Box sx={{ textAlign: 'left', py: 2, mt: 1 }}>
         <Typography variant="body2" color="text.secondary">
-          No recent drafts found for this form.
+          {t('draft.none', 'No recent drafts found for this form.')}
         </Typography>
       </Box>
     );
@@ -207,13 +220,13 @@ export const DraftSelector: React.FC<DraftSelectorProps> = ({
             mb: 0.5,
             textAlign: 'left',
           }}>
-          Resume Draft or Start New
+          {t('draft.title', 'Resume Draft or Start New')}
         </Typography>
         <Typography
           variant="body2"
           color="text.secondary"
           sx={{ textAlign: 'left' }}>
-          Form: {formType}
+          {t('draft.formLabel', 'Form: {{formType}}', { formType })}
           {formVersion && (
             <Chip label={`v${formVersion}`} size="small" sx={{ ml: 1 }} />
           )}
@@ -238,7 +251,7 @@ export const DraftSelector: React.FC<DraftSelectorProps> = ({
               gutterBottom
               color="text.primary"
               sx={{ fontWeight: 600, textAlign: 'left' }}>
-              New Form
+              {t('draft.newFormSection', 'New Form')}
             </Typography>
             <Box sx={{ textAlign: 'center', mt: 0.5 }}>
               <Button
@@ -246,7 +259,7 @@ export const DraftSelector: React.FC<DraftSelectorProps> = ({
                 size="medium"
                 onPress={onStartNew}
                 style={{ minWidth: 180 }}>
-                Start New Form
+                {t('draft.startNew', 'Start New Form')}
               </Button>
             </Box>
           </Box>
@@ -260,21 +273,23 @@ export const DraftSelector: React.FC<DraftSelectorProps> = ({
           <Dialog
             open={deleteConfirmOpen}
             onClose={() => setDeleteConfirmOpen(false)}>
-            <DialogTitle>Delete Draft</DialogTitle>
+            <DialogTitle>{t('draft.delete', 'Delete Draft')}</DialogTitle>
             <DialogContent>
               <Typography>
-                Are you sure you want to delete this draft? This action cannot
-                be undone.
+                {t(
+                  'draft.deleteConfirm',
+                  'Are you sure you want to delete this draft? This action cannot be undone.',
+                )}
               </Typography>
             </DialogContent>
             <DialogActions>
               <Button
                 variant="neutral"
                 onPress={() => setDeleteConfirmOpen(false)}>
-                Cancel
+                {t('draft.cancel', 'Cancel')}
               </Button>
               <Button variant="danger" onPress={confirmDeleteDraft}>
-                Delete
+                {t('draft.delete', 'Delete')}
               </Button>
             </DialogActions>
           </Dialog>
diff --git a/formulus-formplayer/src/components/FormLayout.tsx b/formulus-formplayer/src/components/FormLayout.tsx
index 1c0d18f78..8647d7e62 100644
--- a/formulus-formplayer/src/components/FormLayout.tsx
+++ b/formulus-formplayer/src/components/FormLayout.tsx
@@ -2,6 +2,7 @@ import React, { ReactNode, useCallback } from 'react';
 import { Box, Paper } from '@mui/material';
 import { Button } from '@ode/components/react-web';
 import { useKeyboardScrollClamp } from '../hooks/useKeyboardScrollClamp';
+import { useOdeT } from '../i18n/useOdeT';
 
 /** Keeps a submit control in the DOM so mobile keyboards can trigger the primary action (Go / Send / →). */
 const visuallyHiddenSubmitStyle: React.CSSProperties = {
@@ -104,6 +105,7 @@ const FormLayout: React.FC<FormLayoutProps> = ({
   scrollRefMerge,
   scrollHandlers,
 }) => {
+  const t = useOdeT();
   const scrollRef = useKeyboardScrollClamp<HTMLDivElement>();
 
   const mergedScrollRef = useCallback(
@@ -193,7 +195,7 @@ const FormLayout: React.FC<FormLayoutProps> = ({
                 disabled={previousButton.disabled}
                 size="medium"
                 style={{ width: '100%', maxWidth: '100%' }}>
-                {previousButton.label || 'Previous'}
+                {previousButton.label || t('nav.previous', 'Previous')}
               </Button>
             )}
           </Box>
@@ -213,7 +215,7 @@ const FormLayout: React.FC<FormLayoutProps> = ({
                 size="medium"
                 className="formplayer-solid-primary"
                 style={{ width: '100%', maxWidth: '100%' }}>
-                {nextButton.label || 'Next'}
+                {nextButton.label || t('nav.next', 'Next')}
               </Button>
             )}
           </Box>
diff --git a/formulus-formplayer/src/components/QuestionShell.tsx b/formulus-formplayer/src/components/QuestionShell.tsx
index cb07e0087..9b0d26b9b 100644
--- a/formulus-formplayer/src/components/QuestionShell.tsx
+++ b/formulus-formplayer/src/components/QuestionShell.tsx
@@ -127,6 +127,8 @@ const QuestionShell: React.FC<QuestionShellProps> = ({
   const effectiveLayout = labelLayout ?? contextLayout;
   const useInline = !block && effectiveLayout === 'inline' && Boolean(title);
   const labelVerticalAlign = description ? 'top' : 'middle';
+  /** Block controls (QR, photo, …) among inline rows need matching top inset. */
+  const blockAmongInlineRows = block && effectiveLayout === 'inline';
 
   const rowDividerColor = isDark
     ? tokens.color.neutral[600]
@@ -178,6 +180,7 @@ const QuestionShell: React.FC<QuestionShellProps> = ({
         display: 'flex',
         flexDirection: 'column',
         gap: 1,
+        ...(blockAmongInlineRows && { pt: INLINE_ROW_PY }),
         ...(useInline && {
           position: 'relative',
           '&::after': {
diff --git a/formulus-formplayer/src/i18n/FormplayerLocaleContext.tsx b/formulus-formplayer/src/i18n/FormplayerLocaleContext.tsx
new file mode 100644
index 000000000..412757f0a
--- /dev/null
+++ b/formulus-formplayer/src/i18n/FormplayerLocaleContext.tsx
@@ -0,0 +1,4 @@
+import { createContext } from 'react';
+import type { OdeUiLocale } from './localeUtils';
+
+export const FormplayerLocaleContext = createContext<OdeUiLocale>('en');
diff --git a/formulus-formplayer/src/i18n/applyFormUiTranslations.test.ts b/formulus-formplayer/src/i18n/applyFormUiTranslations.test.ts
new file mode 100644
index 000000000..c9683154c
--- /dev/null
+++ b/formulus-formplayer/src/i18n/applyFormUiTranslations.test.ts
@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest';
+import { applyFormUiTranslations } from './applyFormUiTranslations';
+
+describe('applyFormUiTranslations', () => {
+  it('returns same reference when no translations', () => {
+    const ui = {
+      type: 'VerticalLayout',
+      elements: [{ type: 'Control', scope: '#/properties/a', label: 'A' }],
+    };
+    expect(applyFormUiTranslations(ui, 'fr')).toBe(ui);
+  });
+
+  it('merges partial control label', () => {
+    const ui = {
+      type: 'Control',
+      scope: '#/properties/name',
+      label: 'Name',
+      translations: { fr: { label: 'Nom' } },
+    };
+    const out = applyFormUiTranslations(ui, 'fr') as typeof ui;
+    expect(out.label).toBe('Nom');
+    expect((out as { translations?: unknown }).translations).toBeUndefined();
+  });
+
+  it('falls back to default for missing locale', () => {
+    const ui = {
+      type: 'Control',
+      scope: '#/properties/name',
+      label: 'Name',
+      translations: { fr: { label: 'Nom' } },
+    };
+    const out = applyFormUiTranslations(ui, 'de') as typeof ui;
+    expect(out.label).toBe('Name');
+  });
+
+  it('merges SwipeLayout options', () => {
+    const ui = {
+      type: 'SwipeLayout',
+      options: { headerTitle: 'Census', nextButtonLabel: 'Next' },
+      translations: {
+        pt: {
+          options: { headerTitle: 'Censo', nextButtonLabel: 'Seguinte' },
+        },
+      },
+      elements: [],
+    };
+    const out = applyFormUiTranslations(ui, 'pt') as {
+      options: { headerTitle: string; nextButtonLabel: string };
+    };
+    expect(out.options.headerTitle).toBe('Censo');
+    expect(out.options.nextButtonLabel).toBe('Seguinte');
+  });
+
+  it('merges oneOf by const', () => {
+    const ui = {
+      type: 'Control',
+      scope: '#/properties/q',
+      options: {
+        oneOf: [
+          { const: 'yes', title: 'Yes' },
+          { const: 'no', title: 'No' },
+        ],
+      },
+      translations: {
+        fr: {
+          options: {
+            oneOf: [{ const: 'yes', title: 'Oui' }],
+          },
+        },
+      },
+    };
+    const out = applyFormUiTranslations(ui, 'fr') as {
+      options: { oneOf: { const: string; title: string }[] };
+    };
+    expect(out.options.oneOf[0]?.title).toBe('Oui');
+    expect(out.options.oneOf[1]?.title).toBe('No');
+  });
+
+  it('handles pt-BR via pt fallback', () => {
+    const ui = {
+      type: 'Label',
+      text: 'Hello',
+      translations: { pt: { text: 'Olá' } },
+    };
+    const out = applyFormUiTranslations(ui, 'pt-BR') as { text: string };
+    expect(out.text).toBe('Olá');
+  });
+
+  it('maps translations.title to label when label absent', () => {
+    const ui = {
+      type: 'Control',
+      scope: '#/properties/codigo',
+      translations: { pt: { title: 'Digitalizar código do envelope' } },
+    };
+    const out = applyFormUiTranslations(ui, 'pt') as { label?: string };
+    expect(out.label).toBe('Digitalizar código do envelope');
+  });
+
+  it('prefers translations.label over translations.title', () => {
+    const ui = {
+      type: 'Control',
+      scope: '#/properties/codigo',
+      translations: {
+        pt: { label: 'Label wins', title: 'Title loses' },
+      },
+    };
+    const out = applyFormUiTranslations(ui, 'pt') as { label?: string };
+    expect(out.label).toBe('Label wins');
+  });
+
+  it('routes addButtonLabel from translation block into options', () => {
+    const ui = {
+      type: 'Control',
+      scope: '#/properties/quartos',
+      label: 'Rooms',
+      translations: {
+        pt: {
+          addButtonLabel: '+ Adicionar quarto',
+        },
+      },
+    };
+    const out = applyFormUiTranslations(ui, 'pt') as {
+      options?: { addButtonLabel?: string };
+    };
+    expect(out.options?.addButtonLabel).toBe('+ Adicionar quarto');
+  });
+
+  it('perf smoke: large form with few translations', () => {
+    const elements = Array.from({ length: 200 }, (_, i) => ({
+      type: 'Control',
+      scope: `#/properties/f${i}`,
+      label: `Field ${i}`,
+      ...(i < 20 ? { translations: { fr: { label: `Champ ${i}` } } } : {}),
+    }));
+    const ui = { type: 'VerticalLayout', elements };
+    const start = performance.now();
+    applyFormUiTranslations(ui, 'fr');
+    expect(performance.now() - start).toBeLessThan(50);
+  });
+});
diff --git a/formulus-formplayer/src/i18n/applyFormUiTranslations.ts b/formulus-formplayer/src/i18n/applyFormUiTranslations.ts
new file mode 100644
index 000000000..d221697c0
--- /dev/null
+++ b/formulus-formplayer/src/i18n/applyFormUiTranslations.ts
@@ -0,0 +1,271 @@
+import { localeLookupCandidates } from './localeUtils';
+
+type UiSchemaNode = Record<string, unknown>;
+
+const TRANSLATABLE_TOP_KEYS = new Set([
+  'label',
+  'description',
+  'text',
+  'headerTitle',
+  'nextButtonLabel',
+  'finalizeButtonLabel',
+]);
+
+/** Keys that live under `options` on SwipeLayout / Control. */
+const SWIPE_OPTION_KEYS = new Set([
+  'headerTitle',
+  'nextButtonLabel',
+  'finalizeButtonLabel',
+]);
+
+const CONTROL_OPTION_KEYS = new Set(['addButtonLabel']);
+
+function hasTranslationsSubtree(node: unknown): boolean {
+  if (!node || typeof node !== 'object') return false;
+  if (Array.isArray(node)) {
+    return node.some(hasTranslationsSubtree);
+  }
+  const obj = node as UiSchemaNode;
+  if (obj.translations && typeof obj.translations === 'object') return true;
+  if (Array.isArray(obj.elements)) {
+    return obj.elements.some(hasTranslationsSubtree);
+  }
+  if (obj.options && typeof obj.options === 'object') {
+    if (Array.isArray((obj.options as UiSchemaNode).columns)) {
+      if (
+        ((obj.options as UiSchemaNode).columns as unknown[]).some(
+          hasTranslationsSubtree,
+        )
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+function pickLocaleBlock(
+  translations: Record<string, unknown>,
+  locale: string,
+): Record<string, unknown> | null {
+  for (const candidate of localeLookupCandidates(locale)) {
+    const block = translations[candidate];
+    if (block && typeof block === 'object' && !Array.isArray(block)) {
+      return block as Record<string, unknown>;
+    }
+  }
+  return null;
+}
+
+function mergeOptionsArraysByConst(
+  base: unknown[],
+  patch: unknown[],
+): unknown[] {
+  const result = base.map(item =>
+    item && typeof item === 'object' ? { ...(item as object) } : item,
+  );
+  for (const patchItem of patch) {
+    if (!patchItem || typeof patchItem !== 'object') continue;
+    const patchObj = patchItem as Record<string, unknown>;
+    const patchConst = patchObj.const;
+    let matched = false;
+    if (patchConst !== undefined) {
+      for (let i = 0; i < result.length; i++) {
+        const baseItem = result[i];
+        if (
+          baseItem &&
+          typeof baseItem === 'object' &&
+          (baseItem as Record<string, unknown>).const === patchConst
+        ) {
+          result[i] = { ...(baseItem as object), ...patchObj };
+          matched = true;
+          break;
+        }
+      }
+    }
+    if (!matched) {
+      result.push(patchItem);
+    }
+  }
+  return result;
+}
+
+function deepMergeOptions(
+  base: Record<string, unknown>,
+  patch: Record<string, unknown>,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = { ...base };
+  for (const [key, patchVal] of Object.entries(patch)) {
+    const baseVal = out[key];
+    if (
+      key === 'oneOf' ||
+      key === 'columns' ||
+      (Array.isArray(patchVal) && Array.isArray(baseVal))
+    ) {
+      out[key] = mergeOptionsArraysByConst(
+        Array.isArray(baseVal) ? baseVal : [],
+        Array.isArray(patchVal) ? patchVal : [],
+      );
+    } else if (
+      patchVal &&
+      typeof patchVal === 'object' &&
+      !Array.isArray(patchVal) &&
+      baseVal &&
+      typeof baseVal === 'object' &&
+      !Array.isArray(baseVal)
+    ) {
+      out[key] = deepMergeOptions(
+        baseVal as Record<string, unknown>,
+        patchVal as Record<string, unknown>,
+      );
+    } else {
+      out[key] = patchVal;
+    }
+  }
+  return out;
+}
+
+function applyBlockToNode(
+  node: UiSchemaNode,
+  block: Record<string, unknown>,
+): UiSchemaNode {
+  const out: UiSchemaNode = { ...node };
+  const optionsBase =
+    out.options &&
+    typeof out.options === 'object' &&
+    !Array.isArray(out.options)
+      ? { ...(out.options as Record<string, unknown>) }
+      : {};
+
+  for (const [key, val] of Object.entries(block)) {
+    if (key === 'title') {
+      continue;
+    }
+    if (
+      key === 'options' &&
+      val &&
+      typeof val === 'object' &&
+      !Array.isArray(val)
+    ) {
+      out.options = deepMergeOptions(
+        optionsBase,
+        val as Record<string, unknown>,
+      );
+      continue;
+    }
+    if (SWIPE_OPTION_KEYS.has(key)) {
+      out.options = {
+        ...((out.options as Record<string, unknown>) ?? {}),
+        [key]: val,
+      };
+      continue;
+    }
+    if (CONTROL_OPTION_KEYS.has(key)) {
+      out.options = {
+        ...((out.options as Record<string, unknown>) ?? {}),
+        [key]: val,
+      };
+      continue;
+    }
+    if (TRANSLATABLE_TOP_KEYS.has(key)) {
+      out[key] = val;
+    }
+  }
+
+  const blockLabel = block.label;
+  const blockTitle = block.title;
+  if (typeof blockLabel === 'string') {
+    out.label = blockLabel;
+  } else if (
+    typeof blockTitle === 'string' &&
+    (out.label === undefined || out.label === null)
+  ) {
+    out.label = blockTitle;
+  }
+
+  return out;
+}
+
+function processNode(node: unknown, locale: string): unknown {
+  if (!node || typeof node !== 'object') return node;
+  if (Array.isArray(node)) {
+    let changed = false;
+    const next = node.map(child => {
+      const processed = processNode(child, locale);
+      if (processed !== child) changed = true;
+      return processed;
+    });
+    return changed ? next : node;
+  }
+
+  const obj = node as UiSchemaNode;
+  let result: UiSchemaNode = obj;
+  let changed = false;
+
+  const translations = obj.translations;
+  if (translations && typeof translations === 'object') {
+    const block = pickLocaleBlock(
+      translations as Record<string, unknown>,
+      locale,
+    );
+    if (block) {
+      result = applyBlockToNode(result, block);
+      changed = true;
+    }
+  }
+
+  if (Array.isArray(obj.elements)) {
+    let elementsChanged = false;
+    const newElements = obj.elements.map(el => {
+      const processed = processNode(el, locale);
+      if (processed !== el) elementsChanged = true;
+      return processed;
+    });
+    if (elementsChanged) {
+      result = changed
+        ? { ...result, elements: newElements }
+        : { ...obj, elements: newElements };
+      changed = true;
+    }
+  }
+
+  if (
+    result.options &&
+    typeof result.options === 'object' &&
+    !Array.isArray(result.options)
+  ) {
+    const opts = result.options as Record<string, unknown>;
+    if (Array.isArray(opts.columns)) {
+      let colsChanged = false;
+      const newCols = opts.columns.map(col => {
+        const processed = processNode(col, locale);
+        if (processed !== col) colsChanged = true;
+        return processed;
+      });
+      if (colsChanged) {
+        result = {
+          ...result,
+          options: { ...opts, columns: newCols },
+        };
+        changed = true;
+      }
+    }
+  }
+
+  if (changed && result.translations) {
+    const { translations: _removed, ...without } = result;
+    return without;
+  }
+
+  return changed ? result : node;
+}
+
+/**
+ * Apply embedded ui.json translations for the active locale (once at form init).
+ * Returns the same reference when no translations exist in the tree.
+ */
+export function applyFormUiTranslations<T>(uischema: T, locale: string): T {
+  if (!uischema || typeof uischema !== 'object') return uischema;
+  if (!hasTranslationsSubtree(uischema)) return uischema;
+  return processNode(uischema, locale) as T;
+}
diff --git a/formulus-formplayer/src/i18n/createOdeI18n.ts b/formulus-formplayer/src/i18n/createOdeI18n.ts
new file mode 100644
index 000000000..45fefe578
--- /dev/null
+++ b/formulus-formplayer/src/i18n/createOdeI18n.ts
@@ -0,0 +1,117 @@
+import type { ErrorObject } from 'ajv';
+import type { JsonFormsI18nState, Translator } from '@jsonforms/core';
+import en from '../locales/en.json';
+import pt from '../locales/pt.json';
+import fr from '../locales/fr.json';
+import type { OdeUiLocale } from './localeUtils';
+
+type Catalog = Record<string, string>;
+
+const CATALOGS: Record<OdeUiLocale, Catalog> = {
+  en: en as Catalog,
+  pt: pt as Catalog,
+  fr: fr as Catalog,
+};
+
+/** Simple {{key}} interpolation for catalog strings. */
+export function interpolate(
+  template: string,
+  vars?: Record<string, string | number>,
+): string {
+  if (!vars) return template;
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key: string) => {
+    const val = vars[key];
+    return val !== undefined ? String(val) : `{{${key}}}`;
+  });
+}
+
+export function getOdeCatalog(locale: OdeUiLocale): Catalog {
+  return CATALOGS[locale] ?? CATALOGS.en;
+}
+
+export function odeT(
+  locale: OdeUiLocale,
+  key: string,
+  defaultMessage?: string,
+  vars?: Record<string, string | number>,
+): string {
+  const catalog = getOdeCatalog(locale);
+  const raw = catalog[key] ?? defaultMessage ?? key;
+  return interpolate(raw, vars);
+}
+
+/**
+ * JsonForms-compatible i18n state for ODE-owned chrome and validation messages.
+ */
+export function createOdeI18n(locale: OdeUiLocale): JsonFormsI18nState {
+  const catalog = getOdeCatalog(locale);
+
+  const translate: Translator = (
+    key: string,
+    defaultMessage?: string,
+    _context?: unknown,
+  ) => {
+    if (defaultMessage === undefined) {
+      return catalog[key] ?? undefined;
+    }
+    return catalog[key] ?? defaultMessage;
+  };
+
+  const translateError = (
+    error: ErrorObject,
+    t: typeof translate,
+    _uischema?: unknown,
+  ): string => {
+    const keyword = error.keyword;
+    const limit =
+      (error.params as { limit?: number })?.limit ??
+      (error.params as { minimum?: number })?.minimum ??
+      (error.params as { maximum?: number })?.maximum;
+
+    const vars: Record<string, string | number> = {};
+    if (limit !== undefined) vars.limit = limit;
+
+    const ajvMessage =
+      typeof error.message === 'string' ? error.message : undefined;
+
+    if (keyword) {
+      const fieldKey = `${String(error.instancePath).replace(/^\//, '').replace(/\//g, '.')}.error.${keyword}`;
+      const fieldMsg = t(fieldKey, undefined);
+      if (fieldMsg) return fieldMsg;
+
+      const globalKey = `error.${keyword}`;
+      const globalMsg = catalog[globalKey];
+      if (globalMsg) return interpolate(globalMsg, vars);
+    }
+
+    if (ajvMessage) {
+      const byMessage =
+        catalog[`error.${ajvMessage}`] ?? t(ajvMessage, ajvMessage);
+      if (byMessage) return interpolate(byMessage, vars);
+    }
+
+    return (
+      ajvMessage ?? catalog['error.Validation error'] ?? 'Validation error'
+    );
+  };
+
+  return {
+    locale,
+    translate,
+    translateError,
+  };
+}
+
+/** Translate a single AJV error for ODE-owned chrome (e.g. Finalize screen). */
+export function translateAjvError(
+  locale: OdeUiLocale,
+  error: ErrorObject,
+): string {
+  const { translate, translateError } = createOdeI18n(locale);
+  if (!translate || !translateError) {
+    return typeof error.message === 'string'
+      ? error.message
+      : odeT(locale, 'error.Validation error', 'Validation error');
+  }
+  return translateError(error, translate);
+}
diff --git a/formulus-formplayer/src/i18n/localeUtils.ts b/formulus-formplayer/src/i18n/localeUtils.ts
new file mode 100644
index 000000000..ab4fc6c4d
--- /dev/null
+++ b/formulus-formplayer/src/i18n/localeUtils.ts
@@ -0,0 +1,46 @@
+/**
+ * Locale utilities (mirrored from formulus/src/lib/locale.ts for Formplayer).
+ */
+
+export const ODE_UI_LOCALES = ['en', 'pt', 'fr'] as const;
+export type OdeUiLocale = (typeof ODE_UI_LOCALES)[number];
+
+export function normalizeLocaleTag(tag: string): string {
+  return tag.trim().replace(/_/g, '-').toLowerCase();
+}
+
+export function localeLookupCandidates(tag: string): string[] {
+  const normalized = normalizeLocaleTag(tag);
+  if (!normalized) return ['en'];
+  const parts = normalized.split('-');
+  const candidates: string[] = [normalized];
+  if (parts.length > 1) {
+    candidates.push(parts[0]!);
+  }
+  return candidates;
+}
+
+export function matchOdeCatalogLocale(
+  tag: string,
+  supported: readonly string[] = ODE_UI_LOCALES,
+): OdeUiLocale | null {
+  for (const candidate of localeLookupCandidates(tag)) {
+    if ((supported as readonly string[]).includes(candidate)) {
+      return candidate as OdeUiLocale;
+    }
+  }
+  return null;
+}
+
+/** Resolve locale from bridge params; falls back to en. */
+export function resolveFormplayerLocale(
+  paramsLocale: unknown,
+  fallback = 'en',
+): OdeUiLocale {
+  if (typeof paramsLocale === 'string' && paramsLocale.trim()) {
+    const matched = matchOdeCatalogLocale(paramsLocale);
+    if (matched) return matched;
+  }
+  const fromFallback = matchOdeCatalogLocale(fallback);
+  return fromFallback ?? 'en';
+}
diff --git a/formulus-formplayer/src/i18n/useOdeT.ts b/formulus-formplayer/src/i18n/useOdeT.ts
new file mode 100644
index 000000000..1c732a679
--- /dev/null
+++ b/formulus-formplayer/src/i18n/useOdeT.ts
@@ -0,0 +1,13 @@
+import { useContext } from 'react';
+import { odeT } from './createOdeI18n';
+import { FormplayerLocaleContext } from './FormplayerLocaleContext';
+
+/** Translate ODE-owned chrome strings using the active Formplayer locale. */
+export function useOdeT() {
+  const locale = useContext(FormplayerLocaleContext);
+  return (
+    key: string,
+    defaultMessage?: string,
+    vars?: Record<string, string | number>,
+  ) => odeT(locale, key, defaultMessage, vars);
+}
diff --git a/formulus-formplayer/src/jsonforms/ShellInputControl.tsx b/formulus-formplayer/src/jsonforms/ShellInputControl.tsx
index 20073e0ff..7fde889d1 100644
--- a/formulus-formplayer/src/jsonforms/ShellInputControl.tsx
+++ b/formulus-formplayer/src/jsonforms/ShellInputControl.tsx
@@ -9,6 +9,10 @@ import { withJsonFormsControlProps } from '@jsonforms/react';
 import { MuiInputText } from '@jsonforms/material-renderers';
 import QuestionShell from '../components/QuestionShell';
 import { useFormContext } from '../App';
+import {
+  resolveControlDescription,
+  resolveControlLabel,
+} from '../utils/controlDisplayText';
 
 /**
  * String control that renders the stock MuiInputText cell inside QuestionShell
@@ -17,13 +21,12 @@ import { useFormContext } from '../App';
  */
 const ShellInputControl = (props: ControlProps) => {
   const { keyboardEnterKeyHint } = useFormContext();
-  const { uischema, schema, errors, label, visible, required } = props;
+  const { uischema, schema, errors, visible, required } = props;
 
   if (visible === false) return null;
 
-  const title =
-    (uischema as { label?: string })?.label || schema?.title || label;
-  const description = schema?.description;
+  const title = resolveControlLabel(props);
+  const description = resolveControlDescription(props) ?? schema?.description;
   const isRequired = Boolean(
     (uischema as { options?: { required?: boolean } })?.options?.required ??
     required,
diff --git a/formulus-formplayer/src/locales/en.json b/formulus-formplayer/src/locales/en.json
new file mode 100644
index 000000000..cacb2df77
--- /dev/null
+++ b/formulus-formplayer/src/locales/en.json
@@ -0,0 +1,101 @@
+{
+  "form.loading": "Loading form...",
+  "form.waitingForData": "Waiting for data from Formulus...",
+  "form.submitSuccess": "Form submitted successfully!",
+  "form.errorLoading": "Error Loading Form",
+  "form.errorInitializing": "Error initializing form",
+  "form.errorProcessing": "Error processing form data",
+  "form.schemaMissing": "Form schema is missing. Form rendering might fail or be incomplete.",
+  "form.submitFailed": "Failed to submit form. Please try again.",
+  "form.submitMissingInit": "Cannot submit form because initialization data is missing.",
+  "form.submitValidatorErrors": "Cannot submit form until custom validation errors are resolved.",
+  "form.missingFormId": "Form ID is missing. Cannot initialize form.",
+  "form.noNativeHost": "Cannot communicate with native host. Formplayer might be running in a standalone browser.",
+  "form.initTimeout": "Failed to initialize form: No data received from native host. Please try again.",
+  "nav.previous": "Previous",
+  "nav.next": "Next",
+  "nav.done": "Done",
+  "nav.finalize": "Finalize",
+  "nav.previousScreen": "Previous screen",
+  "nav.nextScreen": "Next screen",
+  "draft.title": "Resume Draft or Start New",
+  "draft.resume": "Resume",
+  "draft.startNew": "Start New Form",
+  "draft.delete": "Delete Draft",
+  "draft.cancel": "Cancel",
+  "draft.savedAt": "Saved {{date}}",
+  "draft.savedAtLine": "Draft saved {{date}}",
+  "draft.recentDrafts": "Recent drafts ({{count}})",
+  "draft.none": "No recent drafts found for this form.",
+  "draft.formLabel": "Form: {{formType}}",
+  "draft.newFormSection": "New Form",
+  "draft.deleteConfirm": "Are you sure you want to delete this draft? This action cannot be undone.",
+  "draft.cleanupOldOne": "1 draft older than 7 days will be automatically removed.",
+  "draft.cleanupOldMany": "{{count}} drafts older than 7 days will be automatically removed.",
+  "finalize.title": "Finalize",
+  "finalize.summary": "FORM SUMMARY",
+  "finalize.notProvided": "Not provided",
+  "finalize.allValid": "All validations passed! Review your answers and submit.",
+  "finalize.fixErrors": "Please fix the following errors before finalizing:",
+  "finalize.reviewHint": "Review all your entered data below. Click on any field to edit it.",
+  "finalize.editField": "Edit field",
+  "finalize.yes": "Yes",
+  "finalize.no": "No",
+  "finalize.none": "None",
+  "finalize.empty": "Empty",
+  "finalize.value.photoCaptured": "Photo captured",
+  "finalize.value.photoWithName": "Photo: {{name}}",
+  "finalize.value.captured": "Captured",
+  "finalize.value.qrScanned": "QR Code scanned",
+  "finalize.value.qrWithData": "QR Code: {{data}}",
+  "finalize.value.signatureCaptured": "Signature captured",
+  "finalize.value.signatureProvided": "Signature provided",
+  "finalize.value.fileSelected": "File selected",
+  "finalize.value.fileWithName": "File: {{name}}",
+  "finalize.value.audioRecorded": "Audio recorded",
+  "finalize.value.audioWithName": "Audio: {{name}}{{duration}}",
+  "finalize.value.gpsCaptured": "GPS location captured",
+  "finalize.value.location": "Location: {{coords}}",
+  "finalize.value.videoCaptured": "Video captured",
+  "finalize.value.videoWithName": "Video: {{name}}",
+  "validation.missingRequiredFields": "Missing required fields",
+  "validation.missingRequiredField": "Missing required field",
+  "validation.missingRequiredFieldsNamed": "Missing required field(s): {{names}}",
+  "validation.fieldsNeedAttention": "{{count}} fields need attention: {{summary}} Tap Done to review.",
+  "validation.oneFieldAttention": "1 field needs attention",
+  "validation.fieldsAttention": "{{count}} fields need attention",
+  "validation.moreFields": "(+{{count}} more)",
+  "validation.tapDoneToReview": "Tap Done to review.",
+  "validation.draftOnReturn": "Some required fields are missing. Any unsaved changes will be available as a draft when you return.",
+  "validation.stayHere": "Stay here",
+  "validation.goBack": "Go back",
+  "subObservation.add": "+ Add observation",
+  "subObservation.addItem": "+ Add {{itemLabel}}",
+  "subObservation.none": "No observations",
+  "subObservation.adding": "Adding…",
+  "subObservation.addingItem": "Adding {{itemLabel}}…",
+  "media.photo": "Photo",
+  "media.photoTap": "Tap to capture photo",
+  "media.audio": "Audio",
+  "media.video": "Video",
+  "media.gps": "GPS Location",
+  "media.qrCode": "QR Code",
+  "media.approximateDate": "Approximate Date",
+  "media.takePhoto": "Take photo",
+  "media.recording": "Recording...",
+  "cqt.errorTitle": "Custom Question Type Error",
+  "cqt.errorBody": "The custom question type \"{{format}}\" encountered an error and could not be rendered.",
+  "cqt.errorDetails": "Error Details (click to expand)",
+  "cqt.errorContinue": "The form will continue to function, but this field cannot be edited.",
+  "cqt.unknownError": "Unknown error",
+  "error.required": "This field is required",
+  "error.is a required property": "This field is required",
+  "error.must have required property": "This field is required",
+  "error.minLength": "Must be at least {{limit}} characters",
+  "error.maxLength": "Must be at most {{limit}} characters",
+  "error.minimum": "Must be at least {{limit}}",
+  "error.maximum": "Must be at most {{limit}}",
+  "error.pattern": "Invalid format",
+  "error.type": "Invalid value",
+  "error.Validation error": "Validation error"
+}
diff --git a/formulus-formplayer/src/locales/fr.json b/formulus-formplayer/src/locales/fr.json
new file mode 100644
index 000000000..44afd1d1f
--- /dev/null
+++ b/formulus-formplayer/src/locales/fr.json
@@ -0,0 +1,101 @@
+{
+  "form.loading": "Chargement du formulaire...",
+  "form.waitingForData": "En attente des données de Formulus...",
+  "form.submitSuccess": "Formulaire envoyé avec succès !",
+  "form.errorLoading": "Erreur de chargement du formulaire",
+  "form.errorInitializing": "Erreur d'initialisation du formulaire",
+  "form.errorProcessing": "Erreur lors du traitement des données du formulaire",
+  "form.schemaMissing": "Le schéma du formulaire est manquant. L'affichage peut échouer ou être incomplet.",
+  "form.submitFailed": "Échec de l'envoi du formulaire. Veuillez réessayer.",
+  "form.submitMissingInit": "Impossible d'envoyer le formulaire : les données d'initialisation sont manquantes.",
+  "form.submitValidatorErrors": "Impossible d'envoyer le formulaire tant que les erreurs de validation personnalisée ne sont pas corrigées.",
+  "form.missingFormId": "L'identifiant du formulaire est manquant. Impossible d'initialiser.",
+  "form.noNativeHost": "Impossible de communiquer avec l'hôte natif. Formplayer s'exécute peut-être dans un navigateur autonome.",
+  "form.initTimeout": "Échec de l'initialisation : aucune donnée reçue de l'hôte natif. Veuillez réessayer.",
+  "nav.previous": "Précédent",
+  "nav.next": "Suivant",
+  "nav.done": "Terminer",
+  "nav.finalize": "Finaliser",
+  "nav.previousScreen": "Écran précédent",
+  "nav.nextScreen": "Écran suivant",
+  "draft.title": "Reprendre le brouillon ou recommencer",
+  "draft.resume": "Reprendre",
+  "draft.startNew": "Nouveau formulaire",
+  "draft.delete": "Supprimer le brouillon",
+  "draft.cancel": "Annuler",
+  "draft.savedAt": "Enregistré {{date}}",
+  "draft.savedAtLine": "Brouillon enregistré {{date}}",
+  "draft.recentDrafts": "Brouillons récents ({{count}})",
+  "draft.none": "Aucun brouillon récent pour ce formulaire.",
+  "draft.formLabel": "Formulaire : {{formType}}",
+  "draft.newFormSection": "Nouveau formulaire",
+  "draft.deleteConfirm": "Voulez-vous vraiment supprimer ce brouillon ? Cette action est irréversible.",
+  "draft.cleanupOldOne": "1 brouillon de plus de 7 jours sera supprimé automatiquement.",
+  "draft.cleanupOldMany": "{{count}} brouillons de plus de 7 jours seront supprimés automatiquement.",
+  "finalize.title": "Finaliser",
+  "finalize.summary": "RÉSUMÉ DU FORMULAIRE",
+  "finalize.notProvided": "Non renseigné",
+  "finalize.allValid": "Toutes les validations sont passées ! Vérifiez vos réponses et soumettez.",
+  "finalize.fixErrors": "Veuillez corriger les erreurs suivantes avant de finaliser :",
+  "finalize.reviewHint": "Vérifiez toutes vos réponses ci-dessous. Cliquez sur un champ pour le modifier.",
+  "finalize.editField": "Modifier le champ",
+  "finalize.yes": "Oui",
+  "finalize.no": "Non",
+  "finalize.none": "Aucun",
+  "finalize.empty": "Vide",
+  "finalize.value.photoCaptured": "Photo capturée",
+  "finalize.value.photoWithName": "Photo : {{name}}",
+  "finalize.value.captured": "Capturée",
+  "finalize.value.qrScanned": "Code QR scanné",
+  "finalize.value.qrWithData": "Code QR : {{data}}",
+  "finalize.value.signatureCaptured": "Signature capturée",
+  "finalize.value.signatureProvided": "Signature fournie",
+  "finalize.value.fileSelected": "Fichier sélectionné",
+  "finalize.value.fileWithName": "Fichier : {{name}}",
+  "finalize.value.audioRecorded": "Audio enregistré",
+  "finalize.value.audioWithName": "Audio : {{name}}{{duration}}",
+  "finalize.value.gpsCaptured": "Position GPS capturée",
+  "finalize.value.location": "Position : {{coords}}",
+  "finalize.value.videoCaptured": "Vidéo capturée",
+  "finalize.value.videoWithName": "Vidéo : {{name}}",
+  "validation.missingRequiredFields": "Champs obligatoires manquants",
+  "validation.missingRequiredField": "Champ obligatoire manquant",
+  "validation.missingRequiredFieldsNamed": "Champ(s) obligatoire(s) manquant(s) : {{names}}",
+  "validation.fieldsNeedAttention": "{{count}} champs nécessitent une attention : {{summary}} Appuyez sur Terminer pour vérifier.",
+  "validation.oneFieldAttention": "1 champ nécessite une attention",
+  "validation.fieldsAttention": "{{count}} champs nécessitent une attention",
+  "validation.moreFields": "(+{{count}} de plus)",
+  "validation.tapDoneToReview": "Appuyez sur Terminer pour vérifier.",
+  "validation.draftOnReturn": "Des champs obligatoires sont manquants. Les modifications non enregistrées seront disponibles en brouillon à votre retour.",
+  "validation.stayHere": "Rester ici",
+  "validation.goBack": "Retour",
+  "subObservation.add": "+ Ajouter une observation",
+  "subObservation.addItem": "+ Ajouter {{itemLabel}}",
+  "subObservation.none": "Aucune observation",
+  "subObservation.adding": "Ajout…",
+  "subObservation.addingItem": "Ajout de {{itemLabel}}…",
+  "media.photo": "Photo",
+  "media.photoTap": "Appuyez pour prendre une photo",
+  "media.audio": "Audio",
+  "media.video": "Vidéo",
+  "media.gps": "Position GPS",
+  "media.qrCode": "Code QR",
+  "media.approximateDate": "Date approximative",
+  "media.takePhoto": "Prendre une photo",
+  "media.recording": "Enregistrement...",
+  "cqt.errorTitle": "Erreur du type de question personnalisé",
+  "cqt.errorBody": "Le type de question personnalisé « {{format}} » a rencontré une erreur et n'a pas pu être affiché.",
+  "cqt.errorDetails": "Détails de l'erreur (cliquer pour développer)",
+  "cqt.errorContinue": "Le formulaire continuera de fonctionner, mais ce champ ne peut pas être modifié.",
+  "cqt.unknownError": "Erreur inconnue",
+  "error.required": "Ce champ est obligatoire",
+  "error.is a required property": "Ce champ est obligatoire",
+  "error.must have required property": "Ce champ est obligatoire",
+  "error.minLength": "Doit contenir au moins {{limit}} caractères",
+  "error.maxLength": "Doit contenir au plus {{limit}} caractères",
+  "error.minimum": "Doit être au moins {{limit}}",
+  "error.maximum": "Doit être au plus {{limit}}",
+  "error.pattern": "Format invalide",
+  "error.type": "Valeur invalide",
+  "error.Validation error": "Erreur de validation"
+}
diff --git a/formulus-formplayer/src/locales/pt.json b/formulus-formplayer/src/locales/pt.json
new file mode 100644
index 000000000..f81439b8e
--- /dev/null
+++ b/formulus-formplayer/src/locales/pt.json
@@ -0,0 +1,101 @@
+{
+  "form.loading": "A carregar formulário...",
+  "form.waitingForData": "A aguardar dados do Formulus...",
+  "form.submitSuccess": "Formulário enviado com sucesso!",
+  "form.errorLoading": "Erro ao carregar formulário",
+  "form.errorInitializing": "Erro ao inicializar formulário",
+  "form.errorProcessing": "Erro ao processar dados do formulário",
+  "form.schemaMissing": "Falta o esquema do formulário. A apresentação pode falhar ou ficar incompleta.",
+  "form.submitFailed": "Falha ao enviar o formulário. Tente novamente.",
+  "form.submitMissingInit": "Não é possível enviar o formulário porque faltam dados de inicialização.",
+  "form.submitValidatorErrors": "Não é possível enviar o formulário até resolver os erros de validação personalizada.",
+  "form.missingFormId": "Falta o ID do formulário. Não é possível inicializar.",
+  "form.noNativeHost": "Não é possível comunicar com o anfitrião nativo. O Formplayer pode estar num browser autónomo.",
+  "form.initTimeout": "Falha ao inicializar o formulário: não foram recebidos dados do anfitrião nativo. Tente novamente.",
+  "nav.previous": "Anterior",
+  "nav.next": "Seguinte",
+  "nav.done": "Concluir",
+  "nav.finalize": "Finalizar",
+  "nav.previousScreen": "Ecrã anterior",
+  "nav.nextScreen": "Ecrã seguinte",
+  "draft.title": "Retomar rascunho ou começar de novo",
+  "draft.resume": "Retomar",
+  "draft.startNew": "Novo formulário",
+  "draft.delete": "Eliminar rascunho",
+  "draft.cancel": "Cancelar",
+  "draft.savedAt": "Guardado {{date}}",
+  "draft.savedAtLine": "Rascunho guardado {{date}}",
+  "draft.recentDrafts": "Rascunhos recentes ({{count}})",
+  "draft.none": "Não foram encontrados rascunhos recentes para este formulário.",
+  "draft.formLabel": "Formulário: {{formType}}",
+  "draft.newFormSection": "Novo formulário",
+  "draft.deleteConfirm": "Tem a certeza de que pretende eliminar este rascunho? Esta ação não pode ser anulada.",
+  "draft.cleanupOldOne": "1 rascunho com mais de 7 dias será removido automaticamente.",
+  "draft.cleanupOldMany": "{{count}} rascunhos com mais de 7 dias serão removidos automaticamente.",
+  "finalize.title": "Finalizar",
+  "finalize.summary": "RESUMO DO FORMULÁRIO",
+  "finalize.notProvided": "Não fornecido",
+  "finalize.allValid": "Todas as validações passaram! Reveja as respostas e submeta.",
+  "finalize.fixErrors": "Corrija os seguintes erros antes de finalizar:",
+  "finalize.reviewHint": "Reveja todos os dados introduzidos abaixo. Clique em qualquer campo para o editar.",
+  "finalize.editField": "Editar campo",
+  "finalize.yes": "Sim",
+  "finalize.no": "Não",
+  "finalize.none": "Nenhum",
+  "finalize.empty": "Vazio",
+  "finalize.value.photoCaptured": "Fotografia capturada",
+  "finalize.value.photoWithName": "Fotografia: {{name}}",
+  "finalize.value.captured": "Capturada",
+  "finalize.value.qrScanned": "Código QR lido",
+  "finalize.value.qrWithData": "Código QR: {{data}}",
+  "finalize.value.signatureCaptured": "Assinatura capturada",
+  "finalize.value.signatureProvided": "Assinatura fornecida",
+  "finalize.value.fileSelected": "Ficheiro selecionado",
+  "finalize.value.fileWithName": "Ficheiro: {{name}}",
+  "finalize.value.audioRecorded": "Áudio gravado",
+  "finalize.value.audioWithName": "Áudio: {{name}}{{duration}}",
+  "finalize.value.gpsCaptured": "Localização GPS capturada",
+  "finalize.value.location": "Localização: {{coords}}",
+  "finalize.value.videoCaptured": "Vídeo capturado",
+  "finalize.value.videoWithName": "Vídeo: {{name}}",
+  "validation.missingRequiredFields": "Campos obrigatórios em falta",
+  "validation.missingRequiredField": "Campo obrigatório em falta",
+  "validation.missingRequiredFieldsNamed": "Campo(s) obrigatório(s) em falta: {{names}}",
+  "validation.fieldsNeedAttention": "{{count}} campos precisam de atenção: {{summary}} Toque em Concluir para rever.",
+  "validation.oneFieldAttention": "1 campo precisa de atenção",
+  "validation.fieldsAttention": "{{count}} campos precisam de atenção",
+  "validation.moreFields": "(+{{count}} mais)",
+  "validation.tapDoneToReview": "Toque em Concluir para rever.",
+  "validation.draftOnReturn": "Faltam campos obrigatórios. As alterações não guardadas ficarão disponíveis como rascunho quando regressar.",
+  "validation.stayHere": "Ficar aqui",
+  "validation.goBack": "Voltar",
+  "subObservation.add": "+ Adicionar observação",
+  "subObservation.addItem": "+ Adicionar {{itemLabel}}",
+  "subObservation.none": "Sem observações",
+  "subObservation.adding": "A adicionar…",
+  "subObservation.addingItem": "A adicionar {{itemLabel}}…",
+  "media.photo": "Fotografia",
+  "media.photoTap": "Toque para capturar fotografia",
+  "media.audio": "Áudio",
+  "media.video": "Vídeo",
+  "media.gps": "Localização GPS",
+  "media.qrCode": "Código QR",
+  "media.approximateDate": "Data aproximada",
+  "media.takePhoto": "Tirar fotografia",
+  "media.recording": "A gravar...",
+  "cqt.errorTitle": "Erro no tipo de pergunta personalizado",
+  "cqt.errorBody": "O tipo de pergunta personalizado \"{{format}}\" encontrou um erro e não pôde ser apresentado.",
+  "cqt.errorDetails": "Detalhes do erro (clique para expandir)",
+  "cqt.errorContinue": "O formulário continuará a funcionar, mas este campo não pode ser editado.",
+  "cqt.unknownError": "Erro desconhecido",
+  "error.required": "Este campo é obrigatório",
+  "error.is a required property": "Este campo é obrigatório",
+  "error.must have required property": "Este campo é obrigatório",
+  "error.minLength": "Deve ter pelo menos {{limit}} caracteres",
+  "error.maxLength": "Deve ter no máximo {{limit}} caracteres",
+  "error.minimum": "Deve ser pelo menos {{limit}}",
+  "error.maximum": "Deve ser no máximo {{limit}}",
+  "error.pattern": "Formato inválido",
+  "error.type": "Valor inválido",
+  "error.Validation error": "Erro de validação"
+}
diff --git a/formulus-formplayer/src/renderers/CustomQuestionTypeAdapter.test.tsx b/formulus-formplayer/src/renderers/CustomQuestionTypeAdapter.test.tsx
new file mode 100644
index 000000000..5522695af
--- /dev/null
+++ b/formulus-formplayer/src/renderers/CustomQuestionTypeAdapter.test.tsx
@@ -0,0 +1,118 @@
+// @vitest-environment jsdom
+import React from 'react';
+import { describe, it, expect, afterEach } from 'vitest';
+import { render, screen, cleanup } from '@testing-library/react';
+import { ThemeProvider } from '@mui/material/styles';
+import { JsonForms } from '@jsonforms/react';
+import type { JsonSchema7, UISchemaElement } from '@jsonforms/core';
+import Ajv from 'ajv';
+import { theme } from '../theme/theme';
+import { FormContext } from '../App';
+import { registerCustomQuestionTypes } from '../services/CustomQuestionTypeRegistry';
+import type { CustomQuestionTypeProps } from '../types/CustomQuestionTypeContract';
+import { applyFormUiTranslations } from '../i18n/applyFormUiTranslations';
+
+const FORMAT = 'confidence-rating-test';
+const ajv = new Ajv({ allErrors: true, strict: false });
+
+function SpyCqt(props: CustomQuestionTypeProps) {
+  return (
+    <div
+      data-testid="spy-cqt"
+      data-options={JSON.stringify(props.options ?? null)}
+    />
+  );
+}
+
+function readCapturedOptions(): Record<string, unknown> | null {
+  const raw = screen.getByTestId('spy-cqt').getAttribute('data-options');
+  return raw ? (JSON.parse(raw) as Record<string, unknown>) : null;
+}
+
+const schema: JsonSchema7 = {
+  type: 'object',
+  properties: {
+    confidence: {
+      type: 'number',
+      title: 'Confidence',
+      format: FORMAT,
+    },
+  },
+};
+
+const rawUischema = {
+  type: 'Control',
+  scope: '#/properties/confidence',
+  options: {
+    lowLabel: 'Not at all',
+    highLabel: 'Completely',
+  },
+  translations: {
+    pt: {
+      options: {
+        lowLabel: 'Nada',
+        highLabel: 'Completamente',
+      },
+    },
+  },
+} as UISchemaElement;
+
+function renderWithUischema(uischema: UISchemaElement) {
+  const renderers = registerCustomQuestionTypes(new Map([[FORMAT, SpyCqt]]));
+
+  render(
+    <ThemeProvider theme={theme}>
+      <FormContext.Provider
+        value={{
+          formInitData: null,
+          keyboardEnterKeyHint: 'next',
+          draftSessionKey: null,
+        }}>
+        <JsonForms
+          schema={schema}
+          uischema={uischema}
+          data={{}}
+          renderers={renderers}
+          ajv={ajv}
+          onChange={() => {}}
+        />
+      </FormContext.Provider>
+    </ThemeProvider>,
+  );
+}
+
+afterEach(() => {
+  cleanup();
+});
+
+describe('CustomQuestionTypeAdapter', () => {
+  it('passes preprocessed ui.json options to the custom component', () => {
+    const uischema = applyFormUiTranslations(
+      rawUischema,
+      'pt',
+    ) as UISchemaElement;
+
+    renderWithUischema(uischema);
+
+    expect(screen.getByTestId('spy-cqt')).toBeTruthy();
+    expect(readCapturedOptions()).toEqual({
+      lowLabel: 'Nada',
+      highLabel: 'Completamente',
+    });
+  });
+
+  it('passes default options when locale has no translation block', () => {
+    // rawUischema.translations only defines `pt`; `de` is not in ui.json.
+    const uischema = applyFormUiTranslations(
+      rawUischema,
+      'de',
+    ) as UISchemaElement;
+
+    renderWithUischema(uischema);
+
+    expect(readCapturedOptions()).toEqual({
+      lowLabel: 'Not at all',
+      highLabel: 'Completely',
+    });
+  });
+});
diff --git a/formulus-formplayer/src/renderers/CustomQuestionTypeAdapter.tsx b/formulus-formplayer/src/renderers/CustomQuestionTypeAdapter.tsx
index a0772f331..51d641653 100644
--- a/formulus-formplayer/src/renderers/CustomQuestionTypeAdapter.tsx
+++ b/formulus-formplayer/src/renderers/CustomQuestionTypeAdapter.tsx
@@ -12,14 +12,24 @@ import type { ControlProps } from '@jsonforms/core';
 import QuestionShell from '../components/QuestionShell';
 import type { CustomQuestionTypeProps } from '../types/CustomQuestionTypeContract';
 import { formatControlErrors } from '../utils/formatControlErrors';
+import {
+  resolveControlDescription,
+  resolveControlLabel,
+} from '../utils/controlDisplayText';
+import { useOdeT } from '../i18n/useOdeT';
 
-// ---------------------------------------------------------------------------
-// Error Boundary — catches crashes in custom components
-// ---------------------------------------------------------------------------
+interface ErrorBoundaryLabels {
+  title: string;
+  body: string;
+  details: string;
+  continueMessage: string;
+  unknownError: string;
+}
 
 interface ErrorBoundaryProps {
   formatName: string;
   children: ReactNode;
+  labels: ErrorBoundaryLabels;
 }
 
 interface ErrorBoundaryState {
@@ -58,15 +68,14 @@ class CustomQuestionErrorBoundary extends Component<
             margin: '8px 0',
           }}>
           <strong style={{ display: 'block', marginBottom: '8px' }}>
-            ⚠️ Custom Question Type Error
+            ⚠️ {this.props.labels.title}
           </strong>
           <div style={{ fontSize: '0.9em', marginBottom: '8px' }}>
-            The custom question type <code>"{this.props.formatName}"</code>{' '}
-            encountered an error and could not be rendered.
+            {this.props.labels.body}
           </div>
           <details style={{ fontSize: '0.85em', marginTop: '8px' }}>
             <summary style={{ cursor: 'pointer', fontWeight: 'bold' }}>
-              Error Details (click to expand)
+              {this.props.labels.details}
             </summary>
             <pre
               style={{
@@ -77,7 +86,7 @@ class CustomQuestionErrorBoundary extends Component<
                 overflow: 'auto',
                 fontSize: '0.8em',
               }}>
-              {this.state.error?.message || 'Unknown error'}
+              {this.state.error?.message || this.props.labels.unknownError}
               {this.state.error?.stack && (
                 <>
                   {'\n\n'}
@@ -92,7 +101,7 @@ class CustomQuestionErrorBoundary extends Component<
               marginTop: '8px',
               fontStyle: 'italic',
             }}>
-            The form will continue to function, but this field cannot be edited.
+            {this.props.labels.continueMessage}
           </div>
         </div>
       );
@@ -115,18 +124,36 @@ export function createCustomQuestionTypeRenderer(
   formatName: string,
   CustomComponent: React.ComponentType<CustomQuestionTypeProps>,
 ): React.ComponentType {
-  const AdapterInner: React.FC<ControlProps> = ({
-    data,
-    handleChange,
-    path,
-    schema,
-    errors,
-    enabled,
-    label,
-    description,
-    required,
-    visible,
-  }) => {
+  const AdapterInner: React.FC<ControlProps> = props => {
+    const {
+      data,
+      handleChange,
+      path,
+      schema,
+      uischema,
+      errors,
+      enabled,
+      label,
+      description,
+      required,
+      visible,
+    } = props;
+    const t = useOdeT();
+    const errorBoundaryLabels = {
+      title: t('cqt.errorTitle', 'Custom Question Type Error'),
+      body: t(
+        'cqt.errorBody',
+        'The custom question type "{{format}}" encountered an error and could not be rendered.',
+        { format: formatName },
+      ),
+      details: t('cqt.errorDetails', 'Error Details (click to expand)'),
+      continueMessage: t(
+        'cqt.errorContinue',
+        'The form will continue to function, but this field cannot be edited.',
+      ),
+      unknownError: t('cqt.unknownError', 'Unknown error'),
+    };
+
     // Build the simplified props for the custom component
     const hasErrors =
       errors && (Array.isArray(errors) ? errors.length > 0 : true);
@@ -214,6 +241,15 @@ export function createCustomQuestionTypeRenderer(
     const customProps: CustomQuestionTypeProps = {
       value: data,
       config,
+      options:
+        uischema &&
+        typeof uischema === 'object' &&
+        'options' in uischema &&
+        uischema.options &&
+        typeof uischema.options === 'object' &&
+        !Array.isArray(uischema.options)
+          ? (uischema.options as Record<string, unknown>)
+          : undefined,
       onChange: (newValue: unknown) => handleChange(path, newValue),
       validation: {
         error: Boolean(hasErrors),
@@ -240,11 +276,13 @@ export function createCustomQuestionTypeRenderer(
 
     return (
       <QuestionShell
-        title={label}
-        description={description}
+        title={resolveControlLabel(props)}
+        description={resolveControlDescription(props)}
         required={required}
         error={errorMessage || null}>
-        <CustomQuestionErrorBoundary formatName={formatName}>
+        <CustomQuestionErrorBoundary
+          formatName={formatName}
+          labels={errorBoundaryLabels}>
           <CustomComponent {...customProps} />
         </CustomQuestionErrorBoundary>
       </QuestionShell>
diff --git a/formulus-formplayer/src/renderers/FinalizeRenderer.tsx b/formulus-formplayer/src/renderers/FinalizeRenderer.tsx
index 6b5d5d2cc..00d334d33 100644
--- a/formulus-formplayer/src/renderers/FinalizeRenderer.tsx
+++ b/formulus-formplayer/src/renderers/FinalizeRenderer.tsx
@@ -1,4 +1,4 @@
-import React, { useMemo } from 'react';
+import React, { useContext, useMemo, useCallback } from 'react';
 import { Box, List, ListItem, Typography, IconButton } from '@mui/material';
 import { tokens } from '../theme/tokens-adapter';
 import { Button } from '@ode/components/react-web';
@@ -9,6 +9,12 @@ import { ErrorObject } from 'ajv';
 import { useFormContext } from '../App';
 import EditIcon from '@mui/icons-material/Edit';
 import { displayAdate } from '../utils/adateUtils';
+import { useOdeT } from '../i18n/useOdeT';
+import { translateAjvError } from '../i18n/createOdeI18n';
+import { FormplayerLocaleContext } from '../i18n/FormplayerLocaleContext';
+import { titleForErrorPath } from '../utils/errorPageNavigation';
+import { resolveFieldLabel } from '../utils/controlDisplayText';
+import type { JsonSchema7 } from '@jsonforms/core';
 
 interface SummaryItem {
   label: string;
@@ -21,26 +27,35 @@ interface SummaryItem {
 
 const FinalizeRenderer = ({ data }: ControlProps) => {
   const { core } = useJsonForms();
+  const t = useOdeT();
+  const locale = useContext(FormplayerLocaleContext);
   const errors = core?.errors || [];
   const { formInitData } = useFormContext();
   const fullSchema = core?.schema;
-  const fullUISchema = formInitData?.uiSchema;
-
-  // Helper function to get field label from schema
-  const getFieldLabel = (fieldPath: string, fieldSchema: any): string => {
-    if (!fieldSchema) return fieldPath;
-    return (
-      fieldSchema.title ||
-      fieldSchema.description ||
-      fieldPath.split('/').pop() ||
-      fieldPath
-    );
-  };
+  const localizedUiSchema = core?.uischema;
+  const fullUISchema = localizedUiSchema ?? formInitData?.uiSchema;
+
+  const getFieldLabel = useCallback(
+    (fullPath: string, fieldSchema: any): string => {
+      const normalized = fullPath.replace(/^#\/properties\//, '');
+      const segments = normalized.split('/').filter(Boolean);
+      const key = segments[segments.length - 1] || normalized;
+      if (segments.length === 1 && key) {
+        return resolveFieldLabel(
+          fullSchema as JsonSchema7 | undefined,
+          localizedUiSchema,
+          key,
+        );
+      }
+      return fieldSchema?.title || fieldSchema?.description || key || fullPath;
+    },
+    [fullSchema, localizedUiSchema],
+  );
 
   // Helper function to format field value based on type
   const formatFieldValue = (value: any, fieldSchema: any): string => {
     if (value === null || value === undefined || value === '') {
-      return 'Not provided';
+      return t('finalize.notProvided', 'Not provided');
     }
 
     // Handle special formats
@@ -48,21 +63,27 @@ const FinalizeRenderer = ({ data }: ControlProps) => {
       switch (fieldSchema.format) {
         case 'photo':
           if (typeof value === 'object' && value.uri) {
-            return `Photo: ${value.filename || 'Captured'}`;
+            return t('finalize.value.photoWithName', 'Photo: {{name}}', {
+              name: value.filename || t('finalize.value.captured', 'Captured'),
+            });
           }
-          return 'Photo captured';
+          return t('finalize.value.photoCaptured', 'Photo captured');
         case 'qrcode':
           if (typeof value === 'object' && value.data) {
-            return `QR Code: ${value.data}`;
+            return t('finalize.value.qrWithData', 'QR Code: {{data}}', {
+              data: String(value.data),
+            });
           }
           return typeof value === 'string'
-            ? `QR Code: ${value}`
-            : 'QR Code scanned';
+            ? t('finalize.value.qrWithData', 'QR Code: {{data}}', {
+                data: value,
+              })
+            : t('finalize.value.qrScanned', 'QR Code scanned');
         case 'signature':
           if (typeof value === 'object' && value.uri) {
-            return 'Signature captured';
+            return t('finalize.value.signatureCaptured', 'Signature captured');
           }
-          return 'Signature provided';
+          return t('finalize.value.signatureProvided', 'Signature provided');
         case 'select_file':
           if (typeof value === 'object' && value.filename) {
             const original =
@@ -71,27 +92,40 @@ const FinalizeRenderer = ({ data }: ControlProps) => {
                 : '';
             const label =
               original.length > 0 ? original : String(value.filename);
-            return `File: ${label}`;
+            return t('finalize.value.fileWithName', 'File: {{name}}', {
+              name: label,
+            });
           }
-          return 'File selected';
+          return t('finalize.value.fileSelected', 'File selected');
         case 'audio':
           if (typeof value === 'object' && value.filename) {
             const duration = value.metadata?.duration
               ? ` (${Math.round(value.metadata.duration)}s)`
               : '';
-            return `Audio: ${value.filename}${duration}`;
+            return t(
+              'finalize.value.audioWithName',
+              'Audio: {{name}}{{duration}}',
+              {
+                name: String(value.filename),
+                duration,
+              },
+            );
           }
-          return 'Audio recorded';
+          return t('finalize.value.audioRecorded', 'Audio recorded');
         case 'gps':
           if (typeof value === 'object' && value.latitude && value.longitude) {
-            return `Location: ${value.latitude.toFixed(6)}, ${value.longitude.toFixed(6)}`;
+            return t('finalize.value.location', 'Location: {{coords}}', {
+              coords: `${value.latitude.toFixed(6)}, ${value.longitude.toFixed(6)}`,
+            });
           }
-          return 'GPS location captured';
+          return t('finalize.value.gpsCaptured', 'GPS location captured');
         case 'video':
           if (typeof value === 'object' && value.filename) {
-            return `Video: ${value.filename}`;
+            return t('finalize.value.videoWithName', 'Video: {{name}}', {
+              name: String(value.filename),
+            });
           }
-          return 'Video captured';
+          return t('finalize.value.videoCaptured', 'Video captured');
         case 'date':
           return new Date(value).toLocaleDateString();
         case 'date-time':
@@ -105,7 +139,7 @@ const FinalizeRenderer = ({ data }: ControlProps) => {
 
     // Handle arrays
     if (Array.isArray(value)) {
-      if (value.length === 0) return 'None';
+      if (value.length === 0) return t('finalize.none', 'None');
       return value
         .map((item, idx) => {
           if (typeof item === 'object') {
@@ -119,13 +153,13 @@ const FinalizeRenderer = ({ data }: ControlProps) => {
     // Handle objects
     if (typeof value === 'object') {
       // Check if it's a nested object with properties
-      if (Object.keys(value).length === 0) return 'Empty';
+      if (Object.keys(value).length === 0) return t('finalize.empty', 'Empty');
       return JSON.stringify(value, null, 2);
     }
 
     // Handle booleans
     if (typeof value === 'boolean') {
-      return value ? 'Yes' : 'No';
+      return value ? t('finalize.yes', 'Yes') : t('finalize.no', 'No');
     }
 
     // Default: convert to string
@@ -232,29 +266,16 @@ const FinalizeRenderer = ({ data }: ControlProps) => {
     extractFields(fullSchema, data);
 
     return items;
-  }, [fullSchema, data, findFieldPageMemo]);
-
-  const formatErrorPath = (path: string) => {
-    // Remove leading slash and convert to readable format
-    return path.replace(/^\//, '').replace(/\//g, ' > ');
-  };
+  }, [fullSchema, data, findFieldPageMemo, getFieldLabel]);
 
   const formatErrorMessage = (error: ErrorObject) => {
-    const path = formatErrorPath(error.instancePath);
-    // Check if there's a custom error message in the error object
-    const customMessage = (error as any).params?.errorMessage;
-    // Title case the path and add spaces before capitalized letters
-    const formattedPath = path
-      ? path
-          .split(' ')
-          .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-          .join(' ')
-          .replace(/([A-Z])/g, ' $1')
-          .trim()
-      : '';
-    return formattedPath
-      ? `${formattedPath} ${customMessage || error.message}`
-      : customMessage || error.message;
+    const title = titleForErrorPath(
+      error.instancePath,
+      fullSchema as JsonSchema7 | undefined,
+      localizedUiSchema,
+    );
+    const translated = translateAjvError(locale, error);
+    return title ? `${title}: ${translated}` : translated;
   };
 
   const hasErrors = Array.isArray(errors) && errors.length > 0;
@@ -306,7 +327,10 @@ const FinalizeRenderer = ({ data }: ControlProps) => {
             color="error"
             gutterBottom
             sx={{ textAlign: 'center' }}>
-            Please fix the following errors before finalizing:
+            {t(
+              'finalize.fixErrors',
+              'Please fix the following errors before finalizing:',
+            )}
           </Typography>
           <Box
             sx={{
@@ -340,7 +364,10 @@ const FinalizeRenderer = ({ data }: ControlProps) => {
           color="success.main"
           gutterBottom
           sx={{ textAlign: 'center' }}>
-          All validations passed! You can now finalize your submission.
+          {t(
+            'finalize.allValid',
+            'All validations passed! You can now finalize your submission.',
+          )}
         </Typography>
       )}
 
@@ -352,7 +379,7 @@ const FinalizeRenderer = ({ data }: ControlProps) => {
           disabled={Boolean(hasErrors)}
           className="formplayer-solid-primary"
           style={{ width: '100%' }}>
-          Finalize
+          {t('nav.finalize', 'Finalize')}
         </Button>
       </Box>
 
@@ -371,14 +398,17 @@ const FinalizeRenderer = ({ data }: ControlProps) => {
             variant="h5"
             gutterBottom
             sx={{ fontWeight: 700, textAlign: 'center' }}>
-            FORM SUMMARY
+            {t('finalize.summary', 'FORM SUMMARY')}
           </Typography>
           <Typography
             variant="body2"
             color="text.secondary"
             gutterBottom
             sx={{ mb: 2, textAlign: 'center' }}>
-            Review all your entered data below. Click on any field to edit it.
+            {t(
+              'finalize.reviewHint',
+              'Review all your entered data below. Click on any field to edit it.',
+            )}
           </Typography>
           <Box
             sx={{
@@ -469,7 +499,7 @@ const FinalizeRenderer = ({ data }: ControlProps) => {
                             },
                             flexShrink: 0,
                           }}
-                          aria-label="Edit field">
+                          aria-label={t('finalize.editField', 'Edit field')}>
                           <EditIcon sx={{ fontSize: 18 }} />
                         </IconButton>
                       )}
diff --git a/formulus-formplayer/src/renderers/QrcodeQuestionRenderer.tsx b/formulus-formplayer/src/renderers/QrcodeQuestionRenderer.tsx
index 1a2635e1c..5c3bfcc3e 100644
--- a/formulus-formplayer/src/renderers/QrcodeQuestionRenderer.tsx
+++ b/formulus-formplayer/src/renderers/QrcodeQuestionRenderer.tsx
@@ -22,6 +22,10 @@ import { ControlProps, rankWith, formatIs } from '@jsonforms/core';
 import FormulusClient from '../services/FormulusInterface';
 import { QrcodeResult } from '../types/FormulusInterfaceDefinition';
 import QuestionShell from '../components/QuestionShell';
+import {
+  resolveControlDescription,
+  resolveControlLabel,
+} from '../utils/controlDisplayText';
 
 /**
  * Tester function — matches any schema field with "format": "qrcode".
@@ -37,16 +41,17 @@ export const qrcodeQuestionTester = rankWith(
   formatIs('qrcode'),
 );
 
-const QrcodeQuestionRenderer: React.FC<ControlProps> = ({
-  data,
-  handleChange,
-  path,
-  errors,
-  schema,
-  uischema,
-  enabled = true,
-  visible = true,
-}) => {
+const QrcodeQuestionRenderer: React.FC<ControlProps> = props => {
+  const {
+    data,
+    handleChange,
+    path,
+    errors,
+    schema,
+    uischema,
+    enabled = true,
+    visible = true,
+  } = props;
   const [isScanning, setIsScanning] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [showManualEntry, setShowManualEntry] = useState(false);
@@ -135,8 +140,8 @@ const QrcodeQuestionRenderer: React.FC<ControlProps> = ({
     return null;
   }
 
-  const label = (uischema as any)?.label || schema.title || 'QR Code';
-  const description = schema.description;
+  const label = resolveControlLabel(props) || 'QR Code';
+  const description = resolveControlDescription(props) ?? schema.description;
   const isRequired = Boolean(
     (uischema as any)?.options?.required ??
     (schema as any)?.options?.required ??
diff --git a/formulus-formplayer/src/renderers/SubObservationQuestionRenderer.tsx b/formulus-formplayer/src/renderers/SubObservationQuestionRenderer.tsx
index e08130a0c..962112270 100644
--- a/formulus-formplayer/src/renderers/SubObservationQuestionRenderer.tsx
+++ b/formulus-formplayer/src/renderers/SubObservationQuestionRenderer.tsx
@@ -4,7 +4,7 @@
  * `openFormplayer` with `subObservationMode`.
  */
 
-import React, { useCallback, useMemo, useState } from 'react';
+import React, { useCallback, useContext, useMemo, useState } from 'react';
 import { withJsonFormsControlProps, useJsonForms } from '@jsonforms/react';
 import { ControlProps, rankWith, schemaMatches } from '@jsonforms/core';
 import { Box, Typography, Button, IconButton, Tooltip } from '@mui/material';
@@ -14,7 +14,13 @@ import QuestionShell from '../components/QuestionShell';
 import FormulusClient from '../services/FormulusInterface';
 import type { FormCompletionResult } from '../types/FormulusInterfaceDefinition';
 import { useFormContext } from '../App';
+import { FormplayerLocaleContext } from '../i18n/FormplayerLocaleContext';
+import { odeT } from '../i18n/createOdeI18n';
 import { tokens } from '../theme/tokens-adapter';
+import {
+  mergeSubObservationColumnDefs,
+  resolveSubObservationColumns,
+} from '../utils/subObservationColumnLabels';
 import {
   buildColumns,
   coerceSubObservationRows,
@@ -32,6 +38,7 @@ import {
   writeSubObservationContextToWindow,
   type OrderBySpec,
   type SubObservationContextMergeConfig,
+  type SubObservationSchemaConfig,
 } from './subObservationHelpers';
 
 const RESERVED_SCHEMA_KEYS = new Set([
@@ -117,7 +124,7 @@ const SubObservationQuestionRendererInner: React.FC<ControlProps> = ({
   required,
 }) => {
   const jsonForms = useJsonForms();
-  const { commitFormData } = useFormContext();
+  const { commitFormData, linkedFormSpecs } = useFormContext();
   const config = useMemo(() => extractConfig(schema), [schema]);
 
   const childFormType =
@@ -177,10 +184,48 @@ const SubObservationQuestionRendererInner: React.FC<ControlProps> = ({
     ) as Record<string, unknown>[];
   }, [jsonForms.core?.data, data, path, config.orderBy]);
 
-  const columns = useMemo(() => buildColumns(config, rows), [config, rows]);
+  const columnDefs = useMemo(
+    () =>
+      mergeSubObservationColumnDefs(
+        (config as SubObservationSchemaConfig).columns,
+        uischema,
+      ),
+    [config, uischema],
+  );
+
+  const columns = useMemo(() => {
+    if (columnDefs.length > 0) {
+      return resolveSubObservationColumns(
+        columnDefs,
+        childFormType,
+        linkedFormSpecs,
+      );
+    }
+    return buildColumns(config, rows);
+  }, [columnDefs, childFormType, linkedFormSpecs, config, rows]);
 
   const itemLabel = useMemo(() => resolveItemLabel(config), [config]);
 
+  const locale = useContext(FormplayerLocaleContext);
+
+  const addButtonCopy = useMemo(
+    () => ({
+      addDefault: odeT(locale, 'subObservation.add', '+ Add observation'),
+      addWithItem: odeT(
+        locale,
+        'subObservation.addItem',
+        '+ Add {{itemLabel}}',
+      ),
+      adding: odeT(locale, 'subObservation.adding', 'Adding…'),
+      addingWithItem: odeT(
+        locale,
+        'subObservation.addingItem',
+        'Adding {{itemLabel}}…',
+      ),
+    }),
+    [locale],
+  );
+
   const addButtonLabelOverride = useMemo(() => {
     const opts = (uischema as { options?: { addButtonLabel?: unknown } })
       ?.options;
@@ -189,12 +234,15 @@ const SubObservationQuestionRendererInner: React.FC<ControlProps> = ({
 
   const addButtonText = useMemo(
     () =>
-      resolveAddButtonLabel({
-        itemLabel,
-        addButtonLabel: addButtonLabelOverride,
-        busy: busyId === 'add',
-      }),
-    [itemLabel, addButtonLabelOverride, busyId],
+      resolveAddButtonLabel(
+        {
+          itemLabel,
+          addButtonLabel: addButtonLabelOverride,
+          busy: busyId === 'add',
+        },
+        addButtonCopy,
+      ),
+    [itemLabel, addButtonLabelOverride, busyId, addButtonCopy],
   );
 
   const emptyLabel = useMemo(() => resolveEmptyLabel(itemLabel), [itemLabel]);
@@ -496,17 +544,16 @@ const SubObservationQuestionRendererInner: React.FC<ControlProps> = ({
                 ))}
                 <Box
                   component="th"
+                  scope="col"
                   sx={{
-                    textAlign: 'left',
                     px: 1.5,
                     py: 1.25,
                     backgroundColor: 'action.hover',
                     borderBottom: `${tokens.border.width.thin} solid`,
                     borderColor: 'divider',
                     width: 140,
-                  }}>
-                  Actions
-                </Box>
+                  }}
+                />
               </Box>
             </Box>
             <Box component="tbody">
diff --git a/formulus-formplayer/src/renderers/SwipeLayoutRenderer.tsx b/formulus-formplayer/src/renderers/SwipeLayoutRenderer.tsx
index 5cfbb7680..bb966f1c8 100644
--- a/formulus-formplayer/src/renderers/SwipeLayoutRenderer.tsx
+++ b/formulus-formplayer/src/renderers/SwipeLayoutRenderer.tsx
@@ -44,6 +44,8 @@ import {
 } from '../utils/autofocusHelpers';
 import { navigateToFirstBlockingError } from '../utils/validationNavigation';
 import { formatBlockingErrorSummary } from '../utils/errorPageNavigation';
+import { resolveFieldLabel } from '../utils/controlDisplayText';
+import { useOdeT } from '../i18n/useOdeT';
 
 // ---------------------------------------------------------------------------
 // Testers
@@ -98,6 +100,7 @@ const SwipeLayoutRenderer = ({
   );
   const [snackbarMessage, setSnackbarMessage] = useState<string>('');
   const { core, config } = useJsonForms();
+  const t = useOdeT();
   const parentFormContext = useFormContext();
   const { formInitData } = parentFormContext;
 
@@ -369,9 +372,13 @@ const SwipeLayoutRenderer = ({
         const missingFields = getMissingRequiredFieldsOnPage();
 
         if (missingFields.length > 0) {
-          const message = `Missing required ${
-            missingFields.length === 1 ? 'field' : 'fields'
-          }: ${missingFields.slice(0, 2).join(', ')}${missingFields.length > 2 ? '...' : ''}`;
+          const message = t(
+            'validation.missingRequiredFieldsNamed',
+            `Missing required field(s): ${missingFields.slice(0, 2).join(', ')}${missingFields.length > 2 ? '...' : ''}`,
+            {
+              names: `${missingFields.slice(0, 2).join(', ')}${missingFields.length > 2 ? '...' : ''}`,
+            },
+          );
 
           setPendingNavigation(newPage);
           setSnackbarMessage(message);
@@ -394,6 +401,7 @@ const SwipeLayoutRenderer = ({
       getMissingRequiredFieldsOnPage,
       performNavigation,
       snackbarOpen,
+      t,
     ],
   );
 
@@ -435,8 +443,11 @@ const SwipeLayoutRenderer = ({
     return formatBlockingErrorSummary(
       errors,
       (core?.schema ?? schema) as JsonSchema7,
+      3,
+      t,
+      uischema,
     );
-  }, [core?.errors, core?.schema, schema]);
+  }, [core?.errors, core?.schema, schema, t, uischema]);
 
   const trySubmitForm = useCallback(() => {
     if (!formInitData) return;
@@ -491,13 +502,14 @@ const SwipeLayoutRenderer = ({
       primaryKeyboardEnterKeyHint(
         isOnFinalizePage,
         nextVisiblePage !== null ? nextButtonLabelOption : undefined,
-        finalizeButtonLabelOption ?? 'Finalize',
+        finalizeButtonLabelOption ?? t('nav.finalize', 'Finalize'),
       ),
     [
       isOnFinalizePage,
       nextVisiblePage,
       nextButtonLabelOption,
       finalizeButtonLabelOption,
+      t,
     ],
   );
 
@@ -584,8 +596,11 @@ const SwipeLayoutRenderer = ({
                     borderTop: `1px solid ${theme.palette.divider}`,
                   })}>
                   {headerFields.map((fieldKey: string) => {
-                    const fieldSchema = (schema as any)?.properties?.[fieldKey];
-                    const label = fieldSchema?.title || fieldKey;
+                    const label = resolveFieldLabel(
+                      schema as JsonSchema7 | undefined,
+                      uischema,
+                      fieldKey,
+                    );
                     const value = data?.[fieldKey];
                     const displayValue =
                       value != null && value !== '' ? String(value) : '—';
@@ -642,7 +657,7 @@ const SwipeLayoutRenderer = ({
               ? {
                   onClick: trySubmitForm,
                   disabled: isNavigating || !formInitData,
-                  label: finalizeButtonLabelOption ?? 'Done',
+                  label: finalizeButtonLabelOption ?? t('nav.done', 'Done'),
                 }
               : nextVisiblePage !== null
                 ? {
@@ -711,14 +726,20 @@ const SwipeLayoutRenderer = ({
                   <Typography
                     variant="h6"
                     sx={{ fontWeight: 600, textAlign: 'center', mb: 1.5 }}>
-                    Missing required fields
+                    {t(
+                      'validation.missingRequiredFields',
+                      'Missing required fields',
+                    )}
                   </Typography>
                   <Typography
                     variant="body2"
                     color="text.secondary"
                     sx={{ textAlign: 'center', mb: 3 }}>
                     {snackbarMessage ||
-                      'Some required fields are missing. Any unsaved changes will be available as a draft when you return.'}
+                      t(
+                        'validation.draftOnReturn',
+                        'Some required fields are missing. Any unsaved changes will be available as a draft when you return.',
+                      )}
                   </Typography>
                   <Box
                     sx={{
@@ -732,13 +753,13 @@ const SwipeLayoutRenderer = ({
                       variant="neutral"
                       size="medium"
                       onPress={handleSnackbarClose}>
-                      Stay here
+                      {t('validation.stayHere', 'Stay here')}
                     </Button>
                     <Button
                       variant="danger"
                       size="medium"
                       onPress={handleGoBack}>
-                      Go back
+                      {t('validation.goBack', 'Go back')}
                     </Button>
                   </Box>
                 </Box>
diff --git a/formulus-formplayer/src/renderers/subObservationHelpers.test.ts b/formulus-formplayer/src/renderers/subObservationHelpers.test.ts
index 4779fbeed..83b677356 100644
--- a/formulus-formplayer/src/renderers/subObservationHelpers.test.ts
+++ b/formulus-formplayer/src/renderers/subObservationHelpers.test.ts
@@ -13,6 +13,7 @@ import {
   optionalRecordMap,
   resolveItemLabel,
   resolveAddButtonLabel,
+  DEFAULT_ADD_BUTTON_COPY,
   resolveEmptyLabel,
   resolveDeleteFallbackLabel,
   mergeSessionIntoSubObservationContext,
@@ -170,34 +171,53 @@ describe('subObservationHelpers', () => {
   });
 
   it('resolveAddButtonLabel uses defaults, itemLabel, and ui override', () => {
-    expect(resolveAddButtonLabel({ itemLabel: null, busy: false })).toBe(
+    const copy = DEFAULT_ADD_BUTTON_COPY;
+    expect(resolveAddButtonLabel({ itemLabel: null, busy: false }, copy)).toBe(
       '+ Add observation',
     );
-    expect(resolveAddButtonLabel({ itemLabel: null, busy: true })).toBe(
+    expect(resolveAddButtonLabel({ itemLabel: null, busy: true }, copy)).toBe(
       'Adding…',
     );
-    expect(resolveAddButtonLabel({ itemLabel: 'quarto', busy: false })).toBe(
-      '+ Add quarto',
-    );
-    expect(resolveAddButtonLabel({ itemLabel: 'quarto', busy: true })).toBe(
-      'Adding quarto…',
-    );
     expect(
-      resolveAddButtonLabel({
-        itemLabel: 'quarto',
-        addButtonLabel: '+ Adicionar quarto',
-        busy: false,
-      }),
+      resolveAddButtonLabel({ itemLabel: 'quarto', busy: false }, copy),
+    ).toBe('+ Add quarto');
+    expect(
+      resolveAddButtonLabel({ itemLabel: 'quarto', busy: true }, copy),
+    ).toBe('Adding quarto…');
+    expect(
+      resolveAddButtonLabel(
+        {
+          itemLabel: 'quarto',
+          addButtonLabel: '+ Adicionar quarto',
+          busy: false,
+        },
+        copy,
+      ),
     ).toBe('+ Adicionar quarto');
     expect(
-      resolveAddButtonLabel({
-        itemLabel: 'quarto',
-        addButtonLabel: '+ Adicionar quarto',
-        busy: true,
-      }),
+      resolveAddButtonLabel(
+        {
+          itemLabel: 'quarto',
+          addButtonLabel: '+ Adicionar quarto',
+          busy: true,
+        },
+        copy,
+      ),
     ).toBe('Adding…');
   });
 
+  it('resolveAddButtonLabel uses localized copy templates', () => {
+    const ptCopy = {
+      addDefault: '+ Adicionar observação',
+      addWithItem: '+ Adicionar {{itemLabel}}',
+      adding: 'A adicionar…',
+      addingWithItem: 'A adicionar {{itemLabel}}…',
+    };
+    expect(
+      resolveAddButtonLabel({ itemLabel: 'quarto', busy: false }, ptCopy),
+    ).toBe('+ Adicionar quarto');
+  });
+
   it('resolveEmptyLabel and resolveDeleteFallbackLabel respect itemLabel', () => {
     expect(resolveEmptyLabel(null)).toBe('No observations');
     expect(resolveEmptyLabel('room')).toBe('No room');
diff --git a/formulus-formplayer/src/renderers/subObservationHelpers.ts b/formulus-formplayer/src/renderers/subObservationHelpers.ts
index 98e8c465f..6a7f27e81 100644
--- a/formulus-formplayer/src/renderers/subObservationHelpers.ts
+++ b/formulus-formplayer/src/renderers/subObservationHelpers.ts
@@ -28,6 +28,24 @@ export function resolveItemLabel(
   return trimmed.length > 0 ? trimmed : null;
 }
 
+import { interpolate } from '../i18n/createOdeI18n';
+
+export type ResolveAddButtonCopy = {
+  addDefault: string;
+  /** Template with `{{itemLabel}}`. */
+  addWithItem: string;
+  adding: string;
+  /** Template with `{{itemLabel}}`. */
+  addingWithItem: string;
+};
+
+export const DEFAULT_ADD_BUTTON_COPY: ResolveAddButtonCopy = {
+  addDefault: '+ Add observation',
+  addWithItem: '+ Add {{itemLabel}}',
+  adding: 'Adding…',
+  addingWithItem: 'Adding {{itemLabel}}…',
+};
+
 export type ResolveAddButtonLabelInput = {
   itemLabel: string | null;
   addButtonLabel?: unknown;
@@ -37,18 +55,19 @@ export type ResolveAddButtonLabelInput = {
 /** Add-button text: ui override > composed from itemLabel > legacy default. */
 export function resolveAddButtonLabel(
   input: ResolveAddButtonLabelInput,
+  copy: ResolveAddButtonCopy = DEFAULT_ADD_BUTTON_COPY,
 ): string {
   const override =
     typeof input.addButtonLabel === 'string' ? input.addButtonLabel.trim() : '';
   if (override.length > 0) {
-    return input.busy ? 'Adding…' : override;
+    return input.busy ? copy.adding : override;
   }
   if (input.itemLabel) {
     return input.busy
-      ? `Adding ${input.itemLabel}…`
-      : `+ Add ${input.itemLabel}`;
+      ? interpolate(copy.addingWithItem, { itemLabel: input.itemLabel })
+      : interpolate(copy.addWithItem, { itemLabel: input.itemLabel });
   }
-  return input.busy ? 'Adding…' : '+ Add observation';
+  return input.busy ? copy.adding : copy.addDefault;
 }
 
 /** Empty-table row text when the embedded array has no items. */
diff --git a/formulus-formplayer/src/types/CustomQuestionTypeContract.ts b/formulus-formplayer/src/types/CustomQuestionTypeContract.ts
index 438eec16a..13a2e8f4e 100644
--- a/formulus-formplayer/src/types/CustomQuestionTypeContract.ts
+++ b/formulus-formplayer/src/types/CustomQuestionTypeContract.ts
@@ -26,6 +26,11 @@ export interface CustomQuestionTypeProps {
    */
   config: Record<string, unknown>;
 
+  /**
+   * Display-oriented settings from ui.json Control.options (after locale preprocess).
+   */
+  options?: Record<string, unknown>;
+
   /**
    * Callback to update the field value. Call with a JSON number/boolean/string/etc. —
    * never a display string for numeric schema types.
diff --git a/formulus-formplayer/src/types/FormulusInterfaceDefinition.ts b/formulus-formplayer/src/types/FormulusInterfaceDefinition.ts
index 3be0c2205..d149227a6 100644
--- a/formulus-formplayer/src/types/FormulusInterfaceDefinition.ts
+++ b/formulus-formplayer/src/types/FormulusInterfaceDefinition.ts
@@ -41,7 +41,7 @@ export interface ExtensionMetadata {
  * Data passed to the Formulus app when a form is initialized
  * @property {string} formType - The form type (e.g. 'form1')
  * @property {string | null} observationId - The observation ID (generated by the database on first form submission). NULL if this is a new form.
- * @property {Record<string, unknown>} params - Host parameters for the formplayer WebView. Put **field prefills** in `params.defaultData` (a plain object). Top-level keys are reserved for bridge/UI: `defaultData`, `theme`, `darkMode`, `themeColors` (and any future keys added to the formplayer allowlist)—do not rely on those being stored on the observation. If `defaultData` is omitted, legacy behavior copies every other top-level key as prefill data (still excluding the reserved keys above). On load and submit, when the JSON Schema has non-empty root `properties`, the formplayer keeps only those property keys plus `locale` so polluted rows are cleaned on re-save.
+ * @property {Record<string, unknown>} params - Host parameters for the formplayer WebView. Put **field prefills** in `params.defaultData` (a plain object). Top-level keys are reserved for bridge/UI: `defaultData`, `theme`, `darkMode`, `themeColors`, `locale` (active UI language), `context` (session context)—do not rely on those being stored on the observation. If `defaultData` is omitted, legacy behavior copies every other top-level key as prefill data (still excluding the reserved keys above). On load and submit, when the JSON Schema has non-empty root `properties`, the formplayer keeps only those property keys plus optional observation metadata keys such as schema-declared `locale`.
  * @property {Record<string, unknown>} savedData - Previously saved form data (for editing)
  * @property {any} [formSchema] - JSON Schema for the form structure and validation (optional)
  * @property {any} [uiSchema] - UI Schema for form rendering layout (optional)
@@ -67,6 +67,17 @@ export interface FormInitData {
     custom_types: Record<string, { source: string }>;
     validators?: Record<string, { source: string }>;
   };
+  /**
+   * Linked child form specs for sub-observation column label resolution.
+   * Keys are form type ids (`linkedForm` values). Populated by Formulus at open time.
+   */
+  linkedFormSpecs?: Record<
+    string,
+    {
+      schema: unknown;
+      uiSchema: unknown;
+    }
+  >;
 }
 
 /**
diff --git a/formulus-formplayer/src/utils/controlDisplayText.test.ts b/formulus-formplayer/src/utils/controlDisplayText.test.ts
new file mode 100644
index 000000000..e11ef9f24
--- /dev/null
+++ b/formulus-formplayer/src/utils/controlDisplayText.test.ts
@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildControlIndexByFieldKey,
+  resolveControlLabel,
+  resolveFieldLabel,
+} from './controlDisplayText';
+import type { ControlProps } from '@jsonforms/core';
+
+describe('controlDisplayText', () => {
+  it('resolveControlLabel prefers uischema.label over props.label', () => {
+    const props = {
+      label: 'Schema title from JsonForms',
+      uischema: { label: 'UI label' },
+      schema: { title: 'Schema title' },
+    } as ControlProps;
+    expect(resolveControlLabel(props)).toBe('UI label');
+  });
+
+  it('resolveControlLabel falls back to props.label then schema title', () => {
+    const fromProps = {
+      label: 'From JsonForms',
+      uischema: {},
+      schema: { title: 'Schema title' },
+    } as ControlProps;
+    expect(resolveControlLabel(fromProps)).toBe('From JsonForms');
+
+    const schemaOnly = {
+      label: '',
+      uischema: {},
+      schema: { title: 'Schema title' },
+    } as ControlProps;
+    expect(resolveControlLabel(schemaOnly)).toBe('Schema title');
+  });
+
+  it('resolveFieldLabel uses localized ui label over schema title', () => {
+    const schema = {
+      properties: {
+        codigo: { type: 'string', title: 'Envelope code' },
+      },
+    };
+    const uischema = {
+      type: 'VerticalLayout',
+      elements: [
+        {
+          type: 'Control',
+          scope: '#/properties/codigo',
+          label: 'Scan the envelope code',
+        },
+      ],
+    };
+    expect(resolveFieldLabel(schema, uischema, 'codigo')).toBe(
+      'Scan the envelope code',
+    );
+  });
+
+  it('buildControlIndexByFieldKey maps scope to control', () => {
+    const uischema = {
+      type: 'Control',
+      scope: '#/properties/foo',
+      label: 'Foo',
+    };
+    const index = buildControlIndexByFieldKey(uischema);
+    expect(index.get('foo')?.label).toBe('Foo');
+  });
+});
diff --git a/formulus-formplayer/src/utils/controlDisplayText.ts b/formulus-formplayer/src/utils/controlDisplayText.ts
new file mode 100644
index 000000000..255e42eb4
--- /dev/null
+++ b/formulus-formplayer/src/utils/controlDisplayText.ts
@@ -0,0 +1,137 @@
+import { ControlProps, JsonSchema7, UISchemaElement } from '@jsonforms/core';
+
+type ControlUiNode = {
+  type?: string;
+  scope?: string;
+  label?: string | boolean;
+  elements?: UISchemaElement[];
+  options?: { columns?: UISchemaElement[] };
+};
+
+function scopeToFieldKey(scope: string): string | null {
+  const match = scope.match(/^#\/properties\/([^/]+)$/);
+  return match?.[1] ?? null;
+}
+
+function walkUiControls(
+  node: UISchemaElement | undefined,
+  visit: (control: ControlUiNode) => void,
+): void {
+  if (!node || typeof node !== 'object') return;
+  const obj = node as ControlUiNode;
+  if (obj.type === 'Control' && typeof obj.scope === 'string') {
+    visit(obj);
+  }
+  if (Array.isArray(obj.elements)) {
+    for (const child of obj.elements) {
+      walkUiControls(child, visit);
+    }
+  }
+  const cols = obj.options?.columns;
+  if (Array.isArray(cols)) {
+    for (const col of cols) {
+      walkUiControls(col, visit);
+    }
+  }
+}
+
+/** Build fieldKey → Control ui node index (first match wins). */
+export function buildControlIndexByFieldKey(
+  uischema: UISchemaElement | undefined,
+): Map<string, ControlUiNode> {
+  const index = new Map<string, ControlUiNode>();
+  walkUiControls(uischema, control => {
+    if (typeof control.scope !== 'string') return;
+    const key = scopeToFieldKey(control.scope);
+    if (key && !index.has(key)) {
+      index.set(key, control);
+    }
+  });
+  return index;
+}
+
+function labelFromControlAndSchema(
+  control: ControlUiNode | undefined,
+  fieldSchema: JsonSchema7 | undefined,
+  fieldKey: string,
+): string {
+  if (
+    control &&
+    typeof control.label === 'string' &&
+    control.label.length > 0
+  ) {
+    return control.label;
+  }
+  if (control && control.label === false) {
+    return '';
+  }
+  const title = fieldSchema?.title;
+  if (typeof title === 'string' && title.length > 0) {
+    return title;
+  }
+  return fieldKey;
+}
+
+/**
+ * Resolved display label for a Control renderer.
+ * Prefer `uischema.label` (post-`applyFormUiTranslations`) over JsonForms
+ * `props.label`, which often falls back to `schema.title` for the default locale.
+ */
+export function resolveControlLabel(props: ControlProps): string {
+  const uischema = props.uischema as ControlUiNode | undefined;
+  if (
+    uischema &&
+    typeof uischema.label === 'string' &&
+    uischema.label.length > 0
+  ) {
+    return uischema.label;
+  }
+  if (uischema?.label === false) {
+    return '';
+  }
+  const fromProps = props.label;
+  if (typeof fromProps === 'string' && fromProps.length > 0) {
+    return fromProps;
+  }
+  const schema = props.schema as JsonSchema7 | undefined;
+  const title = schema?.title;
+  if (typeof title === 'string' && title.length > 0) {
+    return title;
+  }
+  return typeof fromProps === 'string' ? fromProps : '';
+}
+
+export function resolveControlDescription(
+  props: ControlProps,
+): string | undefined {
+  const fromProps = props.description;
+  if (typeof fromProps === 'string' && fromProps.length > 0) {
+    return fromProps;
+  }
+  const schema = props.schema as JsonSchema7 | undefined;
+  const desc = schema?.description;
+  return typeof desc === 'string' && desc.length > 0 ? desc : undefined;
+}
+
+/**
+ * Display label for a top-level field when ControlProps is unavailable
+ * (header chips, finalize, errors).
+ */
+export function resolveFieldLabel(
+  schema: JsonSchema7 | undefined,
+  uischema: UISchemaElement | undefined,
+  fieldKey: string,
+  controlIndex?: Map<string, ControlUiNode>,
+): string {
+  const index = controlIndex ?? buildControlIndexByFieldKey(uischema);
+  const control = index.get(fieldKey);
+  const fieldSchema = schema?.properties?.[fieldKey] as JsonSchema7 | undefined;
+  return labelFromControlAndSchema(control, fieldSchema, fieldKey);
+}
+
+export type LinkedFormSpec = {
+  schema: JsonSchema7;
+  uiSchema: UISchemaElement;
+};
+
+export type LinkedFormSpecsMap = Record<string, LinkedFormSpec>;
diff --git a/formulus-formplayer/src/utils/errorPageNavigation.ts b/formulus-formplayer/src/utils/errorPageNavigation.ts
index 333b41187..0d2429738 100644
--- a/formulus-formplayer/src/utils/errorPageNavigation.ts
+++ b/formulus-formplayer/src/utils/errorPageNavigation.ts
@@ -8,6 +8,7 @@ import {
   type UISchemaElement,
 } from '@jsonforms/core';
 import type { BlockingValidationError } from './validationNavigation';
+import { resolveFieldLabel } from './controlDisplayText';
 
 function escapeRegex(segment: string): string {
   return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -185,27 +186,42 @@ function titleAtSchemaPath(
 export function titleForErrorPath(
   errorPath: string,
   schema: JsonSchema7 | undefined,
+  uischema?: UISchemaElement,
 ): string | null {
   const normalized = normalizeErrorInstancePath(errorPath);
   const propertyPath = normalized
     .split('/')
     .filter(segment => segment && !/^\d+$/.test(segment));
+
+  if (uischema && propertyPath.length === 1) {
+    return resolveFieldLabel(schema, uischema, propertyPath[0]!);
+  }
+
   return titleAtSchemaPath(schema, propertyPath);
 }
 
 /** Human-readable summary for skipFinalize Done alert (field titles, not count only). */
+export type OdeTranslateFn = (
+  key: string,
+  defaultMessage?: string,
+  vars?: Record<string, string | number>,
+) => string;
+
 export function formatBlockingErrorSummary(
   errors: ReadonlyArray<BlockingValidationError & { message?: string }>,
   schema: JsonSchema7 | undefined,
   maxTitles = 3,
+  t?: OdeTranslateFn,
+  uischema?: UISchemaElement,
 ): string {
+  const tr: OdeTranslateFn = t ?? ((_, def) => def ?? '');
   if (errors.length === 0) return '';
 
   const titles: string[] = [];
   for (const err of errors) {
     const path =
       err.instancePath ?? (typeof err.path === 'string' ? err.path : undefined);
-    const title = path ? titleForErrorPath(path, schema) : null;
+    const title = path ? titleForErrorPath(path, schema, uischema) : null;
     const label = title || err.message;
     if (label && !titles.includes(label)) titles.push(label);
     if (titles.length >= maxTitles) break;
@@ -213,13 +229,20 @@ export function formatBlockingErrorSummary(
 
   const remaining = errors.length - titles.length;
   const joined = titles.join(', ');
-  const suffix = remaining > 0 ? ` (+${remaining} more)` : '';
+  const suffix =
+    remaining > 0
+      ? ` ${tr('validation.moreFields', '(+{{count}} more)', { count: remaining })}`
+      : '';
   const countPhrase =
-    errors.length === 1 ? '1 field needs' : `${errors.length} fields need`;
+    errors.length === 1
+      ? tr('validation.oneFieldAttention', '1 field needs attention')
+      : tr('validation.fieldsAttention', '{{count}} fields need attention', {
+          count: errors.length,
+        });
 
   if (joined) {
-    return `${countPhrase} attention: ${joined}${suffix}. Tap Done to review.`;
+    return `${countPhrase}: ${joined}${suffix}. ${tr('validation.tapDoneToReview', 'Tap Done to review.')}`;
   }
 
-  return `${countPhrase} attention. Tap Done to review.`;
+  return `${countPhrase}. ${tr('validation.tapDoneToReview', 'Tap Done to review.')}`;
 }
diff --git a/formulus-formplayer/src/utils/formObservationData.test.ts b/formulus-formplayer/src/utils/formObservationData.test.ts
index 9f0f78297..0e97b3e1e 100644
--- a/formulus-formplayer/src/utils/formObservationData.test.ts
+++ b/formulus-formplayer/src/utils/formObservationData.test.ts
@@ -25,6 +25,7 @@ describe('initialFormDataFromParams', () => {
       theme: 'dark',
       darkMode: true,
       themeColors: { primary: '#000' },
+      locale: 'pt',
       species: 'oak',
     };
     expect(initialFormDataFromParams(params)).toEqual({ species: 'oak' });
diff --git a/formulus-formplayer/src/utils/formObservationData.ts b/formulus-formplayer/src/utils/formObservationData.ts
index 70fdb2cd0..c7ee38543 100644
--- a/formulus-formplayer/src/utils/formObservationData.ts
+++ b/formulus-formplayer/src/utils/formObservationData.ts
@@ -9,6 +9,8 @@ export const FORMPARAMS_NON_DATA_KEYS = new Set([
   'theme',
   'darkMode',
   'themeColors',
+  // UI locale from host — not observation data (distinct from optional schema `locale` field).
+  'locale',
   // Reserved read-only session context channel (see App init): a custom app may
   // pass `params.context` with session info (device role, selected cluster, ...)
   // that must never be persisted as observation data.
diff --git a/formulus-formplayer/src/utils/linkedFormUtils.ts b/formulus-formplayer/src/utils/linkedFormUtils.ts
new file mode 100644
index 000000000..d436dca09
--- /dev/null
+++ b/formulus-formplayer/src/utils/linkedFormUtils.ts
@@ -0,0 +1,35 @@
+/** Collect linkedForm ids from a form schema (recursive, includes nested sub-obs). */
+export function collectLinkedFormIds(
+  schema: unknown,
+  out: Set<string> = new Set(),
+): Set<string> {
+  if (!schema || typeof schema !== 'object') return out;
+  const obj = schema as Record<string, unknown>;
+
+  if (typeof obj.linkedForm === 'string' && obj.linkedForm.trim()) {
+    out.add(obj.linkedForm.trim());
+  }
+
+  if (obj.properties && typeof obj.properties === 'object') {
+    for (const val of Object.values(
+      obj.properties as Record<string, unknown>,
+    )) {
+      collectLinkedFormIds(val, out);
+    }
+  }
+
+  if (obj.items && typeof obj.items === 'object') {
+    collectLinkedFormIds(obj.items, out);
+  }
+
+  for (const key of ['allOf', 'anyOf', 'oneOf'] as const) {
+    const branch = obj[key];
+    if (Array.isArray(branch)) {
+      for (const sub of branch) {
+        collectLinkedFormIds(sub, out);
+      }
+    }
+  }
+
+  return out;
+}
diff --git a/formulus-formplayer/src/utils/subObservationColumnLabels.test.ts b/formulus-formplayer/src/utils/subObservationColumnLabels.test.ts
new file mode 100644
index 000000000..25599e96b
--- /dev/null
+++ b/formulus-formplayer/src/utils/subObservationColumnLabels.test.ts
@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import {
+  mergeSubObservationColumnDefs,
+  resolveSubObservationColumns,
+} from './subObservationColumnLabels';
+
+describe('subObservationColumnLabels', () => {
+  const childSpec = {
+    schema: {
+      properties: {
+        quarto_num: { type: 'string', title: 'Room number' },
+        quarto_display: { type: 'string', title: 'Summary' },
+      },
+    },
+    uiSchema: {
+      type: 'VerticalLayout',
+      elements: [
+        {
+          type: 'Control',
+          scope: '#/properties/quarto_num',
+          label: 'Room #',
+          translations: { pt: { label: 'Quarto nº' } },
+        },
+      ],
+    },
+  };
+
+  it('resolveSubObservationColumns uses static label when provided', () => {
+    const cols = resolveSubObservationColumns(
+      [{ key: 'quarto_num', label: 'Static' }],
+      'censo_milda_quarto',
+      { censo_milda_quarto: childSpec },
+    );
+    expect(cols).toEqual([{ key: 'quarto_num', label: 'Static' }]);
+  });
+
+  it('resolveSubObservationColumns resolves from linked child form', () => {
+    const cols = resolveSubObservationColumns(
+      [{ key: 'quarto_num' }, { key: 'quarto_display' }],
+      'censo_milda_quarto',
+      { censo_milda_quarto: childSpec },
+    );
+    expect(cols[0]?.label).toBe('Room #');
+    expect(cols[1]?.label).toBe('Summary');
+  });
+
+  it('mergeSubObservationColumnDefs merges ui options over schema', () => {
+    const merged = mergeSubObservationColumnDefs([{ key: 'a' }], {
+      options: { columns: [{ key: 'a', label: 'Override' }] },
+    });
+    expect(merged).toEqual([{ key: 'a', label: 'Override' }]);
+  });
+});
diff --git a/formulus-formplayer/src/utils/subObservationColumnLabels.ts b/formulus-formplayer/src/utils/subObservationColumnLabels.ts
new file mode 100644
index 000000000..146567794
--- /dev/null
+++ b/formulus-formplayer/src/utils/subObservationColumnLabels.ts
@@ -0,0 +1,75 @@
+import type { UISchemaElement } from '@jsonforms/core';
+import {
+  buildControlIndexByFieldKey,
+  type LinkedFormSpecsMap,
+  resolveFieldLabel,
+} from './controlDisplayText';
+import type { ColumnSpec } from '../renderers/subObservationHelpers';
+
+export type ColumnDef = { key: string; label?: string };
+
+function mergeColumnDefsByKey(
+  schemaColumns: ColumnDef[] | undefined,
+  uiColumns: ColumnDef[] | undefined,
+): ColumnDef[] {
+  const base = Array.isArray(schemaColumns) ? schemaColumns : [];
+  const patch = Array.isArray(uiColumns) ? uiColumns : [];
+  if (patch.length === 0) {
+    return base.map(c => ({ ...c }));
+  }
+  const result = base.map(c => ({ ...c }));
+  for (const patchCol of patch) {
+    if (!patchCol?.key) continue;
+    const idx = result.findIndex(c => c.key === patchCol.key);
+    if (idx >= 0) {
+      result[idx] = { ...result[idx], ...patchCol };
+    } else {
+      result.push({ ...patchCol });
+    }
+  }
+  return result;
+}
+
+/**
+ * Resolve sub-observation table column headers.
+ * - Explicit column.label → static override (all locales).
+ * - Otherwise → linked child form field label via resolveFieldLabel.
+ */
+export function resolveSubObservationColumns(
+  columnDefs: ColumnDef[],
+  linkedForm: string,
+  linkedFormSpecs: LinkedFormSpecsMap | undefined,
+): ColumnSpec[] {
+  const spec = linkedFormSpecs?.[linkedForm];
+  const childSchema = spec?.schema;
+  const childUi = spec?.uiSchema;
+  const childIndex =
+    childUi !== undefined ? buildControlIndexByFieldKey(childUi) : undefined;
+
+  return columnDefs.map(col => {
+    const staticLabel =
+      typeof col.label === 'string' && col.label.trim().length > 0
+        ? col.label.trim()
+        : null;
+    if (staticLabel) {
+      return { key: col.key, label: staticLabel };
+    }
+    if (childSchema && childIndex) {
+      return {
+        key: col.key,
+        label: resolveFieldLabel(childSchema, childUi, col.key, childIndex),
+      };
+    }
+    return { key: col.key, label: col.key };
+  });
+}
+
+export function mergeSubObservationColumnDefs(
+  schemaColumns: ColumnDef[] | undefined,
+  uischema: UISchemaElement | undefined,
+): ColumnDef[] {
+  const uiCols = (
+    uischema as { options?: { columns?: ColumnDef[] } } | undefined
+  )?.options?.columns;
+  return mergeColumnDefsByKey(schemaColumns, uiCols);
+}
diff --git a/formulus-formplayer/tsconfig.json b/formulus-formplayer/tsconfig.json
index e9a73ae77..680739687 100644
--- a/formulus-formplayer/tsconfig.json
+++ b/formulus-formplayer/tsconfig.json
@@ -19,5 +19,10 @@
     "jsx": "react-jsx"
   },
   "include": ["src"],
-  "exclude": ["src/**/__tests__/**", "src/**/*.test.ts", "src/stories/**"]
+  "exclude": [
+    "src/**/__tests__/**",
+    "src/**/*.test.ts",
+    "src/**/*.test.tsx",
+    "src/stories/**"
+  ]
 }
diff --git a/formulus/.prettierignore b/formulus/.prettierignore
index f83ff68d4..a7245668b 100644
--- a/formulus/.prettierignore
+++ b/formulus/.prettierignore
@@ -1,6 +1,6 @@
 node_modules
+third_party
 android
 ios
 coverage
 
-
diff --git a/formulus/AGENTS.md b/formulus/AGENTS.md
index f6fee055c..5511c9670 100644
--- a/formulus/AGENTS.md
+++ b/formulus/AGENTS.md
@@ -33,6 +33,13 @@
 - **Custom apps** are HTML/JS/CSS bundles loaded from Synkronus; they receive the **Formulus** injected API (see interface definition). Authors do not need this monorepo — public docs and [custom_app](https://github.com/OpenDataEnsemble/custom_app) describe usage.
 - **Formplayer** is a sibling package; after changing `FormulusInterfaceDefinition.ts`, run **`pnpm run sync-interface`** (or build) in **formulus-formplayer** so its copy stays aligned.
 
+## UI language (i18n)
+
+- **Settings → Language** (`SettingsScreen`): Auto / `en` / `pt` / `fr`; stored in AsyncStorage (`@ode/uiLocale`) via [`LocaleSettingsService`](src/services/LocaleSettingsService.ts).
+- Resolution: [`src/lib/locale.ts`](src/lib/locale.ts) — preference → device → `app.config.json` `defaultLocale` → `en`.
+- Shell strings: `react-i18next` + [`src/locales/`](src/locales/).
+- Formplayer receives resolved locale as `params.locale` from [`FormplayerModal`](src/components/FormplayerModal.tsx).
+
 ---
 
 ## Changing the bridge
diff --git a/formulus/App.tsx b/formulus/App.tsx
index 58fdafba2..b944f94f5 100644
--- a/formulus/App.tsx
+++ b/formulus/App.tsx
@@ -4,8 +4,9 @@ import {
   DefaultTheme,
   DarkTheme,
 } from '@react-navigation/native';
-import { StatusBar, Alert } from 'react-native';
+import { StatusBar, Alert, View, ActivityIndicator } from 'react-native';
 import { SafeAreaProvider } from 'react-native-safe-area-context';
+import { I18nextProvider } from 'react-i18next';
 import 'react-native-url-polyfill/auto';
 import { FormService } from './src/services/FormService';
 import {
@@ -25,6 +26,7 @@ import SignatureCaptureModal from './src/components/SignatureCaptureModal';
 import MainAppNavigator from './src/navigation/MainAppNavigator';
 import { FormInitData } from './src/webview/FormulusInterfaceDefinition.ts';
 import { FormSpec } from './src/services';
+import { initFormulusI18n, i18n } from './src/i18n';
 
 /**
  * Inner component that consumes the AppTheme context to build a dynamic
@@ -315,16 +317,35 @@ function AppInner(): React.JSX.Element {
  * custom app's brand colors are available to all native UI elements.
  */
 function App(): React.JSX.Element {
+  const [i18nReady, setI18nReady] = useState(false);
+
+  useEffect(() => {
+    void initFormulusI18n().then(() => setI18nReady(true));
+  }, []);
+
+  if (!i18nReady) {
+    return (
+      <SafeAreaProvider>
+        <View
+          style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
+          <ActivityIndicator size="large" />
+        </View>
+      </SafeAreaProvider>
+    );
+  }
+
   return (
-    <SafeAreaProvider>
-      <SyncProvider>
-        <AppThemeProvider>
-          <ConfirmModalProvider>
-            <AppInner />
-          </ConfirmModalProvider>
-        </AppThemeProvider>
-      </SyncProvider>
-    </SafeAreaProvider>
+    <I18nextProvider i18n={i18n}>
+      <SafeAreaProvider>
+        <SyncProvider>
+          <AppThemeProvider>
+            <ConfirmModalProvider>
+              <AppInner />
+            </ConfirmModalProvider>
+          </AppThemeProvider>
+        </SyncProvider>
+      </SafeAreaProvider>
+    </I18nextProvider>
   );
 }
 
diff --git a/formulus/android/app/src/main/assets/webview/FormulusInjectionScript.js b/formulus/android/app/src/main/assets/webview/FormulusInjectionScript.js
index 62d0f6a7e..278d8e244 100644
--- a/formulus/android/app/src/main/assets/webview/FormulusInjectionScript.js
+++ b/formulus/android/app/src/main/assets/webview/FormulusInjectionScript.js
@@ -1,6 +1,6 @@
 // Auto-generated from FormulusInterfaceDefinition.ts
 // Do not edit directly - this file will be overwritten
-// Last generated: 2026-05-16T12:40:22.983Z
+// Last generated: 2026-06-19T16:58:11.324Z
 
 (function () {
   // Enhanced API availability detection and recovery
@@ -229,7 +229,7 @@
       });
     },
 
-    // openFormplayer: formType: string, params: Record<string, unknown>, savedData: Record<string, unknown>, options: { subObservationMode?: boolean; } => Promise<FormCompletionResult>
+    // openFormplayer: formType: string, params: Record<string, unknown>, savedData: Record<string, unknown>, options: { subObservationMode?: boolean; skipFinalize?: boolean; skipDraftSelection?: boolean; observationId?: string; } => Promise<FormCompletionResult>
     openFormplayer: function (formType, params, savedData, options) {
       return new Promise((resolve, reject) => {
         const messageId =
@@ -664,6 +664,251 @@
       });
     },
 
+    // getCachedLocation: fieldId: string => Promise<LocationResult>
+    getCachedLocation: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getCachedLocation callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getCachedLocation callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getCachedLocation_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
+              } else {
+                resolve(data.result);
+              }
+            }
+          } catch (e) {
+            console.error(
+              "'getCachedLocation' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
+            type: 'getCachedLocation',
+            messageId,
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
+    // allocateSequence: scopeKey: string, options: { startAt?: number; peek?: boolean; } => Promise<number>
+    allocateSequence: function (scopeKey, options) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('allocateSequence callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'allocateSequence callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'allocateSequence_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
+              } else {
+                resolve(data.result);
+              }
+            }
+          } catch (e) {
+            console.error(
+              "'allocateSequence' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
+            type: 'allocateSequence',
+            messageId,
+            scopeKey: scopeKey,
+            options: options,
+          }),
+        );
+      });
+    },
+
+    // watchLocation: fieldId: string => Promise<{ status: "started" | "error"; message?: string; }>
+    watchLocation: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('watchLocation callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'watchLocation callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'watchLocation_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
+              } else {
+                resolve(data.result);
+              }
+            }
+          } catch (e) {
+            console.error(
+              "'watchLocation' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
+            type: 'watchLocation',
+            messageId,
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
+    // stopWatchLocation: fieldId: string => Promise<void>
+    stopWatchLocation: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('stopWatchLocation callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'stopWatchLocation callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'stopWatchLocation_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
+              } else {
+                resolve(data.result);
+              }
+            }
+          } catch (e) {
+            console.error(
+              "'stopWatchLocation' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
+            type: 'stopWatchLocation',
+            messageId,
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
     // requestFile: fieldId: string => Promise<FileResult>
     requestFile: function (fieldId) {
       return new Promise((resolve, reject) => {
@@ -1637,6 +1882,245 @@
         );
       });
     },
+
+    // persistObservation: input: PersistObservationInput => Promise<PersistObservationResult>
+    persistObservation: function (input) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('persistObservation callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'persistObservation callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'persistObservation_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
+              } else {
+                resolve(data.result);
+              }
+            }
+          } catch (e) {
+            console.error(
+              "'persistObservation' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
+            type: 'persistObservation',
+            messageId,
+            input: input,
+          }),
+        );
+      });
+    },
+
+    // sync: options: { includeAttachments?: boolean; } => Promise<SyncResult>
+    sync: function (options) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('sync callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'sync callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (data.type === 'sync_response' && data.messageId === messageId) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
+              } else {
+                resolve(data.result);
+              }
+            }
+          } catch (e) {
+            console.error(
+              "'sync' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
+            type: 'sync',
+            messageId,
+            options: options,
+          }),
+        );
+      });
+    },
+
+    // getConnectivityStatus:  => Promise<ConnectivityStatus>
+    getConnectivityStatus: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getConnectivityStatus callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getConnectivityStatus callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getConnectivityStatus_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
+              } else {
+                resolve(data.result);
+              }
+            }
+          } catch (e) {
+            console.error(
+              "'getConnectivityStatus' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
+            type: 'getConnectivityStatus',
+            messageId,
+          }),
+        );
+      });
+    },
+
+    // getCurrentDataRevisionCount:  => Promise<number>
+    getCurrentDataRevisionCount: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getCurrentDataRevisionCount callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getCurrentDataRevisionCount callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getCurrentDataRevisionCount_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
+              } else {
+                resolve(data.result);
+              }
+            }
+          } catch (e) {
+            console.error(
+              "'getCurrentDataRevisionCount' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
+            type: 'getCurrentDataRevisionCount',
+            messageId,
+          }),
+        );
+      });
+    },
   };
 
   // Register the callback handler with the window object
diff --git a/formulus/android/app/src/main/assets/webview/formulus-api.js b/formulus/android/app/src/main/assets/webview/formulus-api.js
index c46263561..f4d47b754 100644
--- a/formulus/android/app/src/main/assets/webview/formulus-api.js
+++ b/formulus/android/app/src/main/assets/webview/formulus-api.js
@@ -5,7 +5,7 @@
  * that's available in the WebView context as `globalThis.formulus`.
  *
  * This file is auto-generated from FormulusInterfaceDefinition.ts
- * Last generated: 2026-05-16T12:40:24.252Z
+ * Last generated: 2026-06-19T16:58:11.756Z
  *
  * @example
  * // In your JavaScript file:
@@ -29,24 +29,29 @@
  */
 const FormulusAPI = {
   /**
-   * Get the current version of the Formulus API
-   * /
-   * @returns {Promise<string>} The API version
+   * Get the current version of the Formulus bridge API (the interface contract
+   * version, e.g. for {@link isCompatibleVersion} checks).
+   * @returns {Promise<string>} The API version (semver)
    */
   getVersion: function () {},
 
   /**
    * Get a list of available forms
-   * /
    * @returns {Promise<FormInfo[]>} Array of form information objects
    */
   getAvailableForms: function () {},
 
   /**
    * Open Formplayer with the specified form
-   * /
+   * Reserved keys are not treated as observation data:
+   * `defaultData` (prefill), `theme`/`darkMode`/`themeColors` (theming), and
+   * `context` — a read-only **session context** object (device role, selected cluster,
+   * ...) that Formplayer never persists and exposes to extensions as
+   * `window.formulusSessionContext`. Draft bypass is not a param key — use
+   * `options.skipDraftSelection` on {@link openFormplayer} (same as `skipFinalize`).
+   * observation instead of creating a new one
    * @param {string} formType - The identifier of the formtype to open
-   * @param {Object} params - Additional parameters for form initialization
+   * @param {Object} params - Additional parameters for form initialization.
    * @param {Object} savedData - Previously saved form data (for editing)
    * @returns {Promise<FormCompletionResult>} Promise that resolves when the form is completed/closed with result details
    */
@@ -54,7 +59,6 @@ const FormulusAPI = {
 
   /**
    * Get observations for a specific form
-   * /
    * @param {string} formType - The identifier of the formtype
    * @returns {Promise<FormObservation[]>} Array of form observations
    */
@@ -64,14 +68,12 @@ const FormulusAPI = {
    * Get observations with optional WHERE clause filtering (for dynamic choice lists).
    * Supports format: data.field = 'value' AND data.other = 'value'
    * Age filtering via age_from_dob(data.dob) is handled client-side in formplayer.
-   * /
    * @returns {Promise<FormObservation[]>} Array of filtered observations
    */
   getObservationsByQuery: function (options) {},
 
   /**
    * Submit a completed form
-   * /
    * @param {string} formType - The identifier of the formtype
    * @param {Object} finalData - The final form data to submit
    * @returns {Promise<string>} The observationId of the submitted form
@@ -80,7 +82,6 @@ const FormulusAPI = {
 
   /**
    * Update an existing form
-   * /
    * @param {string} observationId - The identifier of the observation
    * @param {string} formType - The identifier of the formtype
    * @param {Object} finalData - The final form data to update
@@ -90,7 +91,6 @@ const FormulusAPI = {
 
   /**
    * Request camera access for a field
-   * /
    * @param {string} fieldId - The ID of the field
    * @returns {Promise<CameraResult>} Promise that resolves with camera result or rejects on error/cancellation
    */
@@ -98,15 +98,35 @@ const FormulusAPI = {
 
   /**
    * Request location for a field (captures into the form GPS field).
-   * /
    * @param {string} fieldId - The ID of the field
    * @returns {Promise<LocationResult>} Promise that resolves with location result or rejects on error
    */
   requestLocation: function (fieldId) {},
 
+  /**
+   * Return the best cached device fix (if any) without forcing a new GPS read.
+   */
+  getCachedLocation: function (fieldId) {},
+
+  /**
+   * Allocate the next monotonic integer in a device-local scope.
+   * Formulus prepends `device:{deviceId}:` to the app-authored `scopeKey` suffix.
+   */
+  allocateSequence: function (scopeKey, options) {},
+
+  /**
+   * Subscribe to location updates while the custom app WebView is active.
+   * Updates arrive as `locationWatchUpdate` window messages.
+   */
+  watchLocation: function (fieldId) {},
+
+  /**
+   * Stop a prior `watchLocation` subscription for `fieldId`.
+   */
+  stopWatchLocation: function (fieldId) {},
+
   /**
    * Request file selection for a field
-   * /
    * @param {string} fieldId - The ID of the field
    * @returns {Promise<FileResult>} Promise that resolves with file result or rejects on error/cancellation
    */
@@ -114,7 +134,6 @@ const FormulusAPI = {
 
   /**
    * Launch an external intent
-   * /
    * @param {string} fieldId - The ID of the field
    * @param {Object} intentSpec - The intent specification
    * @returns {Promise<void>}
@@ -123,7 +142,6 @@ const FormulusAPI = {
 
   /**
    * Call a subform
-   * /
    * @param {string} fieldId - The ID of the field
    * @param {string} formType - The ID of the subform
    * @param {Object} options - Additional options for the subform
@@ -133,7 +151,6 @@ const FormulusAPI = {
 
   /**
    * Request audio recording for a field
-   * /
    * @param {string} fieldId - The ID of the field
    * @returns {Promise<AudioResult>} Promise that resolves with audio result or rejects on error/cancellation
    */
@@ -141,7 +158,6 @@ const FormulusAPI = {
 
   /**
    * Request video recording for a field (camera / picker — host-defined).
-   * /
    * @param {string} fieldId - The ID of the field
    * @returns {Promise<VideoResult>} Promise that resolves with video result or rejects on error/cancellation
    */
@@ -149,7 +165,6 @@ const FormulusAPI = {
 
   /**
    * Request QR code scanning for a field
-   * /
    * @param {string} fieldId - The ID of the field
    * @returns {Promise<QrcodeResult>} Promise that resolves with QR code result or rejects on error/cancellation
    */
@@ -157,7 +172,6 @@ const FormulusAPI = {
 
   /**
    * Request biometric authentication
-   * /
    * @param {string} fieldId - The ID of the field
    * @returns {Promise<void>}
    */
@@ -165,21 +179,18 @@ const FormulusAPI = {
 
   /**
    * Request the current connectivity status
-   * /
    * @returns {Promise<void>}
    */
   requestConnectivityStatus: function () {},
 
   /**
    * Request the current sync status
-   * /
    * @returns {Promise<void>}
    */
   requestSyncStatus: function () {},
 
   /**
    * Run a local ML model
-   * /
    * @param {string} fieldId - The ID of the field
    * @param {string} modelId - The ID of the model to run
    * @param {Object} input - The input data for the model
@@ -190,14 +201,12 @@ const FormulusAPI = {
   /**
    * Get information about the currently authenticated user.
    * When no one is logged in, resolves with `{ username: '' }` (does not reject).
-   * /
    * @returns {Promise<{username: string, displayName?: string, role?: 'read-only' | 'read-write' | 'admin'}
    */
   getCurrentUser: function () {},
 
   /**
    * Get the current theme mode (System / Light / Dark) so custom apps can match the host app.
-   * /
    * @returns {Promise<'light' | 'dark' | 'system'>} Current theme mode; 'system' means follow device preference.
    */
   getThemeMode: function () {},
@@ -211,7 +220,6 @@ const FormulusAPI = {
    * Legacy locations (`attachments/<name>` and `attachments/pending_upload/<name>`) are also checked.
    * Path segments and ".." are rejected.
    * **`AttachmentDisplayDescriptor`:** `{ filename }` basename only (same lookup as a string argument).
-   * /
    * @returns {Promise<string | null>} Display URL, or `null` if none
    */
   getAttachmentUri: function (fileName) {},
@@ -225,14 +233,12 @@ const FormulusAPI = {
    * parent directory, which mixed committed files with `draft/` and
    * `pending_upload/` subfolders. Custom apps that iterate this URL will now
    * see only fully-committed attachments.
-   * /
    * @returns {Promise<string>} e.g. `file:///.../attachments/synced/`
    */
   getAttachmentsUri: function () {},
 
   /**
    * Base `file://` URL for the custom app bundle root (`DocumentDirectory/app/`, trailing slash).
-   * /
    * @returns {Promise<string>} App directory URL for extensions, question_types, etc.
    */
   getCustomAppUri: function () {},
@@ -240,10 +246,50 @@ const FormulusAPI = {
   /**
    * Primary `file://` URL for downloaded form specs (`DocumentDirectory/forms/`, trailing slash).
    * Some bundles also use files under the custom app `forms/` subdirectory.
-   * /
    * @returns {Promise<string>} Forms directory URL
    */
   getFormSpecsUri: function () {},
+
+  /**
+   * Persist an observation **without opening Formplayer** (headless write).
+   * Intended for custom apps that create or update records programmatically.
+   * Uses the same persistence path as a Formplayer submit, including promotion
+   * of any referenced draft attachments. Provide `observationId` to update an
+   * existing row; omit it to create a new one.
+   * @since 1.3.0
+   * @param {PersistObservationInput} input - The observation to persist
+   * @returns {Promise<PersistObservationResult>} The stored observation id and data
+   */
+  persistObservation: function (input) {},
+
+  /**
+   * Trigger a synchronization with Synkronus (pull + push).
+   * Resolves when the sync completes; rejects if a sync is already in progress
+   * or the sync fails. Attachments are excluded by default for speed.
+   * @since 1.3.0
+   * @returns {Promise<SyncResult>} The final data version after sync
+   */
+  sync: function (options) {},
+
+  /**
+   * Probe connectivity to the configured Synkronus server (`GET /health`).
+   * Never rejects for an offline device — returns `{ online: false }` so callers
+   * can branch on connectivity without try/catch. Suitable for the
+   * "verify subject details when online, fall back when offline" pattern.
+   * @since 1.3.0
+   * @returns {Promise<ConnectivityStatus>} The current connectivity status
+   */
+  getConnectivityStatus: function () {},
+
+  /**
+   * Read the device's last-known Synkronus data revision (`current_version`
+   * from the most recent successful sync). Reflects server-stream alignment
+   * only — not unsynced local edits. Use with periodic polling or after
+   * {@link sync} to detect when another device has pushed changes.
+   * @since 1.4.0
+   * @returns {Promise<number>} Non-negative revision count (0 if never synced)
+   */
+  getCurrentDataRevisionCount: function () {},
 };
 
 // Make the API available globally in browser environments
diff --git a/formulus/android/app/src/main/assets/webview/placeholder_app.html b/formulus/android/app/src/main/assets/webview/placeholder_app.html
index 9fe62ead1..a96d89fac 100644
--- a/formulus/android/app/src/main/assets/webview/placeholder_app.html
+++ b/formulus/android/app/src/main/assets/webview/placeholder_app.html
@@ -1,12 +1,12 @@
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
   <head>
     <title>Custom App Placeholder</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <style>
       /* ODE_TOKENS_START */
 /*
-       * ODE design tokens — generated from packages/tokens. Do not edit; run npm run generate:placeholder-tokens to update.
+       * ODE design tokens — generated from packages/tokens. Do not edit; run pnpm run generate:placeholder-tokens to update.
        */
       :root {
         /* color.brand.primary */
@@ -54,8 +54,11 @@
       }
       /* ODE_TOKENS_END */
 
-      * { box-sizing: border-box; }
-      html, body {
+      * {
+        box-sizing: border-box;
+      }
+      html,
+      body {
         margin: 0;
         padding: 0;
         min-height: 100%;
@@ -70,12 +73,14 @@
         justify-content: center;
         padding: var(--spacing-8);
         background: transparent;
-        transition: color 0.2s ease, background-color 0.2s ease;
+        transition:
+          color 0.2s ease,
+          background-color 0.2s ease;
       }
-      [data-theme="light"] body {
+      [data-theme='light'] body {
         color: var(--color-neutral-600);
       }
-      [data-theme="dark"] body {
+      [data-theme='dark'] body {
         color: var(--color-neutral-white);
       }
       html:not([data-theme]) body {
@@ -105,10 +110,10 @@
         line-height: var(--line-height-normal);
         margin: 0 0 var(--spacing-8);
       }
-      [data-theme="dark"] .placeholder-subtitle {
+      [data-theme='dark'] .placeholder-subtitle {
         color: var(--color-neutral-400);
       }
-      [data-theme="light"] .placeholder-subtitle {
+      [data-theme='light'] .placeholder-subtitle {
         color: var(--color-neutral-600);
       }
 
@@ -127,7 +132,9 @@
         border: var(--border-width-thin) solid var(--color-brand-primary-500);
         border-radius: var(--border-radius-md);
         cursor: pointer;
-        transition: background-color 0.15s ease, color 0.15s ease;
+        transition:
+          background-color 0.15s ease,
+          color 0.15s ease;
         margin-bottom: var(--spacing-8);
       }
       .placeholder-btn:hover,
@@ -140,29 +147,30 @@
         font-size: var(--font-size-sm);
         margin: 0 0 var(--spacing-2);
       }
-      [data-theme="dark"] .placeholder-tagline {
+      [data-theme='dark'] .placeholder-tagline {
         color: var(--color-neutral-white);
       }
-      [data-theme="light"] .placeholder-tagline {
+      [data-theme='light'] .placeholder-tagline {
         color: var(--color-neutral-600);
       }
       .placeholder-version {
         font-size: var(--font-size-xs);
         margin: 0;
       }
-      [data-theme="dark"] .placeholder-version {
+      [data-theme='dark'] .placeholder-version {
         color: var(--color-neutral-400);
       }
-      [data-theme="light"] .placeholder-version {
+      [data-theme='light'] .placeholder-version {
         color: var(--color-neutral-600);
       }
     </style>
   </head>
   <body>
     <div class="placeholder-card">
-      <h1 class="placeholder-title">Your Custom<br>App</h1>
+      <h1 class="placeholder-title">Your Custom<br />App</h1>
       <p class="placeholder-subtitle" id="subtitle-text">
-        <strong>Login</strong> and <strong>Update App Bundle</strong> to load your forms
+        <strong>Login</strong> and <strong>Update App Bundle</strong> to load
+        your forms
       </p>
       <button
         type="button"
@@ -175,129 +183,156 @@ <h1 class="placeholder-title">Your Custom<br>App</h1>
       <p class="placeholder-version" id="version-el">v0.1.0-native</p>
     </div>
     <script>
-    (function() {
-      function setTheme(mode) {
-        document.documentElement.setAttribute('data-theme', mode === 'dark' ? 'dark' : 'light');
-      }
-      window.__formulusSetTheme = setTheme;
+      (function () {
+        function setTheme(mode) {
+          document.documentElement.setAttribute(
+            'data-theme',
+            mode === 'dark' ? 'dark' : 'light',
+          );
+        }
+        window.__formulusSetTheme = setTheme;
 
-      function navigateToLogin() {
-        try {
-          if (window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === 'function') {
-            window.ReactNativeWebView.postMessage(JSON.stringify({ type: 'formulusNavigateToSettings' }));
+        function navigateToLogin() {
+          try {
+            if (
+              window.ReactNativeWebView &&
+              typeof window.ReactNativeWebView.postMessage === 'function'
+            ) {
+              window.ReactNativeWebView.postMessage(
+                JSON.stringify({ type: 'formulusNavigateToSettings' }),
+              );
+            }
+          } catch (e) {
+            console.error(
+              'Placeholder: failed to post formulusNavigateToSettings',
+              e,
+            );
           }
-        } catch (e) {
-          console.error('Placeholder: failed to post formulusNavigateToSettings', e);
         }
-      }
 
-      function navigateToSync() {
-        try {
-          if (window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === 'function') {
-            window.ReactNativeWebView.postMessage(JSON.stringify({ type: 'formulusNavigateToSync' }));
+        function navigateToSync() {
+          try {
+            if (
+              window.ReactNativeWebView &&
+              typeof window.ReactNativeWebView.postMessage === 'function'
+            ) {
+              window.ReactNativeWebView.postMessage(
+                JSON.stringify({ type: 'formulusNavigateToSync' }),
+              );
+            }
+          } catch (e) {
+            console.error(
+              'Placeholder: failed to post formulusNavigateToSync',
+              e,
+            );
           }
-        } catch (e) {
-          console.error('Placeholder: failed to post formulusNavigateToSync', e);
         }
-      }
 
-      var loginBtn = document.getElementById('login-btn');
-      var subtitleEl = document.getElementById('subtitle-text');
+        var loginBtn = document.getElementById('login-btn');
+        var subtitleEl = document.getElementById('subtitle-text');
 
-      /** Logged-out copy: bold Login + Update App Bundle. Logged-in copy: bold Update App Bundle only. */
-      var SUBTITLE_LOGIN =
-        '<strong>Login</strong> and <strong>Update App Bundle</strong> to load your forms';
-      var SUBTITLE_UPDATE =
-        '<strong>Update App Bundle</strong> to load your forms';
+        /** Logged-out copy: bold Login + Update App Bundle. Logged-in copy: bold Update App Bundle only. */
+        var SUBTITLE_LOGIN =
+          '<strong>Login</strong> and <strong>Update App Bundle</strong> to load your forms';
+        var SUBTITLE_UPDATE =
+          '<strong>Update App Bundle</strong> to load your forms';
 
-      function setButtonMode(mode) {
-        if (!loginBtn) return;
-        if (mode === 'sync') {
-          // Logged in: button goes to Sync screen to update app bundle
-          loginBtn.textContent = 'Update Now';
-          loginBtn.setAttribute('aria-label', 'Update App Bundle to load forms');
-          loginBtn.onclick = navigateToSync;
-          if (subtitleEl) subtitleEl.innerHTML = SUBTITLE_UPDATE;
-        } else {
-          loginBtn.textContent = 'Login Now';
-          loginBtn.setAttribute('aria-label', 'Login to load forms');
-          loginBtn.onclick = navigateToLogin;
-          if (subtitleEl) subtitleEl.innerHTML = SUBTITLE_LOGIN;
+        function setButtonMode(mode) {
+          if (!loginBtn) return;
+          if (mode === 'sync') {
+            // Logged in: button goes to Sync screen to update app bundle
+            loginBtn.textContent = 'Update Now';
+            loginBtn.setAttribute(
+              'aria-label',
+              'Update App Bundle to load forms',
+            );
+            loginBtn.onclick = navigateToSync;
+            if (subtitleEl) subtitleEl.innerHTML = SUBTITLE_UPDATE;
+          } else {
+            loginBtn.textContent = 'Login Now';
+            loginBtn.setAttribute('aria-label', 'Login to load forms');
+            loginBtn.onclick = navigateToLogin;
+            if (subtitleEl) subtitleEl.innerHTML = SUBTITLE_LOGIN;
+          }
         }
-      }
 
-      function refreshLoginState() {
-        try {
-          var api = window.formulus || globalThis.formulus;
-          if (!api || typeof api.getCurrentUser !== 'function') {
+        function refreshLoginState() {
+          try {
+            var api = window.formulus || globalThis.formulus;
+            if (!api || typeof api.getCurrentUser !== 'function') {
+              setButtonMode('login');
+              return;
+            }
+            api
+              .getCurrentUser()
+              .then(function (user) {
+                if (user && user.username) {
+                  setButtonMode('sync');
+                } else {
+                  setButtonMode('login');
+                }
+              })
+              .catch(function () {
+                setButtonMode('login');
+              });
+          } catch (e) {
+            console.error('Placeholder: failed to refresh login state', e);
             setButtonMode('login');
-            return;
           }
-          api
-            .getCurrentUser()
-            .then(function(user) {
-              if (user && user.username) {
-                setButtonMode('sync');
-              } else {
-                setButtonMode('login');
-              }
-            })
-            .catch(function() {
-              setButtonMode('login');
-            });
-        } catch (e) {
-          console.error('Placeholder: failed to refresh login state', e);
-          setButtonMode('login');
         }
-      }
 
-      // Expose a hook so the native app can force-refresh the button state
-      window.__formulusPlaceholderRefreshLoginState = refreshLoginState;
+        // Expose a hook so the native app can force-refresh the button state
+        window.__formulusPlaceholderRefreshLoginState = refreshLoginState;
 
-      // Default state before we know anything about login
-      setButtonMode('login');
+        // Default state before we know anything about login
+        setButtonMode('login');
 
-      function waitForFormulus(cb, tries) {
-        tries = tries !== undefined ? tries : 50;
-        var api = window.formulus || globalThis.formulus;
-        if (api && typeof api.getVersion === 'function') {
-          try {
-            var versionPromise = api.getVersion();
-            if (versionPromise && typeof versionPromise.then === 'function') {
-              versionPromise.then(function(v) {
+        function waitForFormulus(cb, tries) {
+          tries = tries !== undefined ? tries : 50;
+          var api = window.formulus || globalThis.formulus;
+          if (api && typeof api.getVersion === 'function') {
+            try {
+              var versionPromise = api.getVersion();
+              if (versionPromise && typeof versionPromise.then === 'function') {
+                versionPromise
+                  .then(function (v) {
+                    var el = document.getElementById('version-el');
+                    if (el && typeof v === 'string') el.textContent = 'v' + v;
+                    if (typeof cb === 'function') cb();
+                  })
+                  .catch(function () {
+                    if (typeof cb === 'function') cb();
+                  });
+              } else {
                 var el = document.getElementById('version-el');
-                if (el && typeof v === 'string') el.textContent = 'v' + v;
-                if (typeof cb === 'function') cb();
-              }).catch(function() {
+                if (el && typeof versionPromise === 'string')
+                  el.textContent = 'v' + versionPromise;
                 if (typeof cb === 'function') cb();
-              });
-            } else {
-              var el = document.getElementById('version-el');
-              if (el && typeof versionPromise === 'string') el.textContent = 'v' + versionPromise;
+              }
+            } catch (err) {
               if (typeof cb === 'function') cb();
             }
-          } catch (err) {
+          } else if (tries > 0) {
+            setTimeout(function () {
+              waitForFormulus(cb, tries - 1);
+            }, 100);
+          } else {
             if (typeof cb === 'function') cb();
           }
-        } else if (tries > 0) {
-          setTimeout(function() { waitForFormulus(cb, tries - 1); }, 100);
-        } else {
-          if (typeof cb === 'function') cb();
         }
-      }
 
-      if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', function() {
-          waitForFormulus(function() {
+        if (document.readyState === 'loading') {
+          document.addEventListener('DOMContentLoaded', function () {
+            waitForFormulus(function () {
+              refreshLoginState();
+            });
+          });
+        } else {
+          waitForFormulus(function () {
             refreshLoginState();
           });
-        });
-      } else {
-        waitForFormulus(function() {
-          refreshLoginState();
-        });
-      }
-    })();
+        }
+      })();
     </script>
   </body>
 </html>
diff --git a/formulus/assets/webview/FormulusInjectionScript.js b/formulus/assets/webview/FormulusInjectionScript.js
index 5c071dd1e..278d8e244 100644
--- a/formulus/assets/webview/FormulusInjectionScript.js
+++ b/formulus/assets/webview/FormulusInjectionScript.js
@@ -2,37 +2,50 @@
 // Do not edit directly - this file will be overwritten
 // Last generated: 2026-06-19T16:58:11.324Z
 
-(function() {
+(function () {
   // Enhanced API availability detection and recovery
   function getFormulus() {
     // Check multiple locations where the API might exist
-    return globalThis.formulus || (typeof window !== 'undefined' ? window.formulus : undefined);
+    return (
+      globalThis.formulus ||
+      (typeof window !== 'undefined' ? window.formulus : undefined)
+    );
   }
 
   function isFormulusAvailable() {
     const api = getFormulus();
-    return api && typeof api === 'object' && typeof api.getVersion === 'function';
+    return (
+      api && typeof api === 'object' && typeof api.getVersion === 'function'
+    );
   }
 
   // Idempotent guard to avoid double-initialization when scripts are reinjected
-  if ((globalThis).__formulusBridgeInitialized) {
+  if (globalThis.__formulusBridgeInitialized) {
     if (isFormulusAvailable()) {
-      console.debug('Formulus bridge already initialized and functional. Skipping duplicate injection.');
+      console.debug(
+        'Formulus bridge already initialized and functional. Skipping duplicate injection.',
+      );
       return;
     } else {
-      console.warn('Formulus bridge flag is set but API is not functional. Proceeding with re-injection...');
+      console.warn(
+        'Formulus bridge flag is set but API is not functional. Proceeding with re-injection...',
+      );
     }
   }
 
   // If API already exists and is functional, skip injection
   if (isFormulusAvailable()) {
-    console.debug('Formulus interface already exists and is functional. Skipping injection.');
+    console.debug(
+      'Formulus interface already exists and is functional. Skipping injection.',
+    );
     return;
   }
 
   // If API exists but is not functional, log warning and proceed with re-injection
   if (getFormulus()) {
-    console.warn('Formulus interface exists but appears non-functional. Re-injecting...');
+    console.warn(
+      'Formulus interface exists but appears non-functional. Re-injecting...',
+    );
   }
 
   // Helper function to handle callbacks
@@ -48,7 +61,7 @@
 
   // Initialize callbacks
   const callbacks = {};
-  
+
   // Global function to handle responses from React Native
   function handleMessage(event) {
     try {
@@ -61,1625 +74,2087 @@
         // console.warn('Global handleMessage: Received message with unexpected data type:', typeof event.data, event.data);
         return; // Or handle error, but for now, just return to avoid breaking others.
       }
-      
+
       // Handle callbacks
-      if (data.type === 'callback' && data.callbackId && callbacks[data.callbackId]) {
+      if (
+        data.type === 'callback' &&
+        data.callbackId &&
+        callbacks[data.callbackId]
+      ) {
         handleCallback(callbacks[data.callbackId], data.data);
         delete callbacks[data.callbackId];
       }
-      
+
       // Handle specific callbacks
-      
-      
-      if (data.type === 'onFormulusReady' && globalThis.formulusCallbacks?.onFormulusReady) {
+
+      if (
+        data.type === 'onFormulusReady' &&
+        globalThis.formulusCallbacks?.onFormulusReady
+      ) {
         handleCallback(globalThis.formulusCallbacks.onFormulusReady);
       }
     } catch (e) {
-      console.error('Global handleMessage: Error processing message:', e, 'Raw event.data:', event.data);
+      console.error(
+        'Global handleMessage: Error processing message:',
+        e,
+        'Raw event.data:',
+        event.data,
+      );
     }
   }
-  
+
   // Set up message listener
   document.addEventListener('message', handleMessage);
   window.addEventListener('message', handleMessage);
 
   // Initialize the formulus interface
   globalThis.formulus = {
-        // getVersion:  => Promise<string>
-        getVersion: function() {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+    // getVersion:  => Promise<string>
+    getVersion: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getVersion callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getVersion callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getVersion_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getVersion callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getVersion callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'getVersion_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'getVersion' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getVersion' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getVersion',
             messageId,
-            
-          }));
-          
-          });
-        },
-
-        // getAvailableForms:  => Promise<FormInfo[]>
-        getAvailableForms: function() {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+          }),
+        );
+      });
+    },
+
+    // getAvailableForms:  => Promise<FormInfo[]>
+    getAvailableForms: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getAvailableForms callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getAvailableForms callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getAvailableForms_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getAvailableForms callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getAvailableForms callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'getAvailableForms_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'getAvailableForms' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getAvailableForms' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getAvailableForms',
             messageId,
-            
-          }));
-          
-          });
-        },
-
-        // openFormplayer: formType: string, params: Record<string, unknown>, savedData: Record<string, unknown>, options: { subObservationMode?: boolean; skipFinalize?: boolean; skipDraftSelection?: boolean; observationId?: string; } => Promise<FormCompletionResult>
-        openFormplayer: function(formType, params, savedData, options) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+          }),
+        );
+      });
+    },
+
+    // openFormplayer: formType: string, params: Record<string, unknown>, savedData: Record<string, unknown>, options: { subObservationMode?: boolean; skipFinalize?: boolean; skipDraftSelection?: boolean; observationId?: string; } => Promise<FormCompletionResult>
+    openFormplayer: function (formType, params, savedData, options) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('openFormplayer callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'openFormplayer callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'openFormplayer_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('openFormplayer callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('openFormplayer callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'openFormplayer_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'openFormplayer' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'openFormplayer' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'openFormplayer',
             messageId,
-                        formType: formType,
+            formType: formType,
             params: params,
             savedData: savedData,
-            options: options
-          }));
-          
-          });
-        },
-
-        // getObservations: formType: string, isDraft: boolean, includeDeleted: boolean => Promise<FormObservation[]>
-        getObservations: function(formType, isDraft, includeDeleted) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            options: options,
+          }),
+        );
+      });
+    },
+
+    // getObservations: formType: string, isDraft: boolean, includeDeleted: boolean => Promise<FormObservation[]>
+    getObservations: function (formType, isDraft, includeDeleted) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getObservations callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getObservations callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getObservations_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getObservations callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getObservations callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'getObservations_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'getObservations' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getObservations' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getObservations',
             messageId,
-                        formType: formType,
+            formType: formType,
             isDraft: isDraft,
-            includeDeleted: includeDeleted
-          }));
-          
-          });
-        },
-
-        // getObservationsByQuery: options: { formType: string; isDraft?: boolean; includeDeleted?: boolean; filter?: ObservationFilter; whereClause?: string; } => Promise<FormObservation[]>
-        getObservationsByQuery: function(options) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            includeDeleted: includeDeleted,
+          }),
+        );
+      });
+    },
+
+    // getObservationsByQuery: options: { formType: string; isDraft?: boolean; includeDeleted?: boolean; filter?: ObservationFilter; whereClause?: string; } => Promise<FormObservation[]>
+    getObservationsByQuery: function (options) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getObservationsByQuery callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getObservationsByQuery callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getObservationsByQuery_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getObservationsByQuery callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getObservationsByQuery callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'getObservationsByQuery_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'getObservationsByQuery' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getObservationsByQuery' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getObservationsByQuery',
             messageId,
-                        options: options
-          }));
-          
-          });
-        },
-
-        // submitObservation: formType: string, finalData: Record<string, unknown> => Promise<string>
-        submitObservation: function(formType, finalData) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            options: options,
+          }),
+        );
+      });
+    },
+
+    // submitObservation: formType: string, finalData: Record<string, unknown> => Promise<string>
+    submitObservation: function (formType, finalData) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('submitObservation callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'submitObservation callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'submitObservation_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('submitObservation callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('submitObservation callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'submitObservation_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'submitObservation' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'submitObservation' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'submitObservation',
             messageId,
-                        formType: formType,
-            finalData: finalData
-          }));
-          
-          });
-        },
-
-        // updateObservation: observationId: string, formType: string, finalData: Record<string, unknown> => Promise<string>
-        updateObservation: function(observationId, formType, finalData) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            formType: formType,
+            finalData: finalData,
+          }),
+        );
+      });
+    },
+
+    // updateObservation: observationId: string, formType: string, finalData: Record<string, unknown> => Promise<string>
+    updateObservation: function (observationId, formType, finalData) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('updateObservation callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'updateObservation callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'updateObservation_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('updateObservation callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('updateObservation callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'updateObservation_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'updateObservation' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'updateObservation' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'updateObservation',
             messageId,
-                        observationId: observationId,
+            observationId: observationId,
             formType: formType,
-            finalData: finalData
-          }));
-          
-          });
-        },
-
-        // requestCamera: fieldId: string => Promise<CameraResult>
-        requestCamera: function(fieldId) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            finalData: finalData,
+          }),
+        );
+      });
+    },
+
+    // requestCamera: fieldId: string => Promise<CameraResult>
+    requestCamera: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('requestCamera callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'requestCamera callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'requestCamera_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('requestCamera callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('requestCamera callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'requestCamera_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'requestCamera' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'requestCamera' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'requestCamera',
             messageId,
-                        fieldId: fieldId
-          }));
-          
-          });
-        },
-
-        // requestLocation: fieldId: string => Promise<LocationResult>
-        requestLocation: function(fieldId) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
+    // requestLocation: fieldId: string => Promise<LocationResult>
+    requestLocation: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('requestLocation callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'requestLocation callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'requestLocation_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('requestLocation callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('requestLocation callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'requestLocation_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'requestLocation' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'requestLocation' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'requestLocation',
             messageId,
-                        fieldId: fieldId
-          }));
-          
-          });
-        },
-
-        // getCachedLocation: fieldId: string => Promise<LocationResult>
-        getCachedLocation: function(fieldId) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
+    // getCachedLocation: fieldId: string => Promise<LocationResult>
+    getCachedLocation: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getCachedLocation callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getCachedLocation callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getCachedLocation_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getCachedLocation callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getCachedLocation callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'getCachedLocation_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'getCachedLocation' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getCachedLocation' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getCachedLocation',
             messageId,
-                        fieldId: fieldId
-          }));
-          
-          });
-        },
-
-        // allocateSequence: scopeKey: string, options: { startAt?: number; peek?: boolean; } => Promise<number>
-        allocateSequence: function(scopeKey, options) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
+    // allocateSequence: scopeKey: string, options: { startAt?: number; peek?: boolean; } => Promise<number>
+    allocateSequence: function (scopeKey, options) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('allocateSequence callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'allocateSequence callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'allocateSequence_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('allocateSequence callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('allocateSequence callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'allocateSequence_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'allocateSequence' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'allocateSequence' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'allocateSequence',
             messageId,
-                        scopeKey: scopeKey,
-            options: options
-          }));
-          
-          });
-        },
-
-        // watchLocation: fieldId: string => Promise<{ status: "started" | "error"; message?: string; }>
-        watchLocation: function(fieldId) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            scopeKey: scopeKey,
+            options: options,
+          }),
+        );
+      });
+    },
+
+    // watchLocation: fieldId: string => Promise<{ status: "started" | "error"; message?: string; }>
+    watchLocation: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('watchLocation callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'watchLocation callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'watchLocation_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('watchLocation callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('watchLocation callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'watchLocation_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'watchLocation' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'watchLocation' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'watchLocation',
             messageId,
-                        fieldId: fieldId
-          }));
-          
-          });
-        },
-
-        // stopWatchLocation: fieldId: string => Promise<void>
-        stopWatchLocation: function(fieldId) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
+    // stopWatchLocation: fieldId: string => Promise<void>
+    stopWatchLocation: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('stopWatchLocation callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'stopWatchLocation callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'stopWatchLocation_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('stopWatchLocation callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('stopWatchLocation callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'stopWatchLocation_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'stopWatchLocation' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'stopWatchLocation' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'stopWatchLocation',
             messageId,
-                        fieldId: fieldId
-          }));
-          
-          });
-        },
-
-        // requestFile: fieldId: string => Promise<FileResult>
-        requestFile: function(fieldId) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
+    // requestFile: fieldId: string => Promise<FileResult>
+    requestFile: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('requestFile callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'requestFile callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'requestFile_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('requestFile callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('requestFile callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'requestFile_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'requestFile' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'requestFile' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'requestFile',
             messageId,
-                        fieldId: fieldId
-          }));
-          
-          });
-        },
-
-        // launchIntent: fieldId: string, intentSpec: Record<string, unknown> => Promise<void>
-        launchIntent: function(fieldId, intentSpec) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
+    // launchIntent: fieldId: string, intentSpec: Record<string, unknown> => Promise<void>
+    launchIntent: function (fieldId, intentSpec) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('launchIntent callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'launchIntent callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'launchIntent_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('launchIntent callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('launchIntent callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'launchIntent_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'launchIntent' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'launchIntent' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'launchIntent',
             messageId,
-                        fieldId: fieldId,
-            intentSpec: intentSpec
-          }));
-          
-          });
-        },
-
-        // callSubform: fieldId: string, formType: string, options: Record<string, unknown> => Promise<void>
-        callSubform: function(fieldId, formType, options) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            fieldId: fieldId,
+            intentSpec: intentSpec,
+          }),
+        );
+      });
+    },
+
+    // callSubform: fieldId: string, formType: string, options: Record<string, unknown> => Promise<void>
+    callSubform: function (fieldId, formType, options) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('callSubform callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'callSubform callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'callSubform_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('callSubform callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('callSubform callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'callSubform_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'callSubform' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'callSubform' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'callSubform',
             messageId,
-                        fieldId: fieldId,
+            fieldId: fieldId,
             formType: formType,
-            options: options
-          }));
-          
-          });
-        },
-
-        // requestAudio: fieldId: string => Promise<AudioResult>
-        requestAudio: function(fieldId) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            options: options,
+          }),
+        );
+      });
+    },
+
+    // requestAudio: fieldId: string => Promise<AudioResult>
+    requestAudio: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('requestAudio callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'requestAudio callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'requestAudio_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('requestAudio callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('requestAudio callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'requestAudio_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'requestAudio' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'requestAudio' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'requestAudio',
             messageId,
-                        fieldId: fieldId
-          }));
-          
-          });
-        },
-
-        // requestVideo: fieldId: string => Promise<VideoResult>
-        requestVideo: function(fieldId) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
+    // requestVideo: fieldId: string => Promise<VideoResult>
+    requestVideo: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('requestVideo callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'requestVideo callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'requestVideo_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('requestVideo callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('requestVideo callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'requestVideo_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'requestVideo' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'requestVideo' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'requestVideo',
             messageId,
-                        fieldId: fieldId
-          }));
-          
-          });
-        },
-
-        // requestQrcode: fieldId: string => Promise<QrcodeResult>
-        requestQrcode: function(fieldId) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
+    // requestQrcode: fieldId: string => Promise<QrcodeResult>
+    requestQrcode: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('requestQrcode callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'requestQrcode callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'requestQrcode_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('requestQrcode callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('requestQrcode callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'requestQrcode_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'requestQrcode' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'requestQrcode' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'requestQrcode',
             messageId,
-                        fieldId: fieldId
-          }));
-          
-          });
-        },
-
-        // requestBiometric: fieldId: string => Promise<void>
-        requestBiometric: function(fieldId) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
+    // requestBiometric: fieldId: string => Promise<void>
+    requestBiometric: function (fieldId) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('requestBiometric callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'requestBiometric callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'requestBiometric_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('requestBiometric callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('requestBiometric callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'requestBiometric_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'requestBiometric' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'requestBiometric' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'requestBiometric',
             messageId,
-                        fieldId: fieldId
-          }));
-          
-          });
-        },
-
-        // requestConnectivityStatus:  => Promise<void>
-        requestConnectivityStatus: function() {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            fieldId: fieldId,
+          }),
+        );
+      });
+    },
+
+    // requestConnectivityStatus:  => Promise<void>
+    requestConnectivityStatus: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('requestConnectivityStatus callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'requestConnectivityStatus callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'requestConnectivityStatus_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('requestConnectivityStatus callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('requestConnectivityStatus callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'requestConnectivityStatus_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'requestConnectivityStatus' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'requestConnectivityStatus' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'requestConnectivityStatus',
             messageId,
-            
-          }));
-          
-          });
-        },
-
-        // requestSyncStatus:  => Promise<void>
-        requestSyncStatus: function() {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+          }),
+        );
+      });
+    },
+
+    // requestSyncStatus:  => Promise<void>
+    requestSyncStatus: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('requestSyncStatus callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'requestSyncStatus callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'requestSyncStatus_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('requestSyncStatus callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('requestSyncStatus callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'requestSyncStatus_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'requestSyncStatus' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'requestSyncStatus' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'requestSyncStatus',
             messageId,
-            
-          }));
-          
-          });
-        },
-
-        // runLocalModel: fieldId: string, modelId: string, input: Record<string, unknown> => Promise<void>
-        runLocalModel: function(fieldId, modelId, input) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+          }),
+        );
+      });
+    },
+
+    // runLocalModel: fieldId: string, modelId: string, input: Record<string, unknown> => Promise<void>
+    runLocalModel: function (fieldId, modelId, input) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('runLocalModel callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'runLocalModel callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'runLocalModel_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('runLocalModel callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('runLocalModel callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'runLocalModel_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'runLocalModel' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'runLocalModel' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'runLocalModel',
             messageId,
-                        fieldId: fieldId,
+            fieldId: fieldId,
             modelId: modelId,
-            input: input
-          }));
-          
-          });
-        },
-
-        // getCurrentUser:  => Promise<{ username: string; displayName?: string; role?: "read-only" | "read-write" | "admin"; }>
-        getCurrentUser: function() {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            input: input,
+          }),
+        );
+      });
+    },
+
+    // getCurrentUser:  => Promise<{ username: string; displayName?: string; role?: "read-only" | "read-write" | "admin"; }>
+    getCurrentUser: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getCurrentUser callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getCurrentUser callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getCurrentUser_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getCurrentUser callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getCurrentUser callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'getCurrentUser_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'getCurrentUser' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getCurrentUser' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getCurrentUser',
             messageId,
-            
-          }));
-          
-          });
-        },
-
-        // getThemeMode:  => Promise<"light" | "dark" | "system">
-        getThemeMode: function() {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+          }),
+        );
+      });
+    },
+
+    // getThemeMode:  => Promise<"light" | "dark" | "system">
+    getThemeMode: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getThemeMode callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getThemeMode callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getThemeMode_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getThemeMode callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getThemeMode callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'getThemeMode_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'getThemeMode' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getThemeMode' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getThemeMode',
             messageId,
-            
-          }));
-          
-          });
-        },
-
-        // getAttachmentUri: fileName: string | AttachmentDisplayDescriptor => Promise<string>
-        getAttachmentUri: function(fileName) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+          }),
+        );
+      });
+    },
+
+    // getAttachmentUri: fileName: string | AttachmentDisplayDescriptor => Promise<string>
+    getAttachmentUri: function (fileName) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getAttachmentUri callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getAttachmentUri callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getAttachmentUri_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getAttachmentUri callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getAttachmentUri callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'getAttachmentUri_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'getAttachmentUri' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getAttachmentUri' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getAttachmentUri',
             messageId,
-                        fileName: fileName
-          }));
-          
-          });
-        },
-
-        // getAttachmentsUri:  => Promise<string>
-        getAttachmentsUri: function() {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            fileName: fileName,
+          }),
+        );
+      });
+    },
+
+    // getAttachmentsUri:  => Promise<string>
+    getAttachmentsUri: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getAttachmentsUri callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getAttachmentsUri callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getAttachmentsUri_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getAttachmentsUri callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getAttachmentsUri callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'getAttachmentsUri_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'getAttachmentsUri' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getAttachmentsUri' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getAttachmentsUri',
             messageId,
-            
-          }));
-          
-          });
-        },
-
-        // getCustomAppUri:  => Promise<string>
-        getCustomAppUri: function() {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+          }),
+        );
+      });
+    },
+
+    // getCustomAppUri:  => Promise<string>
+    getCustomAppUri: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getCustomAppUri callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getCustomAppUri callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getCustomAppUri_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getCustomAppUri callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getCustomAppUri callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'getCustomAppUri_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'getCustomAppUri' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getCustomAppUri' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getCustomAppUri',
             messageId,
-            
-          }));
-          
-          });
-        },
-
-        // getFormSpecsUri:  => Promise<string>
-        getFormSpecsUri: function() {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+          }),
+        );
+      });
+    },
+
+    // getFormSpecsUri:  => Promise<string>
+    getFormSpecsUri: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getFormSpecsUri callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getFormSpecsUri callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getFormSpecsUri_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getFormSpecsUri callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getFormSpecsUri callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'getFormSpecsUri_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'getFormSpecsUri' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getFormSpecsUri' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getFormSpecsUri',
             messageId,
-            
-          }));
-          
-          });
-        },
-
-        // persistObservation: input: PersistObservationInput => Promise<PersistObservationResult>
-        persistObservation: function(input) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+          }),
+        );
+      });
+    },
+
+    // persistObservation: input: PersistObservationInput => Promise<PersistObservationResult>
+    persistObservation: function (input) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('persistObservation callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'persistObservation callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'persistObservation_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('persistObservation callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('persistObservation callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'persistObservation_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'persistObservation' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'persistObservation' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'persistObservation',
             messageId,
-                        input: input
-          }));
-          
-          });
-        },
-
-        // sync: options: { includeAttachments?: boolean; } => Promise<SyncResult>
-        sync: function(options) {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            input: input,
+          }),
+        );
+      });
+    },
+
+    // sync: options: { includeAttachments?: boolean; } => Promise<SyncResult>
+    sync: function (options) {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('sync callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'sync callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (data.type === 'sync_response' && data.messageId === messageId) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('sync callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('sync callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'sync_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'sync' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'sync' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'sync',
             messageId,
-                        options: options
-          }));
-          
-          });
-        },
-
-        // getConnectivityStatus:  => Promise<ConnectivityStatus>
-        getConnectivityStatus: function() {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+            options: options,
+          }),
+        );
+      });
+    },
+
+    // getConnectivityStatus:  => Promise<ConnectivityStatus>
+    getConnectivityStatus: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getConnectivityStatus callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getConnectivityStatus callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getConnectivityStatus_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getConnectivityStatus callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getConnectivityStatus callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
+                resolve(data.result);
               }
-              if (data.type === 'getConnectivityStatus_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
-              }
-            } catch (e) {
-              console.error("'getConnectivityStatus' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getConnectivityStatus' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getConnectivityStatus',
             messageId,
-            
-          }));
-          
-          });
-        },
-
-        // getCurrentDataRevisionCount:  => Promise<number>
-        getCurrentDataRevisionCount: function() {
-          return new Promise((resolve, reject) => {
-          const messageId = 'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
-          
-          // Add response handler for methods that return values
-          
-          const callback = (event) => {
-            try {
-              let data;
-              if (typeof event.data === 'string') {
-                data = JSON.parse(event.data);
-              } else if (typeof event.data === 'object' && event.data !== null) {
-                data = event.data; // Already an object
+          }),
+        );
+      });
+    },
+
+    // getCurrentDataRevisionCount:  => Promise<number>
+    getCurrentDataRevisionCount: function () {
+      return new Promise((resolve, reject) => {
+        const messageId =
+          'msg_' + Date.now() + '_' + Math.floor(Math.random() * 1000);
+
+        // Add response handler for methods that return values
+
+        const callback = event => {
+          try {
+            let data;
+            if (typeof event.data === 'string') {
+              data = JSON.parse(event.data);
+            } else if (typeof event.data === 'object' && event.data !== null) {
+              data = event.data; // Already an object
+            } else {
+              // console.warn('getCurrentDataRevisionCount callback: Received response with unexpected data type:', typeof event.data, event.data);
+              window.removeEventListener('message', callback); // Clean up listener
+              reject(
+                new Error(
+                  'getCurrentDataRevisionCount callback: Received response with unexpected data type. Raw: ' +
+                    String(event.data),
+                ),
+              );
+              return;
+            }
+            if (
+              data.type === 'getCurrentDataRevisionCount_response' &&
+              data.messageId === messageId
+            ) {
+              window.removeEventListener('message', callback);
+              if (data.error) {
+                reject(new Error(data.error));
               } else {
-                // console.warn('getCurrentDataRevisionCount callback: Received response with unexpected data type:', typeof event.data, event.data);
-                window.removeEventListener('message', callback); // Clean up listener
-                reject(new Error('getCurrentDataRevisionCount callback: Received response with unexpected data type. Raw: ' + String(event.data)));
-                return;
-              }
-              if (data.type === 'getCurrentDataRevisionCount_response' && data.messageId === messageId) {
-                window.removeEventListener('message', callback);
-                if (data.error) {
-                  reject(new Error(data.error));
-                } else {
-                  resolve(data.result);
-                }
+                resolve(data.result);
               }
-            } catch (e) {
-              console.error("'getCurrentDataRevisionCount' callback: Error processing response:" , e, "Raw event.data:", event.data);
-              window.removeEventListener('message', callback); // Ensure listener is removed on error too
-              reject(e);
-            }
-          };
-          window.addEventListener('message', callback);
-          
-          
-          // Send the message to React Native
-          globalThis.ReactNativeWebView.postMessage(JSON.stringify({
+            }
+          } catch (e) {
+            console.error(
+              "'getCurrentDataRevisionCount' callback: Error processing response:",
+              e,
+              'Raw event.data:',
+              event.data,
+            );
+            window.removeEventListener('message', callback); // Ensure listener is removed on error too
+            reject(e);
+          }
+        };
+        window.addEventListener('message', callback);
+
+        // Send the message to React Native
+        globalThis.ReactNativeWebView.postMessage(
+          JSON.stringify({
             type: 'getCurrentDataRevisionCount',
             messageId,
-            
-          }));
-          
-          });
-        },
+          }),
+        );
+      });
+    },
   };
-  
+
   // Register the callback handler with the window object
   globalThis.formulusCallbacks = {};
-  
+
   // Notify that the interface is ready
   console.log('Formulus interface initialized');
-  (globalThis).__formulusBridgeInitialized = true;
+  globalThis.__formulusBridgeInitialized = true;
 
   // Simple API availability check for internal use
   function requestApiReinjection() {
     console.log('Formulus: Requesting re-injection from host...');
     if (globalThis.ReactNativeWebView) {
-      globalThis.ReactNativeWebView.postMessage(JSON.stringify({
-        type: 'requestApiReinjection',
-        timestamp: Date.now()
-      }));
+      globalThis.ReactNativeWebView.postMessage(
+        JSON.stringify({
+          type: 'requestApiReinjection',
+          timestamp: Date.now(),
+        }),
+      );
     }
   }
   globalThis.__formulusRequestApiReinjection = requestApiReinjection;
 
   // Notify React Native that the interface is ready
   if (globalThis.ReactNativeWebView) {
-    globalThis.ReactNativeWebView.postMessage(JSON.stringify({
-      type: 'onFormulusReady'
-    }));
+    globalThis.ReactNativeWebView.postMessage(
+      JSON.stringify({
+        type: 'onFormulusReady',
+      }),
+    );
   }
-  
+
   // Make the API available globally in browser environments
   if (typeof window !== 'undefined') {
     window.formulus = globalThis.formulus;
   }
-  
 })();
diff --git a/formulus/assets/webview/formulus-api.js b/formulus/assets/webview/formulus-api.js
index 2aee71918..f4d47b754 100644
--- a/formulus/assets/webview/formulus-api.js
+++ b/formulus/assets/webview/formulus-api.js
@@ -1,16 +1,16 @@
 /**
  * Formulus API Interface (JavaScript Version)
- * 
+ *
  * This file provides type information and documentation for the Formulus API
  * that's available in the WebView context as `globalThis.formulus`.
- * 
+ *
  * This file is auto-generated from FormulusInterfaceDefinition.ts
  * Last generated: 2026-06-19T16:58:11.756Z
- * 
+ *
  * @example
  * // In your JavaScript file:
  * /// <reference path="./formulus-api.js" />
- * 
+ *
  * // Now you'll get autocompletion and type hints in IDEs that support JSDoc
  * globalThis.formulus.getVersion().then(version => {
  *   console.log('Formulus version:', version);
@@ -29,268 +29,267 @@
  */
 const FormulusAPI = {
   /**
- * Get the current version of the Formulus bridge API (the interface contract
- * version, e.g. for {@link isCompatibleVersion} checks).
- * @returns {Promise<string>} The API version (semver)
- */
-  getVersion: function() {},
+   * Get the current version of the Formulus bridge API (the interface contract
+   * version, e.g. for {@link isCompatibleVersion} checks).
+   * @returns {Promise<string>} The API version (semver)
+   */
+  getVersion: function () {},
 
   /**
- * Get a list of available forms
- * @returns {Promise<FormInfo[]>} Array of form information objects
- */
-  getAvailableForms: function() {},
-
-  /**
- * Open Formplayer with the specified form
- * Reserved keys are not treated as observation data:
- * `defaultData` (prefill), `theme`/`darkMode`/`themeColors` (theming), and
- * `context` — a read-only **session context** object (device role, selected cluster,
- * ...) that Formplayer never persists and exposes to extensions as
- * `window.formulusSessionContext`. Draft bypass is not a param key — use
- * `options.skipDraftSelection` on {@link openFormplayer} (same as `skipFinalize`).
- * observation instead of creating a new one
- * @param {string} formType - The identifier of the formtype to open
- * @param {Object} params - Additional parameters for form initialization.
- * @param {Object} savedData - Previously saved form data (for editing)
- * @returns {Promise<FormCompletionResult>} Promise that resolves when the form is completed/closed with result details
- */
-  openFormplayer: function(formType, params, savedData, options) {},
+   * Get a list of available forms
+   * @returns {Promise<FormInfo[]>} Array of form information objects
+   */
+  getAvailableForms: function () {},
 
   /**
- * Get observations for a specific form
- * @param {string} formType - The identifier of the formtype
- * @returns {Promise<FormObservation[]>} Array of form observations
- */
-  getObservations: function(formType, isDraft, includeDeleted) {},
+   * Open Formplayer with the specified form
+   * Reserved keys are not treated as observation data:
+   * `defaultData` (prefill), `theme`/`darkMode`/`themeColors` (theming), and
+   * `context` — a read-only **session context** object (device role, selected cluster,
+   * ...) that Formplayer never persists and exposes to extensions as
+   * `window.formulusSessionContext`. Draft bypass is not a param key — use
+   * `options.skipDraftSelection` on {@link openFormplayer} (same as `skipFinalize`).
+   * observation instead of creating a new one
+   * @param {string} formType - The identifier of the formtype to open
+   * @param {Object} params - Additional parameters for form initialization.
+   * @param {Object} savedData - Previously saved form data (for editing)
+   * @returns {Promise<FormCompletionResult>} Promise that resolves when the form is completed/closed with result details
+   */
+  openFormplayer: function (formType, params, savedData, options) {},
 
   /**
- * Get observations with optional WHERE clause filtering (for dynamic choice lists).
- * Supports format: data.field = 'value' AND data.other = 'value'
- * Age filtering via age_from_dob(data.dob) is handled client-side in formplayer.
- * @returns {Promise<FormObservation[]>} Array of filtered observations
- */
-  getObservationsByQuery: function(options) {},
+   * Get observations for a specific form
+   * @param {string} formType - The identifier of the formtype
+   * @returns {Promise<FormObservation[]>} Array of form observations
+   */
+  getObservations: function (formType, isDraft, includeDeleted) {},
 
   /**
- * Submit a completed form
- * @param {string} formType - The identifier of the formtype
- * @param {Object} finalData - The final form data to submit
- * @returns {Promise<string>} The observationId of the submitted form
- */
-  submitObservation: function(formType, finalData) {},
+   * Get observations with optional WHERE clause filtering (for dynamic choice lists).
+   * Supports format: data.field = 'value' AND data.other = 'value'
+   * Age filtering via age_from_dob(data.dob) is handled client-side in formplayer.
+   * @returns {Promise<FormObservation[]>} Array of filtered observations
+   */
+  getObservationsByQuery: function (options) {},
 
   /**
- * Update an existing form
- * @param {string} observationId - The identifier of the observation
- * @param {string} formType - The identifier of the formtype
- * @param {Object} finalData - The final form data to update
- * @returns {Promise<string>} The observationId of the updated form
- */
-  updateObservation: function(observationId, formType, finalData) {},
+   * Submit a completed form
+   * @param {string} formType - The identifier of the formtype
+   * @param {Object} finalData - The final form data to submit
+   * @returns {Promise<string>} The observationId of the submitted form
+   */
+  submitObservation: function (formType, finalData) {},
 
   /**
- * Request camera access for a field
- * @param {string} fieldId - The ID of the field
- * @returns {Promise<CameraResult>} Promise that resolves with camera result or rejects on error/cancellation
- */
-  requestCamera: function(fieldId) {},
+   * Update an existing form
+   * @param {string} observationId - The identifier of the observation
+   * @param {string} formType - The identifier of the formtype
+   * @param {Object} finalData - The final form data to update
+   * @returns {Promise<string>} The observationId of the updated form
+   */
+  updateObservation: function (observationId, formType, finalData) {},
 
   /**
- * Request location for a field (captures into the form GPS field).
- * @param {string} fieldId - The ID of the field
- * @returns {Promise<LocationResult>} Promise that resolves with location result or rejects on error
- */
-  requestLocation: function(fieldId) {},
+   * Request camera access for a field
+   * @param {string} fieldId - The ID of the field
+   * @returns {Promise<CameraResult>} Promise that resolves with camera result or rejects on error/cancellation
+   */
+  requestCamera: function (fieldId) {},
 
   /**
- * Return the best cached device fix (if any) without forcing a new GPS read.
- */
-  getCachedLocation: function(fieldId) {},
+   * Request location for a field (captures into the form GPS field).
+   * @param {string} fieldId - The ID of the field
+   * @returns {Promise<LocationResult>} Promise that resolves with location result or rejects on error
+   */
+  requestLocation: function (fieldId) {},
 
   /**
- * Allocate the next monotonic integer in a device-local scope.
- * Formulus prepends `device:{deviceId}:` to the app-authored `scopeKey` suffix.
- */
-  allocateSequence: function(scopeKey, options) {},
+   * Return the best cached device fix (if any) without forcing a new GPS read.
+   */
+  getCachedLocation: function (fieldId) {},
 
   /**
- * Subscribe to location updates while the custom app WebView is active.
- * Updates arrive as `locationWatchUpdate` window messages.
- */
-  watchLocation: function(fieldId) {},
+   * Allocate the next monotonic integer in a device-local scope.
+   * Formulus prepends `device:{deviceId}:` to the app-authored `scopeKey` suffix.
+   */
+  allocateSequence: function (scopeKey, options) {},
 
   /**
- * Stop a prior `watchLocation` subscription for `fieldId`.
- */
-  stopWatchLocation: function(fieldId) {},
+   * Subscribe to location updates while the custom app WebView is active.
+   * Updates arrive as `locationWatchUpdate` window messages.
+   */
+  watchLocation: function (fieldId) {},
 
   /**
- * Request file selection for a field
- * @param {string} fieldId - The ID of the field
- * @returns {Promise<FileResult>} Promise that resolves with file result or rejects on error/cancellation
- */
-  requestFile: function(fieldId) {},
+   * Stop a prior `watchLocation` subscription for `fieldId`.
+   */
+  stopWatchLocation: function (fieldId) {},
 
   /**
- * Launch an external intent
- * @param {string} fieldId - The ID of the field
- * @param {Object} intentSpec - The intent specification
- * @returns {Promise<void>} 
- */
-  launchIntent: function(fieldId, intentSpec) {},
+   * Request file selection for a field
+   * @param {string} fieldId - The ID of the field
+   * @returns {Promise<FileResult>} Promise that resolves with file result or rejects on error/cancellation
+   */
+  requestFile: function (fieldId) {},
 
   /**
- * Call a subform
- * @param {string} fieldId - The ID of the field
- * @param {string} formType - The ID of the subform
- * @param {Object} options - Additional options for the subform
- * @returns {Promise<void>} 
- */
-  callSubform: function(fieldId, formType, options) {},
+   * Launch an external intent
+   * @param {string} fieldId - The ID of the field
+   * @param {Object} intentSpec - The intent specification
+   * @returns {Promise<void>}
+   */
+  launchIntent: function (fieldId, intentSpec) {},
 
   /**
- * Request audio recording for a field
- * @param {string} fieldId - The ID of the field
- * @returns {Promise<AudioResult>} Promise that resolves with audio result or rejects on error/cancellation
- */
-  requestAudio: function(fieldId) {},
+   * Call a subform
+   * @param {string} fieldId - The ID of the field
+   * @param {string} formType - The ID of the subform
+   * @param {Object} options - Additional options for the subform
+   * @returns {Promise<void>}
+   */
+  callSubform: function (fieldId, formType, options) {},
 
   /**
- * Request video recording for a field (camera / picker — host-defined).
- * @param {string} fieldId - The ID of the field
- * @returns {Promise<VideoResult>} Promise that resolves with video result or rejects on error/cancellation
- */
-  requestVideo: function(fieldId) {},
+   * Request audio recording for a field
+   * @param {string} fieldId - The ID of the field
+   * @returns {Promise<AudioResult>} Promise that resolves with audio result or rejects on error/cancellation
+   */
+  requestAudio: function (fieldId) {},
 
   /**
- * Request QR code scanning for a field
- * @param {string} fieldId - The ID of the field
- * @returns {Promise<QrcodeResult>} Promise that resolves with QR code result or rejects on error/cancellation
- */
-  requestQrcode: function(fieldId) {},
+   * Request video recording for a field (camera / picker — host-defined).
+   * @param {string} fieldId - The ID of the field
+   * @returns {Promise<VideoResult>} Promise that resolves with video result or rejects on error/cancellation
+   */
+  requestVideo: function (fieldId) {},
 
   /**
- * Request biometric authentication
- * @param {string} fieldId - The ID of the field
- * @returns {Promise<void>} 
- */
-  requestBiometric: function(fieldId) {},
+   * Request QR code scanning for a field
+   * @param {string} fieldId - The ID of the field
+   * @returns {Promise<QrcodeResult>} Promise that resolves with QR code result or rejects on error/cancellation
+   */
+  requestQrcode: function (fieldId) {},
 
   /**
- * Request the current connectivity status
- * @returns {Promise<void>} 
- */
-  requestConnectivityStatus: function() {},
+   * Request biometric authentication
+   * @param {string} fieldId - The ID of the field
+   * @returns {Promise<void>}
+   */
+  requestBiometric: function (fieldId) {},
 
   /**
- * Request the current sync status
- * @returns {Promise<void>} 
- */
-  requestSyncStatus: function() {},
+   * Request the current connectivity status
+   * @returns {Promise<void>}
+   */
+  requestConnectivityStatus: function () {},
 
   /**
- * Run a local ML model
- * @param {string} fieldId - The ID of the field
- * @param {string} modelId - The ID of the model to run
- * @param {Object} input - The input data for the model
- * @returns {Promise<void>} 
- */
-  runLocalModel: function(fieldId, modelId, input) {},
+   * Request the current sync status
+   * @returns {Promise<void>}
+   */
+  requestSyncStatus: function () {},
 
   /**
- * Get information about the currently authenticated user.
- * When no one is logged in, resolves with `{ username: '' }` (does not reject).
- * @returns {Promise<{username: string, displayName?: string, role?: 'read-only' | 'read-write' | 'admin'} 
- */
-  getCurrentUser: function() {},
+   * Run a local ML model
+   * @param {string} fieldId - The ID of the field
+   * @param {string} modelId - The ID of the model to run
+   * @param {Object} input - The input data for the model
+   * @returns {Promise<void>}
+   */
+  runLocalModel: function (fieldId, modelId, input) {},
 
   /**
- * Get the current theme mode (System / Light / Dark) so custom apps can match the host app.
- * @returns {Promise<'light' | 'dark' | 'system'>} Current theme mode; 'system' means follow device preference.
- */
-  getThemeMode: function() {},
-
-  /**
- * Resolve an attachment to a WebView-loadable URL (`file://`, `http(s):`, or host-specific).
- * **String `fileName`:** basename only (e.g. `photo.filename`). Lookup order, first hit wins:
- * 1. `attachments/draft/<name>`   — unsaved capture (formplayer preview)
- * 2. `attachments/synced/<name>`  — canonical committed / downloaded copy
- * 3. `attachments/pending/<name>` — queued for upload (fallback only)
- * Legacy locations (`attachments/<name>` and `attachments/pending_upload/<name>`) are also checked.
- * Path segments and ".." are rejected.
- * **`AttachmentDisplayDescriptor`:** `{ filename }` basename only (same lookup as a string argument).
- * @returns {Promise<string | null>} Display URL, or `null` if none
- */
-  getAttachmentUri: function(fileName) {},
-
-  /**
- * Base `file://` URL for the canonical attachments directory (trailing slash).
- * Returns the `synced/` subfolder — only committed/downloaded files are
- * iterable from here. Drafts and the upload queue are excluded by design so
- * custom apps can safely list this directory.
- * **Breaking change (v2 layout):** this used to return the `attachments/`
- * parent directory, which mixed committed files with `draft/` and
- * `pending_upload/` subfolders. Custom apps that iterate this URL will now
- * see only fully-committed attachments.
- * @returns {Promise<string>} e.g. `file:///.../attachments/synced/`
- */
-  getAttachmentsUri: function() {},
+   * Get information about the currently authenticated user.
+   * When no one is logged in, resolves with `{ username: '' }` (does not reject).
+   * @returns {Promise<{username: string, displayName?: string, role?: 'read-only' | 'read-write' | 'admin'}
+   */
+  getCurrentUser: function () {},
 
   /**
- * Base `file://` URL for the custom app bundle root (`DocumentDirectory/app/`, trailing slash).
- * @returns {Promise<string>} App directory URL for extensions, question_types, etc.
- */
-  getCustomAppUri: function() {},
-
+   * Get the current theme mode (System / Light / Dark) so custom apps can match the host app.
+   * @returns {Promise<'light' | 'dark' | 'system'>} Current theme mode; 'system' means follow device preference.
+   */
+  getThemeMode: function () {},
+
   /**
- * Primary `file://` URL for downloaded form specs (`DocumentDirectory/forms/`, trailing slash).
- * Some bundles also use files under the custom app `forms/` subdirectory.
- * @returns {Promise<string>} Forms directory URL
- */
-  getFormSpecsUri: function() {},
-
-  /**
- * Persist an observation **without opening Formplayer** (headless write).
- * Intended for custom apps that create or update records programmatically.
- * Uses the same persistence path as a Formplayer submit, including promotion
- * of any referenced draft attachments. Provide `observationId` to update an
- * existing row; omit it to create a new one.
- * @since 1.3.0
- * @param {PersistObservationInput} input - The observation to persist
- * @returns {Promise<PersistObservationResult>} The stored observation id and data
- */
-  persistObservation: function(input) {},
-
-  /**
- * Trigger a synchronization with Synkronus (pull + push).
- * Resolves when the sync completes; rejects if a sync is already in progress
- * or the sync fails. Attachments are excluded by default for speed.
- * @since 1.3.0
- * @returns {Promise<SyncResult>} The final data version after sync
- */
-  sync: function(options) {},
-
-  /**
- * Probe connectivity to the configured Synkronus server (`GET /health`).
- * Never rejects for an offline device — returns `{ online: false }` so callers
- * can branch on connectivity without try/catch. Suitable for the
- * "verify subject details when online, fall back when offline" pattern.
- * @since 1.3.0
- * @returns {Promise<ConnectivityStatus>} The current connectivity status
- */
-  getConnectivityStatus: function() {},
-
-  /**
- * Read the device's last-known Synkronus data revision (`current_version`
- * from the most recent successful sync). Reflects server-stream alignment
- * only — not unsynced local edits. Use with periodic polling or after
- * {@link sync} to detect when another device has pushed changes.
- * @since 1.4.0
- * @returns {Promise<number>} Non-negative revision count (0 if never synced)
- */
-  getCurrentDataRevisionCount: function() {},
-
+   * Resolve an attachment to a WebView-loadable URL (`file://`, `http(s):`, or host-specific).
+   * **String `fileName`:** basename only (e.g. `photo.filename`). Lookup order, first hit wins:
+   * 1. `attachments/draft/<name>`   — unsaved capture (formplayer preview)
+   * 2. `attachments/synced/<name>`  — canonical committed / downloaded copy
+   * 3. `attachments/pending/<name>` — queued for upload (fallback only)
+   * Legacy locations (`attachments/<name>` and `attachments/pending_upload/<name>`) are also checked.
+   * Path segments and ".." are rejected.
+   * **`AttachmentDisplayDescriptor`:** `{ filename }` basename only (same lookup as a string argument).
+   * @returns {Promise<string | null>} Display URL, or `null` if none
+   */
+  getAttachmentUri: function (fileName) {},
+
+  /**
+   * Base `file://` URL for the canonical attachments directory (trailing slash).
+   * Returns the `synced/` subfolder — only committed/downloaded files are
+   * iterable from here. Drafts and the upload queue are excluded by design so
+   * custom apps can safely list this directory.
+   * **Breaking change (v2 layout):** this used to return the `attachments/`
+   * parent directory, which mixed committed files with `draft/` and
+   * `pending_upload/` subfolders. Custom apps that iterate this URL will now
+   * see only fully-committed attachments.
+   * @returns {Promise<string>} e.g. `file:///.../attachments/synced/`
+   */
+  getAttachmentsUri: function () {},
+
+  /**
+   * Base `file://` URL for the custom app bundle root (`DocumentDirectory/app/`, trailing slash).
+   * @returns {Promise<string>} App directory URL for extensions, question_types, etc.
+   */
+  getCustomAppUri: function () {},
+
+  /**
+   * Primary `file://` URL for downloaded form specs (`DocumentDirectory/forms/`, trailing slash).
+   * Some bundles also use files under the custom app `forms/` subdirectory.
+   * @returns {Promise<string>} Forms directory URL
+   */
+  getFormSpecsUri: function () {},
+
+  /**
+   * Persist an observation **without opening Formplayer** (headless write).
+   * Intended for custom apps that create or update records programmatically.
+   * Uses the same persistence path as a Formplayer submit, including promotion
+   * of any referenced draft attachments. Provide `observationId` to update an
+   * existing row; omit it to create a new one.
+   * @since 1.3.0
+   * @param {PersistObservationInput} input - The observation to persist
+   * @returns {Promise<PersistObservationResult>} The stored observation id and data
+   */
+  persistObservation: function (input) {},
+
+  /**
+   * Trigger a synchronization with Synkronus (pull + push).
+   * Resolves when the sync completes; rejects if a sync is already in progress
+   * or the sync fails. Attachments are excluded by default for speed.
+   * @since 1.3.0
+   * @returns {Promise<SyncResult>} The final data version after sync
+   */
+  sync: function (options) {},
+
+  /**
+   * Probe connectivity to the configured Synkronus server (`GET /health`).
+   * Never rejects for an offline device — returns `{ online: false }` so callers
+   * can branch on connectivity without try/catch. Suitable for the
+   * "verify subject details when online, fall back when offline" pattern.
+   * @since 1.3.0
+   * @returns {Promise<ConnectivityStatus>} The current connectivity status
+   */
+  getConnectivityStatus: function () {},
+
+  /**
+   * Read the device's last-known Synkronus data revision (`current_version`
+   * from the most recent successful sync). Reflects server-stream alignment
+   * only — not unsynced local edits. Use with periodic polling or after
+   * {@link sync} to detect when another device has pushed changes.
+   * @since 1.4.0
+   * @returns {Promise<number>} Non-negative revision count (0 if never synced)
+   */
+  getCurrentDataRevisionCount: function () {},
 };
 
 // Make the API available globally in browser environments
diff --git a/formulus/assets/webview/placeholder_app.html b/formulus/assets/webview/placeholder_app.html
index 52454cc61..a96d89fac 100644
--- a/formulus/assets/webview/placeholder_app.html
+++ b/formulus/assets/webview/placeholder_app.html
@@ -5,8 +5,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <style>
       /* ODE_TOKENS_START */
-      /*
-       * ODE design tokens — generated from packages/tokens. Do not edit; run npm run generate:placeholder-tokens to update.
+/*
+       * ODE design tokens — generated from packages/tokens. Do not edit; run pnpm run generate:placeholder-tokens to update.
        */
       :root {
         /* color.brand.primary */
@@ -39,8 +39,7 @@
         --font-weight-regular: 400;
         --font-weight-bold: 700;
         /* font.family.sans */
-        --font-family-sans:
-          -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif;
+        --font-family-sans: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif;
         /* font.lineHeight */
         --line-height-tight: 1.25;
         --line-height-normal: 1.5;
diff --git a/formulus/eslint.config.js b/formulus/eslint.config.js
index fa44ecf3f..84125be03 100644
--- a/formulus/eslint.config.js
+++ b/formulus/eslint.config.js
@@ -11,6 +11,7 @@ export default tseslint.config(
   {
     ignores: [
       '**/node_modules/**',
+      'third_party/**',
       '**/android/**',
       '**/ios/**',
       '**/coverage/**',
@@ -65,4 +66,12 @@ export default tseslint.config(
       },
     },
   },
+  {
+    files: ['src/testUtils/**/*.{js,mjs}'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+    },
+  },
 );
diff --git a/formulus/jest.config.js b/formulus/jest.config.js
index 9c62bc1a2..a6d2e3408 100644
--- a/formulus/jest.config.js
+++ b/formulus/jest.config.js
@@ -3,6 +3,8 @@ export default {
   testMatch: ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).[jt]s?(x)'],
   moduleNameMapper: {
     '^@babel/runtime/(.*)$': '<rootDir>/node_modules/@babel/runtime/$1',
+    '^react-native-localize$':
+      '<rootDir>/src/testUtils/mocks/reactNativeLocalize.js',
   },
   // Vendored packages ship their own Jest suites; they are not part of this app.
   testPathIgnorePatterns: ['/node_modules/', '<rootDir>/third_party/'],
diff --git a/formulus/package.json b/formulus/package.json
index 8eb6fced0..b2349a1ea 100644
--- a/formulus/package.json
+++ b/formulus/package.json
@@ -41,8 +41,10 @@
     "@react-navigation/native": "^7.1.26",
     "@react-navigation/stack": "^7.6.13",
     "@testing-library/react-native": "^13.3.3",
+    "i18next": "^26.3.4",
     "lucide-react-native": "^0.577.0",
     "react": "19.2.4",
+    "react-i18next": "^17.0.8",
     "react-native": "0.83.1",
     "react-native-camera-kit-no-google": "^17.0.1",
     "react-native-device-info": "^15.0.1",
@@ -50,6 +52,7 @@
     "react-native-gesture-handler": "^2.30.0",
     "react-native-image-picker": "^8.2.1",
     "react-native-keychain": "^10.0.0",
+    "react-native-localize": "^3.7.0",
     "react-native-nitro-modules": "^0.35.4",
     "react-native-nitro-sound": "^0.2.10",
     "react-native-permissions": "^5.4.4",
diff --git a/formulus/pnpm-lock.yaml b/formulus/pnpm-lock.yaml
index 775c9ec9b..3dfdbf483 100644
--- a/formulus/pnpm-lock.yaml
+++ b/formulus/pnpm-lock.yaml
@@ -66,12 +66,18 @@ importers:
       '@testing-library/react-native':
         specifier: ^13.3.3
         version: 13.3.3(jest@30.4.2(@types/node@24.12.4))(react-native@0.83.1(@babel/core@7.29.7)(@react-native-community/cli@20.1.3(typescript@5.9.3))(@react-native/metro-config@0.83.1(@babel/core@7.29.7))(@types/react@19.2.14)(react@19.2.4))(react-test-renderer@19.2.4(react@19.2.4))(react@19.2.4)
+      i18next:
+        specifier: ^26.3.4
+        version: 26.3.4(typescript@5.9.3)
       lucide-react-native:
         specifier: ^0.577.0
         version: 0.577.0(react-native-svg@15.15.5(react-native@0.83.1(@babel/core@7.29.7)(@react-native-community/cli@20.1.3(typescript@5.9.3))(@react-native/metro-config@0.83.1(@babel/core@7.29.7))(@types/react@19.2.14)(react@19.2.4))(react@19.2.4))(react-native@0.83.1(@babel/core@7.29.7)(@react-native-community/cli@20.1.3(typescript@5.9.3))(@react-native/metro-config@0.83.1(@babel/core@7.29.7))(@types/react@19.2.14)(react@19.2.4))(react@19.2.4)
       react:
         specifier: 19.2.4
         version: 19.2.4
+      react-i18next:
+        specifier: ^17.0.8
+        version: 17.0.8(i18next@26.3.4(typescript@5.9.3))(react-native@0.83.1(@babel/core@7.29.7)(@react-native-community/cli@20.1.3(typescript@5.9.3))(@react-native/metro-config@0.83.1(@babel/core@7.29.7))(@types/react@19.2.14)(react@19.2.4))(react@19.2.4)(typescript@5.9.3)
       react-native:
         specifier: 0.83.1
         version: 0.83.1(@babel/core@7.29.7)(@react-native-community/cli@20.1.3(typescript@5.9.3))(@react-native/metro-config@0.83.1(@babel/core@7.29.7))(@types/react@19.2.14)(react@19.2.4)
@@ -93,6 +99,9 @@ importers:
       react-native-keychain:
         specifier: ^10.0.0
         version: 10.0.0
+      react-native-localize:
+        specifier: ^3.7.0
+        version: 3.7.0(react-native@0.83.1(@babel/core@7.29.7)(@react-native-community/cli@20.1.3(typescript@5.9.3))(@react-native/metro-config@0.83.1(@babel/core@7.29.7))(@types/react@19.2.14)(react@19.2.4))(react@19.2.4)
       react-native-nitro-modules:
         specifier: ^0.35.4
         version: 0.35.7(react-native@0.83.1(@babel/core@7.29.7)(@react-native-community/cli@20.1.3(typescript@5.9.3))(@react-native/metro-config@0.83.1(@babel/core@7.29.7))(@types/react@19.2.14)(react@19.2.4))(react@19.2.4)
@@ -3362,6 +3371,9 @@ packages:
   html-escaper@2.0.2:
     resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}
 
+  html-parse-stringify@3.0.1:
+    resolution: {integrity: sha512-KknJ50kTInJ7qIScF3jeaFRpMpE8/lfiTdzf/twXyPBLAGrLRTmkz3AdTnKeh40X8k9L2fdYwEp/42WGXIRGcg==}
+
   http-errors@2.0.1:
     resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==}
     engines: {node: '>= 0.8'}
@@ -3382,6 +3394,14 @@ packages:
     resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
     engines: {node: '>=10.17.0'}
 
+  i18next@26.3.4:
+    resolution: {integrity: sha512-pa7m0d7pBDqGHZxljT+WPFeyFgQ7P7SciPPo1tTqYuO0z4sqADYhwnBESmmGp/wEof1inwdls/k8ZgTg8rxFHA==}
+    peerDependencies:
+      typescript: ^5 || ^6
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+
   iconv-lite@0.7.2:
     resolution: {integrity: sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==}
     engines: {node: '>=0.10.0'}
@@ -4381,6 +4401,22 @@ packages:
     peerDependencies:
       react: '>=17.0.0'
 
+  react-i18next@17.0.8:
+    resolution: {integrity: sha512-0ooKbGLU8JXhe1zwpQUWIeXSgLPOfwJmgheWRIUpcoA0CpyabpGhayjdG+/eA5esC1AQ8h2jWpXjJfzQzeDOCw==}
+    peerDependencies:
+      i18next: '>= 26.2.0'
+      react: '>= 16.8.0'
+      react-dom: '*'
+      react-native: '*'
+      typescript: ^5 || ^6
+    peerDependenciesMeta:
+      react-dom:
+        optional: true
+      react-native:
+        optional: true
+      typescript:
+        optional: true
+
   react-is@16.13.1:
     resolution: {integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==}
 
@@ -4430,6 +4466,19 @@ packages:
     resolution: {integrity: sha512-YzPKSAnSzGEJ12IK6CctNLU79T1W15WDrElRQ+1/FsOazGX9ucFPTQwgYe8Dy8jiSEDJKM4wkVa3g4lD2Z+Pnw==}
     engines: {node: '>=16'}
 
+  react-native-localize@3.7.0:
+    resolution: {integrity: sha512-6Ohx+zZzycC6zhNVBGM/u1U+O6Ww29YIFseeyXqsKcO/pTfjLcdE40IUJF4SVVwrdh00IMJwy90HjLGUaeqK7Q==}
+    peerDependencies:
+      '@expo/config-plugins': '*'
+      react: '*'
+      react-native: '*'
+      react-native-macos: '*'
+    peerDependenciesMeta:
+      '@expo/config-plugins':
+        optional: true
+      react-native-macos:
+        optional: true
+
   react-native-nitro-modules@0.35.7:
     resolution: {integrity: sha512-3EiU27EmnxTlD3pAXR2OBWeDg7+9tdjKrNQOPX08rFX5hJPNIT/h1i2PjvTUieOypCGTEi9nW/SNBtK3F+4HYg==}
     peerDependencies:
@@ -5072,6 +5121,10 @@ packages:
   vlq@1.0.1:
     resolution: {integrity: sha512-gQpnTgkubC6hQgdIcRdYGDSDc+SaujOdyesZQMv6JlfQee/9Mp0Qhnys6WxDWvQnL5WZdT7o2Ul187aSt0Rq+w==}
 
+  void-elements@3.1.0:
+    resolution: {integrity: sha512-Dhxzh5HZuiHQhbvTW9AMetFfBHDMYpo23Uo9btPXgdYP+3T5S+p+jgNy7spra+veYhBP2dCSgxR/i2Y02h5/6w==}
+    engines: {node: '>=0.10.0'}
+
   walker@1.0.8:
     resolution: {integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==}
 
@@ -9120,6 +9173,10 @@ snapshots:
 
   html-escaper@2.0.2: {}
 
+  html-parse-stringify@3.0.1:
+    dependencies:
+      void-elements: 3.1.0
+
   http-errors@2.0.1:
     dependencies:
       depd: 2.0.0
@@ -9151,6 +9208,10 @@ snapshots:
 
   human-signals@2.1.0: {}
 
+  i18next@26.3.4(typescript@5.9.3):
+    optionalDependencies:
+      typescript: 5.9.3
+
   iconv-lite@0.7.2:
     dependencies:
       safer-buffer: 2.1.2
@@ -10419,6 +10480,17 @@ snapshots:
     dependencies:
       react: 19.2.4
 
+  react-i18next@17.0.8(i18next@26.3.4(typescript@5.9.3))(react-native@0.83.1(@babel/core@7.29.7)(@react-native-community/cli@20.1.3(typescript@5.9.3))(@react-native/metro-config@0.83.1(@babel/core@7.29.7))(@types/react@19.2.14)(react@19.2.4))(react@19.2.4)(typescript@5.9.3):
+    dependencies:
+      '@babel/runtime': 7.29.7
+      html-parse-stringify: 3.0.1
+      i18next: 26.3.4(typescript@5.9.3)
+      react: 19.2.4
+      use-sync-external-store: 1.6.0(react@19.2.4)
+    optionalDependencies:
+      react-native: 0.83.1(@babel/core@7.29.7)(@react-native-community/cli@20.1.3(typescript@5.9.3))(@react-native/metro-config@0.83.1(@babel/core@7.29.7))(@types/react@19.2.14)(react@19.2.4)
+      typescript: 5.9.3
+
   react-is@16.13.1: {}
 
   react-is@18.3.1: {}
@@ -10458,6 +10530,11 @@ snapshots:
 
   react-native-keychain@10.0.0: {}
 
+  react-native-localize@3.7.0(react-native@0.83.1(@babel/core@7.29.7)(@react-native-community/cli@20.1.3(typescript@5.9.3))(@react-native/metro-config@0.83.1(@babel/core@7.29.7))(@types/react@19.2.14)(react@19.2.4))(react@19.2.4):
+    dependencies:
+      react: 19.2.4
+      react-native: 0.83.1(@babel/core@7.29.7)(@react-native-community/cli@20.1.3(typescript@5.9.3))(@react-native/metro-config@0.83.1(@babel/core@7.29.7))(@types/react@19.2.14)(react@19.2.4)
+
   react-native-nitro-modules@0.35.7(react-native@0.83.1(@babel/core@7.29.7)(@react-native-community/cli@20.1.3(typescript@5.9.3))(@react-native/metro-config@0.83.1(@babel/core@7.29.7))(@types/react@19.2.14)(react@19.2.4))(react@19.2.4):
     dependencies:
       react: 19.2.4
@@ -11193,6 +11270,8 @@ snapshots:
 
   vlq@1.0.1: {}
 
+  void-elements@3.1.0: {}
+
   walker@1.0.8:
     dependencies:
       makeerror: 1.0.12
diff --git a/formulus/src/api/synkronus/index.ts b/formulus/src/api/synkronus/index.ts
index 6d5480c1b..618cc5733 100644
--- a/formulus/src/api/synkronus/index.ts
+++ b/formulus/src/api/synkronus/index.ts
@@ -37,6 +37,7 @@ import {
   type SyncProgress,
   type SyncProgressReporter,
 } from '../../sync/syncProgress';
+import { i18n } from '../../i18n/instance';
 
 const REPOSITORY_GENERATION_STORAGE_KEY = '@repository_generation';
 
@@ -434,7 +435,7 @@ class SynkronusApi {
         current: 0,
         total: 0,
         indeterminate: true,
-        details: 'Checking for attachments…',
+        details: i18n.t('sync.progress.checkingAttachments'),
       });
 
       console.debug(
@@ -486,7 +487,7 @@ class SynkronusApi {
           phase: 'pull_attachments',
           current: 1,
           total: 1,
-          details: 'Up to date',
+          details: i18n.t('sync.progress.upToDate'),
         });
         return;
       }
@@ -1102,7 +1103,7 @@ class SynkronusApi {
       current: 0,
       total: 0,
       indeterminate: true,
-      details: 'Connecting…',
+      details: i18n.t('sync.progress.connecting'),
     });
 
     do {
@@ -1177,10 +1178,12 @@ class SynkronusApi {
         indeterminate: true,
         details:
           totalServerRecordsThisPull > 0
-            ? `${totalServerRecordsThisPull.toLocaleString()} records downloaded`
+            ? i18n.t('sync.progress.recordsDownloaded', {
+                count: totalServerRecordsThisPull,
+              })
             : res.data.has_more
-              ? `Downloading (page ${pullPage})…`
-              : 'Downloading…',
+              ? i18n.t('sync.progress.downloadingPage', { page: pullPage })
+              : i18n.t('sync.progress.downloading'),
       });
 
       console.debug('Pulled observations: ', domainObservations);
@@ -1202,8 +1205,10 @@ class SynkronusApi {
       total: 1,
       details:
         totalServerRecordsThisPull > 0
-          ? `${totalServerRecordsThisPull.toLocaleString()} records`
-          : 'Up to date',
+          ? i18n.t('sync.progress.recordsSummary', {
+              count: totalServerRecordsThisPull,
+            })
+          : i18n.t('sync.progress.upToDate'),
     });
 
     logRepositoryGenerationSync('syncPull all pages done', {
@@ -1301,7 +1306,7 @@ class SynkronusApi {
           phase: 'push_observations',
           current: 1,
           total: 1,
-          details: 'Nothing to upload',
+          details: i18n.t('sync.progress.nothingToUpload'),
         });
         const skipGen = await this.getRepositoryGenerationForRequestOrNull();
         const lastSeen =
@@ -1355,7 +1360,9 @@ class SynkronusApi {
         current: 0,
         total: 1,
         indeterminate: true,
-        details: `Uploading ${localChanges.length} observation${localChanges.length === 1 ? '' : 's'}…`,
+        details: i18n.t('sync.progress.uploadingObservations', {
+          count: localChanges.length,
+        }),
       });
 
       console.debug(
@@ -1415,7 +1422,7 @@ class SynkronusApi {
         phase: 'push_observations',
         current: 1,
         total: 1,
-        details: 'Upload complete',
+        details: i18n.t('sync.progress.uploadComplete'),
       });
 
       return res.data.current_version;
diff --git a/formulus/src/components/FormplayerModal.tsx b/formulus/src/components/FormplayerModal.tsx
index b92689549..55583e7a3 100644
--- a/formulus/src/components/FormplayerModal.tsx
+++ b/formulus/src/components/FormplayerModal.tsx
@@ -39,13 +39,40 @@ import {
   odeBorderWidth,
   odeFormplayerHeaderHeight,
 } from '../theme/odeDesign';
-import { FormSpec } from '../services'; // FormService will be imported directly
+import { FormSpec, FormService } from '../services';
+import { collectLinkedFormIds } from '../utils/collectLinkedFormIds';
 import { ExtensionService } from '../services/ExtensionService';
 import RNFS from 'react-native-fs';
 import { useAppTheme } from '../contexts/AppThemeContext';
 import { useConfirmModal } from '../contexts/ConfirmModalContext';
 import { geolocationService } from '../services/GeolocationService';
 import { persistObservationWithAttachments } from '../services/attachmentStorage';
+import { localeSettingsService } from '../services/LocaleSettingsService';
+import { useTranslation } from 'react-i18next';
+
+async function buildLinkedFormSpecs(
+  schema: unknown,
+): Promise<FormInitData['linkedFormSpecs']> {
+  const linkedIds = collectLinkedFormIds(schema);
+  if (linkedIds.size === 0) return undefined;
+
+  try {
+    const formService = await FormService.getInstance();
+    const specs: NonNullable<FormInitData['linkedFormSpecs']> = {};
+    for (const id of linkedIds) {
+      const spec = formService.getFormSpecById(id);
+      if (!spec?.schema) continue;
+      specs[id] = {
+        schema: spec.schema,
+        uiSchema: spec.uiSchema ?? {},
+      };
+    }
+    return Object.keys(specs).length > 0 ? specs : undefined;
+  } catch (error) {
+    console.warn('[FormplayerModal] Failed to load linked form specs:', error);
+    return undefined;
+  }
+}
 
 interface FormplayerModalProps {
   visible: boolean;
@@ -76,6 +103,7 @@ const FormplayerModal = forwardRef<FormplayerModalHandle, FormplayerModalProps>(
     const webViewRef = useRef<CustomAppWebViewHandle>(null);
     const [isSubmitting, setIsSubmitting] = useState(false);
     const { showConfirm } = useConfirmModal();
+    const { t } = useTranslation();
 
     // Theme colors & resolved mode from AppThemeContext.
     const { themeColors, resolvedMode } = useAppTheme();
@@ -177,15 +205,14 @@ const FormplayerModal = forwardRef<FormplayerModalHandle, FormplayerModalProps>(
       }
 
       showConfirm({
-        title: 'Close form?',
-        message:
-          'This will close the current form. Any changes made will not be saved, but will be available as a draft next time you open the form.',
+        title: t('formplayer.closeTitle'),
+        message: t('formplayer.closeMessage'),
         buttons: [
-          { text: 'Cancel', variant: 'tertiary', onPress: () => {} },
-          { text: 'Close form', variant: 'danger', onPress: performClose },
+          { text: t('common.cancel'), variant: 'tertiary', onPress: () => {} },
+          { text: t('common.close'), variant: 'danger', onPress: performClose },
         ],
       });
-    }, [isClosing, isSubmitting, performClose, showConfirm]);
+    }, [isClosing, isSubmitting, performClose, showConfirm, t]);
 
     // Removed closeFormplayer event listener - now using direct promise-based submission handling
 
@@ -261,12 +288,17 @@ const FormplayerModal = forwardRef<FormplayerModalHandle, FormplayerModalProps>(
       // that form UI elements (buttons, inputs, headers) match the branding.
       const isDark = resolvedMode === 'dark';
 
+      const sessionLocale =
+        params && typeof params.locale === 'string' ? params.locale : null;
+      const resolvedLocale =
+        await localeSettingsService.resolveActiveLocale(sessionLocale);
+
       const formParams = {
-        locale: 'en',
         theme: 'default',
         darkMode: isDark,
         themeColors, // ← custom app palette forwarded to Formplayer
         ...params,
+        locale: resolvedLocale,
       };
 
       // Load extensions for this form
@@ -338,9 +370,11 @@ const FormplayerModal = forwardRef<FormplayerModalHandle, FormplayerModalProps>(
           formType.id,
         );
         showConfirm({
-          title: 'Form Error',
-          message: `Form "${formType.name}" has no schema. The form may not have loaded correctly from storage. Try syncing again.`,
-          buttons: [{ text: 'OK', variant: 'primary', onPress: () => {} }],
+          title: t('formplayer.formErrorTitle'),
+          message: t('formplayer.noSchemaMessage', { name: formType.name }),
+          buttons: [
+            { text: t('common.ok'), variant: 'primary', onPress: () => {} },
+          ],
         });
         return;
       }
@@ -468,6 +502,7 @@ const FormplayerModal = forwardRef<FormplayerModalHandle, FormplayerModalProps>(
         subObservationMode,
         skipFinalize,
         skipDraftSelection,
+        linkedFormSpecs: await buildLinkedFormSpecs(formType.schema),
       } as FormInitData;
 
       if (!webViewRef.current) {
@@ -482,10 +517,11 @@ const FormplayerModal = forwardRef<FormplayerModalHandle, FormplayerModalProps>(
       } catch (error) {
         console.error('FormplayerModal: Error sending form init data:', error);
         showConfirm({
-          title: 'Error',
-          message:
-            'Failed to initialize the form UI. Please close and try again.',
-          buttons: [{ text: 'OK', variant: 'primary', onPress: () => {} }],
+          title: t('common.error'),
+          message: t('formplayer.initFailed'),
+          buttons: [
+            { text: t('common.ok'), variant: 'primary', onPress: () => {} },
+          ],
         });
       }
     };
@@ -564,14 +600,14 @@ const FormplayerModal = forwardRef<FormplayerModalHandle, FormplayerModalProps>(
           }
 
           const successMessage = effectiveObservationId
-            ? 'Observation updated successfully!'
-            : 'Form submitted successfully!';
+            ? t('formplayer.submitSuccessUpdated')
+            : t('formplayer.submitSuccessSubmitted');
           showConfirm({
-            title: 'Success',
+            title: t('common.success'),
             message: successMessage,
             buttons: [
               {
-                text: 'OK',
+                text: t('common.ok'),
                 variant: 'primary',
                 onPress: () => {
                   setIsSubmitting(false);
@@ -601,14 +637,16 @@ const FormplayerModal = forwardRef<FormplayerModalHandle, FormplayerModalProps>(
           }
 
           showConfirm({
-            title: 'Error',
-            message: 'Failed to save your form. Please try again.',
-            buttons: [{ text: 'OK', variant: 'primary', onPress: () => {} }],
+            title: t('common.error'),
+            message: t('formplayer.saveFailed'),
+            buttons: [
+              { text: t('common.ok'), variant: 'primary', onPress: () => {} },
+            ],
           });
           throw error;
         }
       },
-      [currentObservationId, currentOperationId, onClose, showConfirm],
+      [currentObservationId, currentOperationId, onClose, showConfirm, t],
     );
 
     // Register/unregister modal with message handlers and reset form state.
@@ -726,7 +764,9 @@ const FormplayerModal = forwardRef<FormplayerModalHandle, FormplayerModalProps>(
                     size="large"
                     color={colors.semantic.info.ios}
                   />
-                  <Text style={styles.loadingText}>Saving form data...</Text>
+                  <Text style={styles.loadingText}>
+                    {t('formplayer.saving')}
+                  </Text>
                 </View>
               </View>
             )}
diff --git a/formulus/src/components/MenuDrawer.tsx b/formulus/src/components/MenuDrawer.tsx
index 11a04c129..f5567f031 100644
--- a/formulus/src/components/MenuDrawer.tsx
+++ b/formulus/src/components/MenuDrawer.tsx
@@ -18,6 +18,7 @@ import {
   odeRadius,
 } from '../theme/odeDesign';
 import { useAppTheme } from '../contexts/AppThemeContext';
+import { useTranslation } from 'react-i18next';
 import Button from './common/Button';
 import { loadSettingsHydrationFromStorage } from '../services/SettingsHydrationCache';
 
@@ -95,6 +96,7 @@ const MenuDrawer: React.FC<MenuDrawerProps> = ({
   onLogout,
   allowClose = true,
 }) => {
+  const { t } = useTranslation();
   const { themeColors, resolvedMode } = useAppTheme();
   const isDark = resolvedMode === 'dark';
   const textColor = isDark
@@ -119,12 +121,12 @@ const MenuDrawer: React.FC<MenuDrawerProps> = ({
   const menuItems: MenuItem[] = [
     {
       icon: 'information',
-      label: 'About',
+      label: t('common.about'),
       screen: 'About',
     },
     {
       icon: 'help-circle',
-      label: 'Help & Support',
+      label: t('common.help'),
       screen: 'Help',
     },
   ];
@@ -185,7 +187,9 @@ const MenuDrawer: React.FC<MenuDrawerProps> = ({
         ]}>
         <SafeAreaView style={styles.safeArea} edges={['top', 'left', 'right']}>
           <View style={styles.header}>
-            <Text style={[styles.headerTitle, { color: textColor }]}>Menu</Text>
+            <Text style={[styles.headerTitle, { color: textColor }]}>
+              {t('menu.title')}
+            </Text>
             {allowClose && (
               <TouchableOpacity onPress={onClose} style={styles.closeButton}>
                 <Icon name="close" size={24} color={themeColors.onSurface} />
@@ -221,10 +225,10 @@ const MenuDrawer: React.FC<MenuDrawerProps> = ({
                     ]}>
                     <Text style={styles.roleBadgeText}>
                       {userInfo.role === 'admin'
-                        ? 'Admin'
+                        ? t('roles.admin')
                         : userInfo.role === 'read-write'
-                          ? 'Read-write'
-                          : 'Read-only'}
+                          ? t('roles.readWrite')
+                          : t('roles.readOnly')}
                     </Text>
                   </View>
                 </View>
@@ -253,10 +257,10 @@ const MenuDrawer: React.FC<MenuDrawerProps> = ({
                 </View>
                 <View style={styles.userInfo}>
                   <Text style={[styles.userNameInactive, { color: textColor }]}>
-                    Not logged in
+                    {t('menu.notLoggedIn')}
                   </Text>
                   <Text style={[styles.loginHint, { color: textColor }]}>
-                    Click the Login at the bottom
+                    {t('menu.loginHint')}
                   </Text>
                 </View>
               </View>
@@ -275,7 +279,7 @@ const MenuDrawer: React.FC<MenuDrawerProps> = ({
               }}>
               <Icon name="cog" size={24} color={textColor} />
               <Text style={[styles.menuLabel, { color: textColor }]}>
-                Settings
+                {t('settings.title')}
               </Text>
             </TouchableOpacity>
             <MenuDivider color={menuModalBorderColor} />
@@ -299,7 +303,7 @@ const MenuDrawer: React.FC<MenuDrawerProps> = ({
           <View style={[styles.footer, { backgroundColor: sectionBg }]}>
             {userInfo ? (
               <Button
-                title="Logout"
+                title={t('common.logout')}
                 onPress={onLogout}
                 variant="danger"
                 size="medium"
@@ -307,7 +311,7 @@ const MenuDrawer: React.FC<MenuDrawerProps> = ({
               />
             ) : (
               <Button
-                title="Login"
+                title={t('common.login')}
                 onPress={() => {
                   onClose();
                   onNavigate('Settings');
diff --git a/formulus/src/components/SignatureCaptureModal.tsx b/formulus/src/components/SignatureCaptureModal.tsx
index e279408e1..949cadb2a 100644
--- a/formulus/src/components/SignatureCaptureModal.tsx
+++ b/formulus/src/components/SignatureCaptureModal.tsx
@@ -4,6 +4,7 @@ import { SafeAreaView } from 'react-native-safe-area-context';
 import Signature, { SignatureViewRef } from 'react-native-signature-canvas';
 import { colors } from '../theme/colors';
 import Button from './common/Button';
+import { useTranslation } from 'react-i18next';
 
 interface SignatureCaptureModalProps {
   visible: boolean;
@@ -18,6 +19,7 @@ const SignatureCaptureModal: React.FC<SignatureCaptureModalProps> = ({
   onSignatureCapture,
   fieldId,
 }) => {
+  const { t } = useTranslation();
   const [_isCapturing, setIsCapturing] = useState(false);
   const signatureRef = useRef<SignatureViewRef>(null);
   const { width, height } = Dimensions.get('window');
@@ -77,7 +79,7 @@ const SignatureCaptureModal: React.FC<SignatureCaptureModalProps> = ({
       onSignatureCapture(signatureResult);
       onClose();
     } else {
-      Alert.alert('Error', 'No signature data captured. Please try again.');
+      Alert.alert(t('common.error'), t('signature.noData'));
     }
   };
 
@@ -140,7 +142,7 @@ const SignatureCaptureModal: React.FC<SignatureCaptureModalProps> = ({
             onBegin={handleSignatureBegin}
             onOK={handleSignatureResult}
             onEmpty={() =>
-              Alert.alert('Error', 'Please provide a signature before saving.')
+              Alert.alert(t('common.error'), t('signature.required'))
             }
             descriptionText=""
             clearText="Clear"
diff --git a/formulus/src/components/common/LocalePicker.tsx b/formulus/src/components/common/LocalePicker.tsx
new file mode 100644
index 000000000..20dd6b1c9
--- /dev/null
+++ b/formulus/src/components/common/LocalePicker.tsx
@@ -0,0 +1,176 @@
+import React, { useState } from 'react';
+import {
+  Modal,
+  Text,
+  TouchableOpacity,
+  StyleSheet,
+  Pressable,
+} from 'react-native';
+import Icon from '@react-native-vector-icons/material-design-icons';
+import { useTranslation } from 'react-i18next';
+import {
+  UI_LOCALE_PREFERENCE_OPTIONS,
+  type UiLocalePreference,
+} from '../../lib/locale';
+import { useAppTheme } from '../../contexts/AppThemeContext';
+import colors from '../../theme/colors';
+import { odeSpacing, odeTypography, odeRadius } from '../../theme/odeDesign';
+interface LocalePickerProps {
+  value: UiLocalePreference;
+  onChange: (value: UiLocalePreference) => void;
+}
+
+const LocalePicker: React.FC<LocalePickerProps> = ({ value, onChange }) => {
+  const { t } = useTranslation();
+  const { themeColors } = useAppTheme();
+  const [open, setOpen] = useState(false);
+
+  const labels: Record<UiLocalePreference, string> = {
+    auto: t('settings.language.auto'),
+    en: t('settings.language.en'),
+    pt: t('settings.language.pt'),
+    fr: t('settings.language.fr'),
+  };
+
+  return (
+    <>
+      <TouchableOpacity
+        style={[
+          styles.trigger,
+          {
+            borderColor: themeColors.divider as string,
+            backgroundColor: themeColors.surface as string,
+          },
+        ]}
+        onPress={() => setOpen(true)}
+        accessibilityRole="button"
+        accessibilityLabel={t('settings.language.label')}>
+        <Text
+          style={[
+            styles.triggerText,
+            { color: themeColors.onSurface as string },
+          ]}
+          numberOfLines={1}>
+          {labels[value]}
+        </Text>
+        <Icon
+          name="chevron-down"
+          size={20}
+          color={themeColors.onSurface as string}
+        />
+      </TouchableOpacity>
+
+      <Modal
+        visible={open}
+        transparent
+        animationType="fade"
+        onRequestClose={() => setOpen(false)}>
+        <Pressable style={styles.backdrop} onPress={() => setOpen(false)}>
+          <Pressable
+            style={[
+              styles.sheet,
+              {
+                backgroundColor: themeColors.surface as string,
+                borderColor: themeColors.divider as string,
+              },
+            ]}
+            onPress={e => e.stopPropagation()}>
+            <Text
+              style={[
+                styles.sheetTitle,
+                { color: themeColors.onSurface as string },
+              ]}>
+              {t('settings.language.label')}
+            </Text>
+            {UI_LOCALE_PREFERENCE_OPTIONS.map(opt => {
+              const selected = value === opt.value;
+              return (
+                <TouchableOpacity
+                  key={opt.value}
+                  style={[
+                    styles.option,
+                    selected && {
+                      backgroundColor: themeColors.primaryLight as string,
+                    },
+                  ]}
+                  onPress={() => {
+                    onChange(opt.value);
+                    setOpen(false);
+                  }}>
+                  <Text
+                    style={[
+                      styles.optionText,
+                      {
+                        color: selected
+                          ? (themeColors.primary as string)
+                          : (themeColors.onSurface as string),
+                      },
+                    ]}>
+                    {labels[opt.value]}
+                  </Text>
+                  {selected ? (
+                    <Icon
+                      name="check"
+                      size={20}
+                      color={themeColors.primary as string}
+                    />
+                  ) : null}
+                </TouchableOpacity>
+              );
+            })}
+          </Pressable>
+        </Pressable>
+      </Modal>
+    </>
+  );
+};
+
+const styles = StyleSheet.create({
+  trigger: {
+    flex: 1,
+    minWidth: 140,
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    borderWidth: 1,
+    borderRadius: odeRadius.inner,
+    paddingHorizontal: odeSpacing.sm,
+    paddingVertical: odeSpacing.xs,
+    gap: odeSpacing.xs,
+  },
+  triggerText: {
+    flex: 1,
+    fontSize: odeTypography.bodySm,
+  },
+  backdrop: {
+    flex: 1,
+    backgroundColor: colors.ui.background,
+    justifyContent: 'center',
+    padding: odeSpacing.lg,
+  },
+  sheet: {
+    borderRadius: odeRadius.card,
+    borderWidth: 1,
+    paddingVertical: odeSpacing.sm,
+    overflow: 'hidden',
+  },
+  sheetTitle: {
+    fontSize: odeTypography.body,
+    fontWeight: '600',
+    paddingHorizontal: odeSpacing.md,
+    paddingVertical: odeSpacing.sm,
+  },
+  option: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    paddingHorizontal: odeSpacing.md,
+    paddingVertical: odeSpacing.sm,
+  },
+  optionText: {
+    fontSize: odeTypography.body,
+    flex: 1,
+  },
+});
+
+export default LocalePicker;
diff --git a/formulus/src/components/common/SyncStatusButtons.tsx b/formulus/src/components/common/SyncStatusButtons.tsx
index e692cfa56..f39d95493 100644
--- a/formulus/src/components/common/SyncStatusButtons.tsx
+++ b/formulus/src/components/common/SyncStatusButtons.tsx
@@ -1,5 +1,6 @@
 import React from 'react';
 import { View, StyleSheet, ViewStyle } from 'react-native';
+import { useTranslation } from 'react-i18next';
 import Button from './Button';
 
 export type SyncStatus = 'all' | 'synced' | 'pending';
@@ -15,10 +16,11 @@ const SyncStatusButtons: React.FC<SyncStatusButtonsProps> = ({
   onStatusChange,
   containerStyle,
 }) => {
+  const { t } = useTranslation();
   const buttons: { id: SyncStatus; label: string }[] = [
-    { id: 'all', label: 'All' },
-    { id: 'synced', label: 'Synced' },
-    { id: 'pending', label: 'Pending' },
+    { id: 'all', label: t('filters.all') },
+    { id: 'synced', label: t('filters.synced') },
+    { id: 'pending', label: t('filters.pending') },
   ];
 
   return (
diff --git a/formulus/src/components/common/index.ts b/formulus/src/components/common/index.ts
index e5704cc04..89e5612ed 100644
--- a/formulus/src/components/common/index.ts
+++ b/formulus/src/components/common/index.ts
@@ -12,5 +12,6 @@ export { default as SyncStatusButtons } from './SyncStatusButtons';
 export type { SortOption, FilterOption } from './FilterBar.types';
 export type { StatusTab } from './StatusTabs';
 export type { SyncStatus } from './SyncStatusButtons';
+export { default as LocalePicker } from './LocalePicker';
 export { default as PasswordInput } from './PasswordInput';
 export type { PasswordInputProps } from './PasswordInput';
diff --git a/formulus/src/i18n/bootstrap.ts b/formulus/src/i18n/bootstrap.ts
new file mode 100644
index 000000000..142e73004
--- /dev/null
+++ b/formulus/src/i18n/bootstrap.ts
@@ -0,0 +1,45 @@
+import { initReactI18next } from 'react-i18next';
+import en from '../locales/en.json';
+import pt from '../locales/pt.json';
+import fr from '../locales/fr.json';
+import { localeSettingsService } from '../services/LocaleSettingsService';
+import { i18n } from './instance';
+
+const resources = {
+  en: { translation: en },
+  pt: { translation: pt },
+  fr: { translation: fr },
+};
+
+let initPromise: Promise<typeof i18n> | null = null;
+
+export async function initFormulusI18n(): Promise<typeof i18n> {
+  if (initPromise) return initPromise;
+
+  initPromise = (async () => {
+    await localeSettingsService.load();
+    const locale = await localeSettingsService.resolveActiveLocale();
+
+    if (!i18n.isInitialized) {
+      await i18n.use(initReactI18next).init({
+        resources,
+        lng: locale,
+        fallbackLng: 'en',
+        interpolation: { escapeValue: false },
+        compatibilityJSON: 'v4',
+      });
+    } else {
+      await i18n.changeLanguage(locale);
+    }
+
+    return i18n;
+  })();
+
+  return initPromise;
+}
+
+/** Re-apply locale after Settings change. */
+export async function syncFormulusI18nLanguage(): Promise<void> {
+  const locale = await localeSettingsService.resolveActiveLocale();
+  await i18n.changeLanguage(locale);
+}
diff --git a/formulus/src/i18n/index.ts b/formulus/src/i18n/index.ts
new file mode 100644
index 000000000..b67e6675e
--- /dev/null
+++ b/formulus/src/i18n/index.ts
@@ -0,0 +1,2 @@
+export { i18n } from './instance';
+export { initFormulusI18n, syncFormulusI18nLanguage } from './bootstrap';
diff --git a/formulus/src/i18n/instance.ts b/formulus/src/i18n/instance.ts
new file mode 100644
index 000000000..21ecc5e57
--- /dev/null
+++ b/formulus/src/i18n/instance.ts
@@ -0,0 +1,4 @@
+import i18n from 'i18next';
+
+/** Shared i18next singleton (no native module dependencies). */
+export { i18n };
diff --git a/formulus/src/lib/locale.test.ts b/formulus/src/lib/locale.test.ts
new file mode 100644
index 000000000..b5714da02
--- /dev/null
+++ b/formulus/src/lib/locale.test.ts
@@ -0,0 +1,70 @@
+import {
+  localeLookupCandidates,
+  matchOdeCatalogLocale,
+  normalizeLocaleTag,
+  resolveActiveLocale,
+} from './locale';
+
+describe('locale', () => {
+  it('normalizes locale tags', () => {
+    expect(normalizeLocaleTag('pt_BR')).toBe('pt-br');
+    expect(normalizeLocaleTag('  EN  ')).toBe('en');
+  });
+
+  it('builds lookup candidates', () => {
+    expect(localeLookupCandidates('pt-BR')).toEqual(['pt-br', 'pt']);
+    expect(localeLookupCandidates('en')).toEqual(['en']);
+  });
+
+  it('matches ODE catalog locales', () => {
+    expect(matchOdeCatalogLocale('pt-BR')).toBe('pt');
+    expect(matchOdeCatalogLocale('de')).toBeNull();
+  });
+
+  it('resolveActiveLocale respects explicit preference', () => {
+    expect(
+      resolveActiveLocale({
+        preference: 'fr',
+        deviceLocale: 'en-US',
+      }),
+    ).toBe('fr');
+  });
+
+  it('resolveActiveLocale uses device when auto', () => {
+    expect(
+      resolveActiveLocale({
+        preference: 'auto',
+        deviceLocale: 'pt-PT',
+      }),
+    ).toBe('pt');
+  });
+
+  it('resolveActiveLocale falls back to bundle default', () => {
+    expect(
+      resolveActiveLocale({
+        preference: 'auto',
+        deviceLocale: 'de-DE',
+        bundleDefaultLocale: 'fr',
+      }),
+    ).toBe('fr');
+  });
+
+  it('resolveActiveLocale session override wins', () => {
+    expect(
+      resolveActiveLocale({
+        preference: 'en',
+        deviceLocale: 'en-US',
+        sessionOverride: 'pt',
+      }),
+    ).toBe('pt');
+  });
+
+  it('resolveActiveLocale defaults to en', () => {
+    expect(
+      resolveActiveLocale({
+        preference: 'auto',
+        deviceLocale: 'de-DE',
+      }),
+    ).toBe('en');
+  });
+});
diff --git a/formulus/src/lib/locale.ts b/formulus/src/lib/locale.ts
new file mode 100644
index 000000000..68ef33bc8
--- /dev/null
+++ b/formulus/src/lib/locale.ts
@@ -0,0 +1,94 @@
+/**
+ * UI locale resolution for Formulus and Formplayer bridge.
+ * ODE ships en, pt, fr catalogs; other tags fall back through normalization.
+ */
+
+export const ODE_UI_LOCALES = ['en', 'pt', 'fr'] as const;
+export type OdeUiLocale = (typeof ODE_UI_LOCALES)[number];
+
+/** User preference stored in Settings (auto = follow device). */
+export type UiLocalePreference = 'auto' | OdeUiLocale;
+
+export const UI_LOCALE_PREFERENCE_OPTIONS: {
+  value: UiLocalePreference;
+  labelKey: string;
+}[] = [
+  { value: 'auto', labelKey: 'settings.language.auto' },
+  { value: 'en', labelKey: 'settings.language.en' },
+  { value: 'pt', labelKey: 'settings.language.pt' },
+  { value: 'fr', labelKey: 'settings.language.fr' },
+];
+
+/** Normalize BCP-47 tag for catalog lookup (lowercase, hyphen). */
+export function normalizeLocaleTag(tag: string): string {
+  return tag.trim().replace(/_/g, '-').toLowerCase();
+}
+
+/** Candidate tags to try for a locale (e.g. pt-BR → pt-br, pt). */
+export function localeLookupCandidates(tag: string): string[] {
+  const normalized = normalizeLocaleTag(tag);
+  if (!normalized) return ['en'];
+  const parts = normalized.split('-');
+  const candidates: string[] = [normalized];
+  if (parts.length > 1) {
+    candidates.push(parts[0]!);
+  }
+  return candidates;
+}
+
+export function isOdeUiLocale(tag: string): tag is OdeUiLocale {
+  return (ODE_UI_LOCALES as readonly string[]).includes(tag);
+}
+
+/**
+ * Map a device or bundle tag to the nearest ODE catalog locale, or null if none match.
+ */
+export function matchOdeCatalogLocale(
+  tag: string,
+  supported: readonly string[] = ODE_UI_LOCALES,
+): OdeUiLocale | null {
+  for (const candidate of localeLookupCandidates(tag)) {
+    if ((supported as readonly string[]).includes(candidate)) {
+      return candidate as OdeUiLocale;
+    }
+  }
+  return null;
+}
+
+export interface ResolveActiveLocaleInput {
+  preference: UiLocalePreference;
+  deviceLocale: string;
+  bundleDefaultLocale?: string | null;
+  /** Optional per-session override from openFormplayer params. */
+  sessionOverride?: string | null;
+}
+
+/**
+ * Resolve the active UI locale for Formplayer and shell i18n.
+ * Precedence: session override → explicit preference → device (auto) → bundle default → en.
+ */
+export function resolveActiveLocale(
+  input: ResolveActiveLocaleInput,
+): OdeUiLocale {
+  const { preference, deviceLocale, bundleDefaultLocale, sessionOverride } =
+    input;
+
+  if (sessionOverride) {
+    const matched = matchOdeCatalogLocale(sessionOverride);
+    if (matched) return matched;
+  }
+
+  if (preference !== 'auto' && isOdeUiLocale(preference)) {
+    return preference;
+  }
+
+  const fromDevice = matchOdeCatalogLocale(deviceLocale);
+  if (fromDevice) return fromDevice;
+
+  if (bundleDefaultLocale) {
+    const fromBundle = matchOdeCatalogLocale(bundleDefaultLocale);
+    if (fromBundle) return fromBundle;
+  }
+
+  return 'en';
+}
diff --git a/formulus/src/locales/en.json b/formulus/src/locales/en.json
new file mode 100644
index 000000000..7dfc2b7c8
--- /dev/null
+++ b/formulus/src/locales/en.json
@@ -0,0 +1,204 @@
+{
+  "settings.language.auto": "Auto (device)",
+  "settings.language.en": "English",
+  "settings.language.pt": "Português",
+  "settings.language.fr": "Français",
+  "settings.language.label": "Language:",
+  "settings.theme.label": "Theme:",
+  "settings.title": "Settings",
+  "settings.appSettings": "App Settings",
+  "settings.subtitle": "Please enter the details for your synkronus server",
+  "settings.login": "Login",
+  "settings.loggingIn": "Logging in...",
+  "settings.serverUrl": "Server URL",
+  "settings.username": "Username",
+  "settings.password": "Password",
+  "settings.updated": "Settings updated successfully",
+  "settings.scanQr": "Scan QR code",
+  "menu.title": "Menu",
+  "menu.notLoggedIn": "Not logged in",
+  "menu.loginHint": "Tap Login at the bottom",
+  "roles.admin": "Admin",
+  "roles.readWrite": "Read-write",
+  "roles.readOnly": "Read-only",
+  "tabs.sync": "Sync",
+  "tabs.forms": "Forms",
+  "tabs.settings": "Settings",
+  "tabs.home": "Home",
+  "tabs.observations": "Observations",
+  "tabs.more": "More",
+  "sync.title": "Sync",
+  "sync.syncing": "Syncing…",
+  "sync.syncingAndUpdating": "Syncing & updating…",
+  "sync.completed": "Sync completed",
+  "sync.failed": "Sync failed",
+  "sync.status": "Status",
+  "sync.lastSync": "Last Sync",
+  "sync.never": "Never",
+  "sync.error": "Error",
+  "sync.pendingSync": "Pending sync",
+  "sync.noPendingChanges": "No pending local changes",
+  "sync.tapToSync": "Tap to sync now",
+  "sync.observationsSection": "Observations and attachments",
+  "sync.pendingItems": "Pending items",
+  "sync.readOnlyHint": "Read-only accounts cannot upload changes. Sync still downloads updates from the server.",
+  "sync.observations": "Observations",
+  "sync.attachments": "Attachments",
+  "sync.record_one": "{{count}} record",
+  "sync.record_other": "{{count}} records",
+  "sync.file_one": "{{count}} file ({{size}} MB)",
+  "sync.file_other": "{{count}} files ({{size}} MB)",
+  "sync.dismiss": "Dismiss",
+  "sync.syncObservationsPullPush": "Sync observations (pull+push)",
+  "sync.syncObservationsPull": "Sync observations (pull)",
+  "sync.updating": "Updating...",
+  "sync.update": "Update",
+  "sync.appBundle": "App bundle",
+  "sync.appBundleSubtitle": "Form definitions and custom app assets",
+  "sync.version": "Version",
+  "sync.local": "Local",
+  "sync.server": "Server",
+  "sync.updateAvailable": "Update available",
+  "sync.upToDate": "Up-to-date",
+  "sync.couldNotVerifyVersions": "Could not verify versions",
+  "sync.bundleVersionUnavailable": "Could not load bundle version information.",
+  "sync.serverBundleUnknown": "Could not load server bundle version.",
+  "sync.localBundleUnknown": "Could not read local bundle version.",
+  "filters.all": "All",
+  "filters.synced": "Synced",
+  "filters.pending": "Pending",
+  "forms.title": "Forms",
+  "forms.available_one": "{{count}} form available",
+  "forms.available_other": "{{count}} forms available",
+  "forms.loading": "Loading forms...",
+  "forms.searchPlaceholder": "Search forms...",
+  "forms.errorTitle": "Error Loading Forms",
+  "forms.retry": "Retry",
+  "forms.openError": "Failed to open form. Please try again.",
+  "forms.emptyTitle": "No Forms Available",
+  "forms.emptyMessage": "No forms have been downloaded yet. Go to the Sync screen to download forms from the server.",
+  "forms.emptySearchTitle": "No Forms Found",
+  "forms.emptySearchMessage": "Try adjusting your search.",
+  "observations.title": "Observations",
+  "observations.count_one": "{{count}} observation",
+  "observations.count_other": "{{count}} observations",
+  "observations.loading": "Loading observations...",
+  "observations.searchPlaceholder": "Search observations...",
+  "observations.allForms": "All Forms",
+  "observations.errorTitle": "Error Loading Observations",
+  "observations.emptyFound": "No Observations Found",
+  "observations.emptyYet": "No Observations Yet",
+  "observations.emptyFoundMessage": "Try adjusting your search or filter criteria.",
+  "observations.emptyYetMessage": "Start filling out forms to create observations. Your data will appear here once saved.",
+  "observations.deleteTitle": "Delete Observation",
+  "observations.deleteMessage": "Are you sure you want to delete this observation? This action cannot be undone.",
+  "observations.delete": "Delete",
+  "observations.editError": "Failed to edit observation. Please try again.",
+  "observations.deleteError": "Failed to delete observation.",
+  "formplayer.closeTitle": "Close form?",
+  "formplayer.closeMessage": "Unsaved changes may be lost.",
+  "formplayer.saving": "Saving form data...",
+  "common.cancel": "Cancel",
+  "common.close": "Close",
+  "common.ok": "OK",
+  "common.about": "About",
+  "common.help": "Help & Support",
+  "common.logout": "Logout",
+  "common.login": "Login",
+  "common.error": "Error",
+  "common.retry": "Retry",
+  "common.success": "Success",
+  "common.delete": "Delete",
+  "common.exit": "Exit",
+  "common.info": "Info",
+  "auth.logoutTitle": "Logout",
+  "auth.logoutMessage": "Are you sure you want to logout?",
+  "home.exitTitle": "Exit app?",
+  "home.exitMessage": "Are you sure you want to exit Formulus?",
+  "sync.operationFailed": "Operation failed",
+  "sync.updateFailed": "Update failed",
+  "sync.authErrorTitle": "Authentication error",
+  "sync.sessionExpired": "Your session has expired. Please log in again.",
+  "sync.loginToUpdateBundle": "Please log in to update the app bundle.",
+  "sync.unsynchronizedDataTitle": "Unsynchronized data",
+  "sync.unsynchronizedDataMessage_one": "You have {{count}} unsynchronized item. Sync your data before updating to avoid data loss.",
+  "sync.unsynchronizedDataMessage_other": "You have {{count}} unsynchronized items. Sync your data before updating to avoid data loss.",
+  "sync.syncAndUpdate": "Sync & update",
+  "sync.repositoryResetTitle": "Server data was reset",
+  "sync.repositoryResetMessage": "The server replaced its observation dataset (a new data generation). To sync again, this device must delete all local observations and all attachment files, including items that have not been uploaded yet.\n\nThis cannot be undone. Erase everything on this device and sync again?",
+  "sync.eraseAndSync": "Erase and sync",
+  "sync.progress.phase.pull_observations": "Syncing observations",
+  "sync.progress.phase.pull_attachments": "Downloading attachments",
+  "sync.progress.phase.push_attachments": "Uploading attachments",
+  "sync.progress.phase.push_observations": "Uploading changes",
+  "sync.progress.phase.app_bundle": "Updating forms",
+  "sync.progress.phase.default": "Syncing",
+  "sync.progress.syncingAndUpdatingForms": "Syncing & updating forms",
+  "sync.progress.syncingAndUpdating": "Syncing & updating",
+  "sync.progress.starting": "Starting…",
+  "sync.progress.complete": "Complete",
+  "sync.progress.preparingDownload": "Preparing download…",
+  "sync.progress.connecting": "Connecting…",
+  "sync.progress.checkingAttachments": "Checking for attachments…",
+  "sync.progress.upToDate": "Up to date",
+  "sync.progress.downloading": "Downloading…",
+  "sync.progress.downloadingPage": "Downloading (page {{page}})…",
+  "sync.progress.recordsDownloaded_one": "{{count}} observation downloaded",
+  "sync.progress.recordsDownloaded_other": "{{count}} observations downloaded",
+  "sync.progress.recordsSummary_one": "{{count}} observation",
+  "sync.progress.recordsSummary_other": "{{count}} observations",
+  "sync.progress.nothingToUpload": "Nothing to upload",
+  "sync.progress.uploadingObservations_one": "Uploading {{count}} observation…",
+  "sync.progress.uploadingObservations_other": "Uploading {{count}} observations…",
+  "sync.progress.uploadComplete": "Upload complete",
+  "sync.progress.countOf": "{{current}} of {{total}}",
+  "sync.progress.inProgress": "In progress…",
+  "settings.switchServerTitle": "Switch server?",
+  "settings.switchServerWipeMessage": "Switching servers will wipe all local data for the previous server.",
+  "settings.switchServerPendingMessage": "Unsynced observations: {{observations}}\nUnsynced attachments: {{attachments}}\n\nSync is recommended before switching.",
+  "settings.proceedWithoutSync": "Proceed without syncing",
+  "settings.syncThenSwitch": "Sync then switch",
+  "settings.yesWipeAndSwitch": "Yes, wipe & switch",
+  "settings.switchedServerCleared": "Switched server and cleared local data.",
+  "settings.syncBeforeSwitchFailed": "{{error}}\n\nPlease retry or proceed without syncing.",
+  "settings.switchServerFailed": "Failed to switch server. Please try again.",
+  "settings.syncInProgress": "Sync already in progress…",
+  "settings.checkPendingFailed": "Unable to check pending data. Try again.",
+  "settings.httpTransportWarning": "HTTP is allowed, but we recommend HTTPS so traffic is encrypted (https://).",
+  "settings.loginSuccess": "Successfully logged in!",
+  "settings.loginFailedCredentials": "Please check your credentials.",
+  "settings.loginFailed": "Login failed: {{message}}",
+  "settings.qrInvalid": "Invalid QR code format. Please try again.",
+  "settings.qrError": "QR code error: {{message}}",
+  "settings.qrScanFailed": "Failed to scan QR code. Please try again.",
+  "formplayer.formErrorTitle": "Form error",
+  "formplayer.noSchemaMessage": "Form \"{{name}}\" has no schema. The form may not have loaded correctly from storage. Try syncing again.",
+  "formplayer.initFailed": "Failed to initialize the form UI. Please close and try again.",
+  "formplayer.submitSuccessUpdated": "Observation updated successfully!",
+  "formplayer.submitSuccessSubmitted": "Form submitted successfully!",
+  "formplayer.saveFailed": "Failed to save your form. Please try again.",
+  "observations.notFound": "Observation not found",
+  "observations.loadFailed": "Failed to load observation",
+  "observations.updateSuccess": "Observation updated successfully",
+  "observations.deleteSuccess": "Observation deleted successfully",
+  "help.exportFailed": "Export failed",
+  "help.exportAttachmentsFailed": "Could not export attachments.",
+  "help.exportObservationsFailed": "Could not export observations.",
+  "signature.noData": "No signature data captured. Please try again.",
+  "signature.required": "Please provide a signature before saving.",
+  "media.selectImageTitle": "Select image",
+  "media.selectImageMessage": "Choose an option",
+  "media.camera": "Camera",
+  "media.gallery": "Gallery",
+  "admin.formServiceNotInitialized": "Form service is not initialized",
+  "admin.loadFormDataFailed": "Failed to load form data",
+  "admin.openFormNewFailed": "Failed to open form for new observation",
+  "admin.openFormEditFailed": "Failed to open form for editing observation",
+  "admin.confirmDeleteTitle": "Confirm delete",
+  "admin.confirmDeleteMessage": "Are you sure you want to delete this observation?",
+  "admin.resetDatabaseTitle": "Reset database",
+  "admin.resetDatabaseMessage": "Are you sure you want to delete ALL observations? This action cannot be undone.",
+  "admin.resetDatabaseButton": "Reset database",
+  "admin.resetDatabaseSuccess": "Database has been reset successfully.",
+  "admin.resetDatabaseFailed": "Failed to reset database"
+}
diff --git a/formulus/src/locales/fr.json b/formulus/src/locales/fr.json
new file mode 100644
index 000000000..5fc840bc3
--- /dev/null
+++ b/formulus/src/locales/fr.json
@@ -0,0 +1,204 @@
+{
+  "settings.language.auto": "Auto (appareil)",
+  "settings.language.en": "English",
+  "settings.language.pt": "Português",
+  "settings.language.fr": "Français",
+  "settings.language.label": "Langue :",
+  "settings.theme.label": "Thème :",
+  "settings.title": "Paramètres",
+  "settings.appSettings": "Paramètres de l'application",
+  "settings.subtitle": "Saisissez les informations de votre serveur Synkronus",
+  "settings.login": "Connexion",
+  "settings.loggingIn": "Connexion...",
+  "settings.serverUrl": "URL du serveur",
+  "settings.username": "Nom d'utilisateur",
+  "settings.password": "Mot de passe",
+  "settings.updated": "Paramètres mis à jour avec succès",
+  "settings.scanQr": "Scanner le code QR",
+  "menu.title": "Menu",
+  "menu.notLoggedIn": "Non connecté",
+  "menu.loginHint": "Appuyez sur Connexion en bas",
+  "roles.admin": "Administrateur",
+  "roles.readWrite": "Lecture-écriture",
+  "roles.readOnly": "Lecture seule",
+  "tabs.sync": "Synchroniser",
+  "tabs.forms": "Formulaires",
+  "tabs.settings": "Paramètres",
+  "tabs.home": "Accueil",
+  "tabs.observations": "Observations",
+  "tabs.more": "Plus",
+  "sync.title": "Synchroniser",
+  "sync.syncing": "Synchronisation…",
+  "sync.syncingAndUpdating": "Synchronisation et mise à jour…",
+  "sync.completed": "Synchronisation terminée",
+  "sync.failed": "Échec de la synchronisation",
+  "sync.status": "État",
+  "sync.lastSync": "Dernière synchronisation",
+  "sync.never": "Jamais",
+  "sync.error": "Erreur",
+  "sync.pendingSync": "Synchronisation en attente",
+  "sync.noPendingChanges": "Aucune modification locale en attente",
+  "sync.tapToSync": "Appuyez pour synchroniser",
+  "sync.observationsSection": "Observations et pièces jointes",
+  "sync.pendingItems": "Éléments en attente",
+  "sync.readOnlyHint": "Les comptes en lecture seule ne peuvent pas envoyer de modifications. La synchronisation télécharge toujours les mises à jour du serveur.",
+  "sync.observations": "Observations",
+  "sync.attachments": "Pièces jointes",
+  "sync.record_one": "{{count}} enregistrement",
+  "sync.record_other": "{{count}} enregistrements",
+  "sync.file_one": "{{count}} fichier ({{size}} Mo)",
+  "sync.file_other": "{{count}} fichiers ({{size}} Mo)",
+  "sync.dismiss": "Fermer",
+  "sync.syncObservationsPullPush": "Synchroniser les observations (envoi+récupération)",
+  "sync.syncObservationsPull": "Synchroniser les observations (récupération)",
+  "sync.updating": "Mise à jour...",
+  "sync.update": "Mettre à jour",
+  "sync.appBundle": "Paquet d'application",
+  "sync.appBundleSubtitle": "Définitions de formulaires et ressources de l'application personnalisée",
+  "sync.version": "Version",
+  "sync.local": "Local",
+  "sync.server": "Serveur",
+  "sync.updateAvailable": "Mise à jour disponible",
+  "sync.upToDate": "À jour",
+  "sync.couldNotVerifyVersions": "Impossible de vérifier les versions",
+  "sync.bundleVersionUnavailable": "Impossible de charger les informations de version du paquet.",
+  "sync.serverBundleUnknown": "Impossible de charger la version du paquet sur le serveur.",
+  "sync.localBundleUnknown": "Impossible de lire la version locale du paquet.",
+  "filters.all": "Tous",
+  "filters.synced": "Synchronisé",
+  "filters.pending": "En attente",
+  "forms.title": "Formulaires",
+  "forms.available_one": "{{count}} formulaire disponible",
+  "forms.available_other": "{{count}} formulaires disponibles",
+  "forms.loading": "Chargement des formulaires...",
+  "forms.searchPlaceholder": "Rechercher des formulaires...",
+  "forms.errorTitle": "Erreur de chargement des formulaires",
+  "forms.retry": "Réessayer",
+  "forms.openError": "Impossible d'ouvrir le formulaire. Veuillez réessayer.",
+  "forms.emptyTitle": "Aucun formulaire disponible",
+  "forms.emptyMessage": "Aucun formulaire n'a encore été téléchargé. Allez à l'écran Synchroniser pour télécharger les formulaires depuis le serveur.",
+  "forms.emptySearchTitle": "Aucun formulaire trouvé",
+  "forms.emptySearchMessage": "Essayez d'ajuster votre recherche.",
+  "observations.title": "Observations",
+  "observations.count_one": "{{count}} observation",
+  "observations.count_other": "{{count}} observations",
+  "observations.loading": "Chargement des observations...",
+  "observations.searchPlaceholder": "Rechercher des observations...",
+  "observations.allForms": "Tous les formulaires",
+  "observations.errorTitle": "Erreur de chargement des observations",
+  "observations.emptyFound": "Aucune observation trouvée",
+  "observations.emptyYet": "Pas encore d'observations",
+  "observations.emptyFoundMessage": "Essayez d'ajuster votre recherche ou vos filtres.",
+  "observations.emptyYetMessage": "Commencez à remplir des formulaires pour créer des observations. Vos données apparaîtront ici une fois enregistrées.",
+  "observations.deleteTitle": "Supprimer l'observation",
+  "observations.deleteMessage": "Voulez-vous vraiment supprimer cette observation ? Cette action est irréversible.",
+  "observations.delete": "Supprimer",
+  "observations.editError": "Impossible de modifier l'observation. Veuillez réessayer.",
+  "observations.deleteError": "Impossible de supprimer l'observation.",
+  "formplayer.closeTitle": "Fermer le formulaire ?",
+  "formplayer.closeMessage": "Les modifications non enregistrées peuvent être perdues.",
+  "formplayer.saving": "Enregistrement des données du formulaire...",
+  "common.cancel": "Annuler",
+  "common.close": "Fermer",
+  "common.ok": "OK",
+  "common.about": "À propos",
+  "common.help": "Aide et support",
+  "common.logout": "Déconnexion",
+  "common.login": "Connexion",
+  "common.error": "Erreur",
+  "common.retry": "Réessayer",
+  "common.success": "Succès",
+  "common.delete": "Supprimer",
+  "common.exit": "Quitter",
+  "common.info": "Information",
+  "auth.logoutTitle": "Déconnexion",
+  "auth.logoutMessage": "Voulez-vous vraiment vous déconnecter ?",
+  "home.exitTitle": "Quitter l'application ?",
+  "home.exitMessage": "Voulez-vous vraiment quitter Formulus ?",
+  "sync.operationFailed": "Échec de l'opération",
+  "sync.updateFailed": "Échec de la mise à jour",
+  "sync.authErrorTitle": "Erreur d'authentification",
+  "sync.sessionExpired": "Votre session a expiré. Veuillez vous reconnecter.",
+  "sync.loginToUpdateBundle": "Connectez-vous pour mettre à jour le paquet d'application.",
+  "sync.unsynchronizedDataTitle": "Données non synchronisées",
+  "sync.unsynchronizedDataMessage_one": "Vous avez {{count}} élément non synchronisé. Synchronisez vos données avant la mise à jour pour éviter toute perte.",
+  "sync.unsynchronizedDataMessage_other": "Vous avez {{count}} éléments non synchronisés. Synchronisez vos données avant la mise à jour pour éviter toute perte.",
+  "sync.syncAndUpdate": "Synchroniser et mettre à jour",
+  "sync.repositoryResetTitle": "Les données du serveur ont été réinitialisées",
+  "sync.repositoryResetMessage": "Le serveur a remplacé son jeu de données d'observations (nouvelle génération). Pour synchroniser à nouveau, cet appareil doit supprimer toutes les observations locales et toutes les pièces jointes, y compris celles non encore envoyées.\n\nCette action est irréversible. Effacer tout sur cet appareil et synchroniser à nouveau ?",
+  "sync.eraseAndSync": "Effacer et synchroniser",
+  "sync.progress.phase.pull_observations": "Synchronisation des observations",
+  "sync.progress.phase.pull_attachments": "Téléchargement des pièces jointes",
+  "sync.progress.phase.push_attachments": "Envoi des pièces jointes",
+  "sync.progress.phase.push_observations": "Envoi des modifications",
+  "sync.progress.phase.app_bundle": "Mise à jour des formulaires",
+  "sync.progress.phase.default": "Synchronisation",
+  "sync.progress.syncingAndUpdatingForms": "Synchronisation et mise à jour des formulaires",
+  "sync.progress.syncingAndUpdating": "Synchronisation et mise à jour",
+  "sync.progress.starting": "Démarrage…",
+  "sync.progress.complete": "Terminé",
+  "sync.progress.preparingDownload": "Préparation du téléchargement…",
+  "sync.progress.connecting": "Connexion…",
+  "sync.progress.checkingAttachments": "Vérification des pièces jointes…",
+  "sync.progress.upToDate": "À jour",
+  "sync.progress.downloading": "Téléchargement…",
+  "sync.progress.downloadingPage": "Téléchargement (page {{page}})…",
+  "sync.progress.recordsDownloaded_one": "{{count}} observation téléchargée",
+  "sync.progress.recordsDownloaded_other": "{{count}} observations téléchargées",
+  "sync.progress.recordsSummary_one": "{{count}} observation",
+  "sync.progress.recordsSummary_other": "{{count}} observations",
+  "sync.progress.nothingToUpload": "Rien à envoyer",
+  "sync.progress.uploadingObservations_one": "Envoi de {{count}} observation…",
+  "sync.progress.uploadingObservations_other": "Envoi de {{count}} observations…",
+  "sync.progress.uploadComplete": "Envoi terminé",
+  "sync.progress.countOf": "{{current}} sur {{total}}",
+  "sync.progress.inProgress": "En cours…",
+  "settings.switchServerTitle": "Changer de serveur ?",
+  "settings.switchServerWipeMessage": "Changer de serveur effacera toutes les données locales de l'ancien serveur.",
+  "settings.switchServerPendingMessage": "Observations non synchronisées : {{observations}}\nPièces jointes non synchronisées : {{attachments}}\n\nIl est recommandé de synchroniser avant de changer.",
+  "settings.proceedWithoutSync": "Continuer sans synchroniser",
+  "settings.syncThenSwitch": "Synchroniser puis changer",
+  "settings.yesWipeAndSwitch": "Oui, effacer et changer",
+  "settings.switchedServerCleared": "Serveur changé et données locales effacées.",
+  "settings.syncBeforeSwitchFailed": "{{error}}\n\nRéessayez ou continuez sans synchroniser.",
+  "settings.switchServerFailed": "Impossible de changer de serveur. Veuillez réessayer.",
+  "settings.syncInProgress": "Synchronisation déjà en cours…",
+  "settings.checkPendingFailed": "Impossible de vérifier les données en attente. Réessayez.",
+  "settings.httpTransportWarning": "HTTP est autorisé, mais nous recommandons HTTPS pour chiffrer le trafic (https://).",
+  "settings.loginSuccess": "Connexion réussie !",
+  "settings.loginFailedCredentials": "Vérifiez vos identifiants.",
+  "settings.loginFailed": "Échec de la connexion : {{message}}",
+  "settings.qrInvalid": "Format de code QR invalide. Veuillez réessayer.",
+  "settings.qrError": "Erreur de code QR : {{message}}",
+  "settings.qrScanFailed": "Impossible de scanner le code QR. Veuillez réessayer.",
+  "formplayer.formErrorTitle": "Erreur de formulaire",
+  "formplayer.noSchemaMessage": "Le formulaire « {{name}} » n'a pas de schéma. Il se peut qu'il ne se soit pas chargé correctement depuis le stockage. Essayez de synchroniser à nouveau.",
+  "formplayer.initFailed": "Impossible d'initialiser l'interface du formulaire. Fermez et réessayez.",
+  "formplayer.submitSuccessUpdated": "Observation mise à jour avec succès !",
+  "formplayer.submitSuccessSubmitted": "Formulaire envoyé avec succès !",
+  "formplayer.saveFailed": "Impossible d'enregistrer le formulaire. Veuillez réessayer.",
+  "observations.notFound": "Observation introuvable",
+  "observations.loadFailed": "Impossible de charger l'observation",
+  "observations.updateSuccess": "Observation mise à jour avec succès",
+  "observations.deleteSuccess": "Observation supprimée avec succès",
+  "help.exportFailed": "Échec de l'export",
+  "help.exportAttachmentsFailed": "Impossible d'exporter les pièces jointes.",
+  "help.exportObservationsFailed": "Impossible d'exporter les observations.",
+  "signature.noData": "Aucune signature capturée. Veuillez réessayer.",
+  "signature.required": "Veuillez fournir une signature avant d'enregistrer.",
+  "media.selectImageTitle": "Sélectionner une image",
+  "media.selectImageMessage": "Choisissez une option",
+  "media.camera": "Appareil photo",
+  "media.gallery": "Galerie",
+  "admin.formServiceNotInitialized": "Le service de formulaires n'est pas initialisé",
+  "admin.loadFormDataFailed": "Impossible de charger les données des formulaires",
+  "admin.openFormNewFailed": "Impossible d'ouvrir le formulaire pour une nouvelle observation",
+  "admin.openFormEditFailed": "Impossible d'ouvrir le formulaire pour modifier l'observation",
+  "admin.confirmDeleteTitle": "Confirmer la suppression",
+  "admin.confirmDeleteMessage": "Voulez-vous vraiment supprimer cette observation ?",
+  "admin.resetDatabaseTitle": "Réinitialiser la base de données",
+  "admin.resetDatabaseMessage": "Voulez-vous vraiment supprimer TOUTES les observations ? Cette action est irréversible.",
+  "admin.resetDatabaseButton": "Réinitialiser la base de données",
+  "admin.resetDatabaseSuccess": "La base de données a été réinitialisée avec succès.",
+  "admin.resetDatabaseFailed": "Impossible de réinitialiser la base de données"
+}
diff --git a/formulus/src/locales/pt.json b/formulus/src/locales/pt.json
new file mode 100644
index 000000000..4cd422dc7
--- /dev/null
+++ b/formulus/src/locales/pt.json
@@ -0,0 +1,204 @@
+{
+  "settings.language.auto": "Automático (dispositivo)",
+  "settings.language.en": "English",
+  "settings.language.pt": "Português",
+  "settings.language.fr": "Français",
+  "settings.language.label": "Idioma:",
+  "settings.theme.label": "Tema:",
+  "settings.title": "Definições",
+  "settings.appSettings": "Definições da aplicação",
+  "settings.subtitle": "Introduza os dados do seu servidor Synkronus",
+  "settings.login": "Entrar",
+  "settings.loggingIn": "A entrar...",
+  "settings.serverUrl": "URL do servidor",
+  "settings.username": "Nome de utilizador",
+  "settings.password": "Palavra-passe",
+  "settings.updated": "Definições atualizadas com sucesso",
+  "settings.scanQr": "Ler código QR",
+  "menu.title": "Menu",
+  "menu.notLoggedIn": "Sessão não iniciada",
+  "menu.loginHint": "Toque em Entrar na parte inferior",
+  "roles.admin": "Administrador",
+  "roles.readWrite": "Leitura e escrita",
+  "roles.readOnly": "Só leitura",
+  "tabs.sync": "Sincronizar",
+  "tabs.forms": "Formulários",
+  "tabs.settings": "Definições",
+  "tabs.home": "Início",
+  "tabs.observations": "Observações",
+  "tabs.more": "Mais",
+  "sync.title": "Sincronizar",
+  "sync.syncing": "A sincronizar…",
+  "sync.syncingAndUpdating": "A sincronizar e atualizar…",
+  "sync.completed": "Sincronização concluída",
+  "sync.failed": "Falha na sincronização",
+  "sync.status": "Estado",
+  "sync.lastSync": "Última sincronização",
+  "sync.never": "Nunca",
+  "sync.error": "Erro",
+  "sync.pendingSync": "Sincronização pendente",
+  "sync.noPendingChanges": "Sem alterações locais pendentes",
+  "sync.tapToSync": "Toque para sincronizar agora",
+  "sync.observationsSection": "Observações e anexos",
+  "sync.pendingItems": "Itens pendentes",
+  "sync.readOnlyHint": "Contas só de leitura não podem enviar alterações. A sincronização continua a descarregar atualizações do servidor.",
+  "sync.observations": "Observações",
+  "sync.attachments": "Anexos",
+  "sync.record_one": "{{count}} registo",
+  "sync.record_other": "{{count}} registos",
+  "sync.file_one": "{{count}} ficheiro ({{size}} MB)",
+  "sync.file_other": "{{count}} ficheiros ({{size}} MB)",
+  "sync.dismiss": "Dispensar",
+  "sync.syncObservationsPullPush": "Sincronizar observações (enviar+receber)",
+  "sync.syncObservationsPull": "Sincronizar observações (receber)",
+  "sync.updating": "A atualizar...",
+  "sync.update": "Atualizar",
+  "sync.appBundle": "Pacote da aplicação",
+  "sync.appBundleSubtitle": "Definições de formulários e recursos da aplicação personalizada",
+  "sync.version": "Versão",
+  "sync.local": "Local",
+  "sync.server": "Servidor",
+  "sync.updateAvailable": "Atualização disponível",
+  "sync.upToDate": "Atualizado",
+  "sync.couldNotVerifyVersions": "Não foi possível verificar as versões",
+  "sync.bundleVersionUnavailable": "Não foi possível carregar a informação da versão do pacote.",
+  "sync.serverBundleUnknown": "Não foi possível carregar a versão do pacote no servidor.",
+  "sync.localBundleUnknown": "Não foi possível ler a versão local do pacote.",
+  "filters.all": "Todos",
+  "filters.synced": "Sincronizado",
+  "filters.pending": "Pendente",
+  "forms.title": "Formulários",
+  "forms.available_one": "{{count}} formulário disponível",
+  "forms.available_other": "{{count}} formulários disponíveis",
+  "forms.loading": "A carregar formulários...",
+  "forms.searchPlaceholder": "Pesquisar formulários...",
+  "forms.errorTitle": "Erro ao carregar formulários",
+  "forms.retry": "Tentar novamente",
+  "forms.openError": "Não foi possível abrir o formulário. Tente novamente.",
+  "forms.emptyTitle": "Sem formulários disponíveis",
+  "forms.emptyMessage": "Ainda não foram descarregados formulários. Vá ao ecrã Sincronizar para descarregar formulários do servidor.",
+  "forms.emptySearchTitle": "Nenhum formulário encontrado",
+  "forms.emptySearchMessage": "Tente ajustar a pesquisa.",
+  "observations.title": "Observações",
+  "observations.count_one": "{{count}} observação",
+  "observations.count_other": "{{count}} observações",
+  "observations.loading": "A carregar observações...",
+  "observations.searchPlaceholder": "Pesquisar observações...",
+  "observations.allForms": "Todos os formulários",
+  "observations.errorTitle": "Erro ao carregar observações",
+  "observations.emptyFound": "Nenhuma observação encontrada",
+  "observations.emptyYet": "Ainda sem observações",
+  "observations.emptyFoundMessage": "Tente ajustar a pesquisa ou os filtros.",
+  "observations.emptyYetMessage": "Comece a preencher formulários para criar observações. Os seus dados aparecerão aqui depois de guardados.",
+  "observations.deleteTitle": "Eliminar observação",
+  "observations.deleteMessage": "Tem a certeza de que pretende eliminar esta observação? Esta ação não pode ser anulada.",
+  "observations.delete": "Eliminar",
+  "observations.editError": "Não foi possível editar a observação. Tente novamente.",
+  "observations.deleteError": "Não foi possível eliminar a observação.",
+  "formplayer.closeTitle": "Fechar formulário?",
+  "formplayer.closeMessage": "Alterações não guardadas podem perder-se.",
+  "formplayer.saving": "A guardar dados do formulário...",
+  "common.cancel": "Cancelar",
+  "common.close": "Fechar",
+  "common.ok": "OK",
+  "common.about": "Acerca de",
+  "common.help": "Ajuda e suporte",
+  "common.logout": "Terminar sessão",
+  "common.login": "Entrar",
+  "common.error": "Erro",
+  "common.retry": "Tentar novamente",
+  "common.success": "Sucesso",
+  "common.delete": "Eliminar",
+  "common.exit": "Sair",
+  "common.info": "Informação",
+  "auth.logoutTitle": "Terminar sessão",
+  "auth.logoutMessage": "Tem a certeza de que pretende terminar sessão?",
+  "home.exitTitle": "Sair da aplicação?",
+  "home.exitMessage": "Tem a certeza de que pretende sair do Formulus?",
+  "sync.operationFailed": "Operação falhou",
+  "sync.updateFailed": "Atualização falhou",
+  "sync.authErrorTitle": "Erro de autenticação",
+  "sync.sessionExpired": "A sua sessão expirou. Inicie sessão novamente.",
+  "sync.loginToUpdateBundle": "Inicie sessão para atualizar o pacote da aplicação.",
+  "sync.unsynchronizedDataTitle": "Dados não sincronizados",
+  "sync.unsynchronizedDataMessage_one": "Tem {{count}} item não sincronizado. Sincronize os dados antes de atualizar para evitar perda de dados.",
+  "sync.unsynchronizedDataMessage_other": "Tem {{count}} itens não sincronizados. Sincronize os dados antes de atualizar para evitar perda de dados.",
+  "sync.syncAndUpdate": "Sincronizar e atualizar",
+  "sync.repositoryResetTitle": "Os dados do servidor foram repostos",
+  "sync.repositoryResetMessage": "O servidor substituiu o conjunto de observações (nova geração de dados). Para sincronizar novamente, este dispositivo deve eliminar todas as observações locais e todos os ficheiros anexos, incluindo itens ainda não enviados.\n\nIsto não pode ser anulado. Apagar tudo neste dispositivo e sincronizar novamente?",
+  "sync.eraseAndSync": "Apagar e sincronizar",
+  "sync.progress.phase.pull_observations": "A sincronizar observações",
+  "sync.progress.phase.pull_attachments": "A descarregar anexos",
+  "sync.progress.phase.push_attachments": "A enviar anexos",
+  "sync.progress.phase.push_observations": "A enviar alterações",
+  "sync.progress.phase.app_bundle": "A atualizar formulários",
+  "sync.progress.phase.default": "A sincronizar",
+  "sync.progress.syncingAndUpdatingForms": "A sincronizar e atualizar formulários",
+  "sync.progress.syncingAndUpdating": "A sincronizar e atualizar",
+  "sync.progress.starting": "A iniciar…",
+  "sync.progress.complete": "Concluído",
+  "sync.progress.preparingDownload": "A preparar descarga…",
+  "sync.progress.connecting": "A ligar…",
+  "sync.progress.checkingAttachments": "A verificar anexos…",
+  "sync.progress.upToDate": "Atualizado",
+  "sync.progress.downloading": "A descarregar…",
+  "sync.progress.downloadingPage": "A descarregar (página {{page}})…",
+  "sync.progress.recordsDownloaded_one": "{{count}} observação descarregada",
+  "sync.progress.recordsDownloaded_other": "{{count}} observações descarregadas",
+  "sync.progress.recordsSummary_one": "{{count}} observação",
+  "sync.progress.recordsSummary_other": "{{count}} observações",
+  "sync.progress.nothingToUpload": "Nada para enviar",
+  "sync.progress.uploadingObservations_one": "A enviar {{count}} observação…",
+  "sync.progress.uploadingObservations_other": "A enviar {{count}} observações…",
+  "sync.progress.uploadComplete": "Envio concluído",
+  "sync.progress.countOf": "{{current}} de {{total}}",
+  "sync.progress.inProgress": "Em curso…",
+  "settings.switchServerTitle": "Mudar de servidor?",
+  "settings.switchServerWipeMessage": "Mudar de servidor irá apagar todos os dados locais do servidor anterior.",
+  "settings.switchServerPendingMessage": "Observações por sincronizar: {{observations}}\nAnexos por sincronizar: {{attachments}}\n\nRecomenda-se sincronizar antes de mudar.",
+  "settings.proceedWithoutSync": "Continuar sem sincronizar",
+  "settings.syncThenSwitch": "Sincronizar e mudar",
+  "settings.yesWipeAndSwitch": "Sim, apagar e mudar",
+  "settings.switchedServerCleared": "Servidor alterado e dados locais apagados.",
+  "settings.syncBeforeSwitchFailed": "{{error}}\n\nTente novamente ou continue sem sincronizar.",
+  "settings.switchServerFailed": "Não foi possível mudar de servidor. Tente novamente.",
+  "settings.syncInProgress": "Sincronização já em curso…",
+  "settings.checkPendingFailed": "Não foi possível verificar dados pendentes. Tente novamente.",
+  "settings.httpTransportWarning": "HTTP é permitido, mas recomendamos HTTPS para encriptar o tráfego (https://).",
+  "settings.loginSuccess": "Sessão iniciada com sucesso!",
+  "settings.loginFailedCredentials": "Verifique as suas credenciais.",
+  "settings.loginFailed": "Falha no login: {{message}}",
+  "settings.qrInvalid": "Formato de código QR inválido. Tente novamente.",
+  "settings.qrError": "Erro no código QR: {{message}}",
+  "settings.qrScanFailed": "Não foi possível ler o código QR. Tente novamente.",
+  "formplayer.formErrorTitle": "Erro no formulário",
+  "formplayer.noSchemaMessage": "O formulário \"{{name}}\" não tem esquema. O formulário pode não ter sido carregado corretamente do armazenamento. Tente sincronizar novamente.",
+  "formplayer.initFailed": "Não foi possível inicializar a interface do formulário. Feche e tente novamente.",
+  "formplayer.submitSuccessUpdated": "Observação atualizada com sucesso!",
+  "formplayer.submitSuccessSubmitted": "Formulário enviado com sucesso!",
+  "formplayer.saveFailed": "Não foi possível guardar o formulário. Tente novamente.",
+  "observations.notFound": "Observação não encontrada",
+  "observations.loadFailed": "Não foi possível carregar a observação",
+  "observations.updateSuccess": "Observação atualizada com sucesso",
+  "observations.deleteSuccess": "Observação eliminada com sucesso",
+  "help.exportFailed": "Exportação falhou",
+  "help.exportAttachmentsFailed": "Não foi possível exportar anexos.",
+  "help.exportObservationsFailed": "Não foi possível exportar observações.",
+  "signature.noData": "Nenhuma assinatura capturada. Tente novamente.",
+  "signature.required": "Forneça uma assinatura antes de guardar.",
+  "media.selectImageTitle": "Selecionar imagem",
+  "media.selectImageMessage": "Escolha uma opção",
+  "media.camera": "Câmara",
+  "media.gallery": "Galeria",
+  "admin.formServiceNotInitialized": "O serviço de formulários não está inicializado",
+  "admin.loadFormDataFailed": "Não foi possível carregar dados dos formulários",
+  "admin.openFormNewFailed": "Não foi possível abrir formulário para nova observação",
+  "admin.openFormEditFailed": "Não foi possível abrir formulário para editar observação",
+  "admin.confirmDeleteTitle": "Confirmar eliminação",
+  "admin.confirmDeleteMessage": "Tem a certeza de que pretende eliminar esta observação?",
+  "admin.resetDatabaseTitle": "Repor base de dados",
+  "admin.resetDatabaseMessage": "Tem a certeza de que pretende eliminar TODAS as observações? Esta ação não pode ser anulada.",
+  "admin.resetDatabaseButton": "Repor base de dados",
+  "admin.resetDatabaseSuccess": "A base de dados foi reposta com sucesso.",
+  "admin.resetDatabaseFailed": "Não foi possível repor a base de dados"
+}
diff --git a/formulus/src/navigation/MainTabNavigator.tsx b/formulus/src/navigation/MainTabNavigator.tsx
index 5b46c811b..9d54d7f4c 100644
--- a/formulus/src/navigation/MainTabNavigator.tsx
+++ b/formulus/src/navigation/MainTabNavigator.tsx
@@ -28,6 +28,7 @@ import {
   VISIBLE_MAIN_TABS,
 } from '../types/NavigationTypes';
 import { useAppTheme } from '../contexts/AppThemeContext';
+import { useTranslation } from 'react-i18next';
 import tokens from '@ode/tokens/dist/react-native/tokens-resolved';
 
 const Tab = createBottomTabNavigator<MainTabParamList>();
@@ -149,6 +150,14 @@ const TAB_ICONS: Record<
   More: renderMoreIcon,
 };
 
+const TAB_ACCESSIBILITY_KEYS: Record<VisibleMainTab, string> = {
+  Home: 'tabs.home',
+  Forms: 'tabs.forms',
+  Observations: 'tabs.observations',
+  Sync: 'tabs.sync',
+  More: 'tabs.more',
+};
+
 const isVisibleMainTab = (value: string): value is VisibleMainTab =>
   (VISIBLE_MAIN_TABS as readonly string[]).includes(value);
 
@@ -233,6 +242,7 @@ const CustomTabBar: React.FC<CustomTabBarProps> = ({
   insets,
   style,
 }) => {
+  const { t } = useTranslation();
   const visibleRoutes = state.routes.filter(r =>
     (VISIBLE_MAIN_TABS as readonly string[]).includes(r.name),
   );
@@ -281,6 +291,10 @@ const CustomTabBar: React.FC<CustomTabBarProps> = ({
                 focused,
               })
             : null;
+          const tabName = route.name as VisibleMainTab;
+          const accessibilityLabel = isVisibleMainTab(tabName)
+            ? t(TAB_ACCESSIBILITY_KEYS[tabName])
+            : route.name;
 
           return (
             <Pressable
@@ -299,7 +313,8 @@ const CustomTabBar: React.FC<CustomTabBarProps> = ({
                 );
               }}
               accessibilityRole="button"
-              accessibilityState={{ selected: focused }}>
+              accessibilityState={{ selected: focused }}
+              accessibilityLabel={accessibilityLabel}>
               {icon}
             </Pressable>
           );
diff --git a/formulus/src/screens/FormManagementScreen.tsx b/formulus/src/screens/FormManagementScreen.tsx
index 48bc248e6..4235a54ee 100644
--- a/formulus/src/screens/FormManagementScreen.tsx
+++ b/formulus/src/screens/FormManagementScreen.tsx
@@ -21,6 +21,7 @@ import { MainAppStackParamList } from '../types/NavigationTypes';
 import { colors } from '../theme/colors';
 import { odeScreenHeaderHeight } from '../theme/odeDesign';
 import { useConfirmModal } from '../contexts/ConfirmModalContext';
+import { useTranslation } from 'react-i18next';
 
 type FormManagementScreenNavigationProp = StackNavigationProp<
   MainAppStackParamList,
@@ -33,6 +34,7 @@ type FormManagementScreenNavigationProp = StackNavigationProp<
 const FormManagementScreen = () => {
   const navigation = useNavigation<FormManagementScreenNavigationProp>();
   const { showConfirm } = useConfirmModal();
+  const { t } = useTranslation();
   const [formSpecs, setFormSpecs] = useState<FormSpec[]>([]);
   const [observations, setObservations] = useState<
     Record<string, Observation[]>
@@ -59,7 +61,7 @@ const FormManagementScreen = () => {
 
   const loadData = useCallback(async () => {
     if (!formService) {
-      Alert.alert('Error', 'FormService is not initialized');
+      Alert.alert(t('common.error'), t('admin.formServiceNotInitialized'));
       return;
     }
     try {
@@ -80,12 +82,12 @@ const FormManagementScreen = () => {
       setObservations(observationsMap);
     } catch (error) {
       console.error('Error loading form data:', error);
-      Alert.alert('Error', 'Failed to load form data');
+      Alert.alert(t('common.error'), t('admin.loadFormDataFailed'));
     } finally {
       setLoading(false);
       setRefreshing(false);
     }
-  }, [formService]);
+  }, [formService, t]);
 
   useEffect(() => {
     if (!formService) {
@@ -122,7 +124,7 @@ const FormManagementScreen = () => {
         'Error while opening Formplayer for new observation:',
         error,
       );
-      Alert.alert('Error', 'Failed to open form for new observation');
+      Alert.alert(t('common.error'), t('admin.openFormNewFailed'));
     }
   };
 
@@ -150,7 +152,7 @@ const FormManagementScreen = () => {
         'Error while opening Formplayer for editing observation:',
         error,
       );
-      Alert.alert('Error', 'Failed to open form for editing observation');
+      Alert.alert(t('common.error'), t('admin.openFormEditFailed'));
     }
   };
 
@@ -165,17 +167,17 @@ const FormManagementScreen = () => {
     observation: Observation,
   ) => {
     if (!formService) {
-      Alert.alert('Error', 'FormService is not initialized');
+      Alert.alert(t('common.error'), t('admin.formServiceNotInitialized'));
       return;
     }
     try {
       showConfirm({
-        title: 'Confirm Delete',
-        message: 'Are you sure you want to delete this observation?',
+        title: t('admin.confirmDeleteTitle'),
+        message: t('admin.confirmDeleteMessage'),
         buttons: [
-          { text: 'Cancel', onPress: () => {}, variant: 'tertiary' },
+          { text: t('common.cancel'), onPress: () => {}, variant: 'tertiary' },
           {
-            text: 'Delete',
+            text: t('common.delete'),
             variant: 'danger',
             onPress: async () => {
               setLoading(true);
@@ -187,38 +189,37 @@ const FormManagementScreen = () => {
       });
     } catch (error) {
       console.error('Error deleting observation:', error);
-      Alert.alert('Error', 'Failed to delete observation');
+      Alert.alert(t('common.error'), t('observations.deleteError'));
       setLoading(false);
     }
   };
 
   const handleResetDatabase = async () => {
     if (!formService) {
-      Alert.alert('Error', 'FormService is not initialized');
+      Alert.alert(t('common.error'), t('admin.formServiceNotInitialized'));
       return;
     }
     try {
       showConfirm({
-        title: 'Reset Database',
-        message:
-          'Are you sure you want to delete ALL observations? This action cannot be undone.',
+        title: t('admin.resetDatabaseTitle'),
+        message: t('admin.resetDatabaseMessage'),
         buttons: [
-          { text: 'Cancel', onPress: () => {}, variant: 'tertiary' },
+          { text: t('common.cancel'), onPress: () => {}, variant: 'tertiary' },
           {
-            text: 'Reset Database',
+            text: t('admin.resetDatabaseButton'),
             variant: 'danger',
             onPress: async () => {
               setLoading(true);
               await formService.resetDatabase();
               await loadData();
-              Alert.alert('Success', 'Database has been reset successfully.');
+              Alert.alert(t('common.success'), t('admin.resetDatabaseSuccess'));
             },
           },
         ],
       });
     } catch (error) {
       console.error('Error resetting database:', error);
-      Alert.alert('Error', 'Failed to reset database');
+      Alert.alert(t('common.error'), t('admin.resetDatabaseFailed'));
       setLoading(false);
     }
   };
diff --git a/formulus/src/screens/FormsScreen.tsx b/formulus/src/screens/FormsScreen.tsx
index 0bf13b892..ee9ba01ae 100644
--- a/formulus/src/screens/FormsScreen.tsx
+++ b/formulus/src/screens/FormsScreen.tsx
@@ -26,8 +26,10 @@ import {
   odeRadius,
   odeScreenHeaderHeight,
 } from '../theme/odeDesign';
+import { useTranslation } from 'react-i18next';
 
 const FormsScreen: React.FC = () => {
+  const { t } = useTranslation();
   const { themeColors, resolvedMode } = useAppTheme();
   const shellStyle = useScreenShellStyle();
   const isDark = resolvedMode === 'dark';
@@ -90,7 +92,7 @@ const FormsScreen: React.FC = () => {
       }
     } catch (err) {
       console.error('Error opening form:', err);
-      Alert.alert('Error', 'Failed to open form. Please try again.');
+      Alert.alert(t('common.error'), t('forms.openError'));
     }
   };
 
@@ -117,7 +119,7 @@ const FormsScreen: React.FC = () => {
             <ActivityIndicator size="large" color={themeColors.primary} />
             <Text
               style={[styles.loadingText, { color: themeColors.onBackground }]}>
-              Loading forms...
+              {t('forms.loading')}
             </Text>
           </View>
         </SafeAreaView>
@@ -135,9 +137,9 @@ const FormsScreen: React.FC = () => {
           ]}>
           <EmptyState
             icon="alert-circle-outline"
-            title="Error Loading Forms"
+            title={t('forms.errorTitle')}
             message={error}
-            actionLabel="Retry"
+            actionLabel={t('forms.retry')}
             onAction={refresh}
           />
         </SafeAreaView>
@@ -170,12 +172,11 @@ const FormsScreen: React.FC = () => {
                   marginBottom: showSubtitle ? 0 : odeSpacing.xs,
                 },
               ]}>
-              Forms
+              {t('forms.title')}
             </Text>
             {showSubtitle && (
               <Text style={[styles.subtitle, { color: themeColors.onSurface }]}>
-                {filteredForms.length} form
-                {filteredForms.length !== 1 ? 's' : ''} available
+                {t('forms.available', { count: filteredForms.length })}
               </Text>
             )}
           </View>
@@ -203,7 +204,7 @@ const FormsScreen: React.FC = () => {
               style={styles.searchIcon}
             />
             <ODEInput
-              placeholder="Search forms..."
+              placeholder={t('forms.searchPlaceholder')}
               value={searchQuery}
               onChangeText={setSearchQuery}
               style={styles.searchInput}
@@ -227,19 +228,21 @@ const FormsScreen: React.FC = () => {
         {forms.length === 0 ? (
           <EmptyState
             icon="file-document-outline"
-            title="No Forms Available"
-            message="No forms have been downloaded yet. Go to the Sync screen to download forms from the server."
+            title={t('forms.emptyTitle')}
+            message={t('forms.emptyMessage')}
           />
         ) : filteredForms.length === 0 ? (
           <EmptyState
             icon="file-document-outline"
             title={
-              effectiveSearchQuery ? 'No Forms Found' : 'No Forms Available'
+              effectiveSearchQuery
+                ? t('forms.emptySearchTitle')
+                : t('forms.emptyTitle')
             }
             message={
               effectiveSearchQuery
-                ? 'Try adjusting your search.'
-                : 'No forms have been downloaded yet. Go to the Sync screen to download forms from the server.'
+                ? t('forms.emptySearchMessage')
+                : t('forms.emptyMessage')
             }
           />
         ) : (
diff --git a/formulus/src/screens/HelpScreen.tsx b/formulus/src/screens/HelpScreen.tsx
index 6d2366aaa..bddbf84af 100644
--- a/formulus/src/screens/HelpScreen.tsx
+++ b/formulus/src/screens/HelpScreen.tsx
@@ -24,12 +24,14 @@ import {
 import logo from '../../assets/images/logo.png';
 import { attachmentExportService } from '../services/AttachmentExportService';
 import { observationExportService } from '../services/ObservationExportService';
+import { useTranslation } from 'react-i18next';
 
 const FORUM_URL = 'https://forum.opendataensemble.org';
 const EMAIL_URL = 'mailto:hello@opendataensemble.org';
 const GH_URL = 'https://github.com/OpenDataEnsemble';
 
 const HelpScreen: React.FC = () => {
+  const { t } = useTranslation();
   const [exportingAttachments, setExportingAttachments] = useState(false);
   const [exportingObservations, setExportingObservations] = useState(false);
   const { themeColors, resolvedMode } = useAppTheme();
@@ -56,8 +58,8 @@ const HelpScreen: React.FC = () => {
       await attachmentExportService.exportDeviceLocalAttachmentsZip();
     } catch (e) {
       const message =
-        e instanceof Error ? e.message : 'Could not export attachments.';
-      Alert.alert('Export failed', message);
+        e instanceof Error ? e.message : t('help.exportAttachmentsFailed');
+      Alert.alert(t('help.exportFailed'), message);
     } finally {
       setExportingAttachments(false);
     }
@@ -69,8 +71,8 @@ const HelpScreen: React.FC = () => {
       await observationExportService.exportAllObservationsZip();
     } catch (e) {
       const message =
-        e instanceof Error ? e.message : 'Could not export observations.';
-      Alert.alert('Export failed', message);
+        e instanceof Error ? e.message : t('help.exportObservationsFailed');
+      Alert.alert(t('help.exportFailed'), message);
     } finally {
       setExportingObservations(false);
     }
diff --git a/formulus/src/screens/HomeScreen.tsx b/formulus/src/screens/HomeScreen.tsx
index 689e6a9b5..0557720ff 100644
--- a/formulus/src/screens/HomeScreen.tsx
+++ b/formulus/src/screens/HomeScreen.tsx
@@ -17,9 +17,11 @@ import { appEvents, Listener } from '../webview/FormulusMessageHandlers';
 import { useAppTheme } from '../contexts/AppThemeContext';
 import { useScreenShellStyle } from '../hooks/useScreenShellStyle';
 import { useConfirmModal } from '../contexts/ConfirmModalContext';
+import { useTranslation } from 'react-i18next';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const HomeScreen = ({ navigation }: { navigation: any }) => {
+  const { t } = useTranslation();
   const [localUri, setLocalUri] = useState<string | null>(null);
   const [isLoading, setIsLoading] = useState(true);
   const [webViewKey, setWebViewKey] = useState(0);
@@ -42,12 +44,16 @@ const HomeScreen = ({ navigation }: { navigation: any }) => {
         }
 
         showConfirm({
-          title: 'Exit app?',
-          message: 'Are you sure you want to exit Formulus?',
+          title: t('home.exitTitle'),
+          message: t('home.exitMessage'),
           buttons: [
-            { text: 'Cancel', onPress: () => {}, variant: 'tertiary' },
             {
-              text: 'Exit',
+              text: t('common.cancel'),
+              onPress: () => {},
+              variant: 'tertiary',
+            },
+            {
+              text: t('common.exit'),
               variant: 'danger',
               onPress: () => BackHandler.exitApp(),
             },
@@ -62,7 +68,7 @@ const HomeScreen = ({ navigation }: { navigation: any }) => {
       );
 
       return () => subscription.remove();
-    }, [showConfirm]),
+    }, [showConfirm, t]),
   );
 
   const checkAndSetAppUri = useCallback(async () => {
diff --git a/formulus/src/screens/MoreScreen.tsx b/formulus/src/screens/MoreScreen.tsx
index 9c527718d..cf03a9a09 100644
--- a/formulus/src/screens/MoreScreen.tsx
+++ b/formulus/src/screens/MoreScreen.tsx
@@ -13,6 +13,7 @@ import MenuDrawer from '../components/MenuDrawer';
 import { logout } from '../api/synkronus/Auth';
 import { useConfirmModal } from '../contexts/ConfirmModalContext';
 import colors from '../theme/colors';
+import { useTranslation } from 'react-i18next';
 
 type MoreScreenNavigationProp = BottomTabNavigationProp<
   MainTabParamList,
@@ -25,6 +26,7 @@ const MoreScreen: React.FC = () => {
   const route = useRoute();
   const navigation = useNavigation<MoreScreenNavigationProp>();
   const { showConfirm } = useConfirmModal();
+  const { t } = useTranslation();
 
   useFocusEffect(
     React.useCallback(() => {
@@ -65,12 +67,12 @@ const MoreScreen: React.FC = () => {
 
   const handleLogout = () => {
     showConfirm({
-      title: 'Logout',
-      message: 'Are you sure you want to logout?',
+      title: t('auth.logoutTitle'),
+      message: t('auth.logoutMessage'),
       buttons: [
-        { text: 'Cancel', onPress: () => {}, variant: 'tertiary' },
+        { text: t('common.cancel'), onPress: () => {}, variant: 'tertiary' },
         {
-          text: 'Logout',
+          text: t('common.logout'),
           variant: 'danger',
           onPress: async () => {
             await logout();
diff --git a/formulus/src/screens/ObservationDetailScreen.tsx b/formulus/src/screens/ObservationDetailScreen.tsx
index d41e622c0..58f6e6798 100644
--- a/formulus/src/screens/ObservationDetailScreen.tsx
+++ b/formulus/src/screens/ObservationDetailScreen.tsx
@@ -21,6 +21,7 @@ import colors from '../theme/colors';
 import { Button } from '../components/common';
 import { useAppTheme } from '../contexts/AppThemeContext';
 import { useConfirmModal } from '../contexts/ConfirmModalContext';
+import { useTranslation } from 'react-i18next';
 import { useScreenShellStyle } from '../hooks/useScreenShellStyle';
 import {
   odeSpacing,
@@ -45,6 +46,7 @@ const ObservationDetailScreen: React.FC<ObservationDetailScreenProps> = ({
   const { themeColors } = useAppTheme();
   const shellStyle = useScreenShellStyle();
   const { showConfirm } = useConfirmModal();
+  const { t } = useTranslation();
   const [observation, setObservation] = useState<Observation | null>(null);
   const [formName, setFormName] = useState<string>('');
   const [loading, setLoading] = useState<boolean>(true);
@@ -76,7 +78,7 @@ const ObservationDetailScreen: React.FC<ObservationDetailScreenProps> = ({
       }
 
       if (!foundObservation) {
-        Alert.alert('Error', 'Observation not found');
+        Alert.alert(t('common.error'), t('observations.notFound'));
         navigation.goBack();
         return;
       }
@@ -84,12 +86,12 @@ const ObservationDetailScreen: React.FC<ObservationDetailScreenProps> = ({
       setObservation(foundObservation);
     } catch (error) {
       console.error('Error loading observation:', error);
-      Alert.alert('Error', 'Failed to load observation');
+      Alert.alert(t('common.error'), t('observations.loadFailed'));
       navigation.goBack();
     } finally {
       setLoading(false);
     }
-  }, [observationId, navigation]);
+  }, [observationId, navigation, t]);
 
   useEffect(() => {
     let cancelled = false;
@@ -121,11 +123,11 @@ const ObservationDetailScreen: React.FC<ObservationDetailScreenProps> = ({
         result.status === 'form_updated'
       ) {
         await loadObservation();
-        Alert.alert('Success', 'Observation updated successfully');
+        Alert.alert(t('common.success'), t('observations.updateSuccess'));
       }
     } catch (error) {
       console.error('Error editing observation:', error);
-      Alert.alert('Error', 'Failed to edit observation');
+      Alert.alert(t('common.error'), t('observations.editError'));
     }
   };
 
@@ -133,23 +135,22 @@ const ObservationDetailScreen: React.FC<ObservationDetailScreenProps> = ({
     if (!observation) return;
 
     showConfirm({
-      title: 'Delete Observation',
-      message:
-        'Are you sure you want to delete this observation? This action cannot be undone.',
+      title: t('observations.deleteTitle'),
+      message: t('observations.deleteMessage'),
       buttons: [
-        { text: 'Cancel', onPress: () => {}, variant: 'tertiary' },
+        { text: t('common.cancel'), onPress: () => {}, variant: 'tertiary' },
         {
-          text: 'Delete',
+          text: t('observations.delete'),
           variant: 'danger',
           onPress: async () => {
             try {
               const formService = await FormService.getInstance();
               await formService.deleteObservation(observation.observationId);
-              Alert.alert('Success', 'Observation deleted successfully');
+              Alert.alert(t('common.success'), t('observations.deleteSuccess'));
               navigation.goBack();
             } catch (error) {
               console.error('Error deleting observation:', error);
-              Alert.alert('Error', 'Failed to delete observation');
+              Alert.alert(t('common.error'), t('observations.deleteError'));
             }
           },
         },
diff --git a/formulus/src/screens/ObservationsScreen.tsx b/formulus/src/screens/ObservationsScreen.tsx
index 667aae9d2..9ed426335 100644
--- a/formulus/src/screens/ObservationsScreen.tsx
+++ b/formulus/src/screens/ObservationsScreen.tsx
@@ -38,6 +38,7 @@ import {
   odeRadius,
   odeScreenHeaderHeight,
 } from '../theme/odeDesign';
+import { useTranslation } from 'react-i18next';
 
 type ObservationsScreenNavigationProp = StackNavigationProp<
   MainAppStackParamList,
@@ -45,6 +46,7 @@ type ObservationsScreenNavigationProp = StackNavigationProp<
 >;
 
 const ObservationsScreen: React.FC = () => {
+  const { t } = useTranslation();
   const { themeColors, resolvedMode } = useAppTheme();
   const shellStyle = useScreenShellStyle();
   const isDark = resolvedMode === 'dark';
@@ -167,19 +169,18 @@ const ObservationsScreen: React.FC = () => {
       }
     } catch (err) {
       console.error('Error editing observation:', err);
-      Alert.alert('Error', 'Failed to edit observation. Please try again.');
+      Alert.alert(t('common.error'), t('observations.editError'));
     }
   };
 
   const handleDeleteObservation = async (observation: Observation) => {
     showConfirm({
-      title: 'Delete Observation',
-      message:
-        'Are you sure you want to delete this observation? This action cannot be undone.',
+      title: t('observations.deleteTitle'),
+      message: t('observations.deleteMessage'),
       buttons: [
-        { text: 'Cancel', onPress: () => {}, variant: 'tertiary' },
+        { text: t('common.cancel'), onPress: () => {}, variant: 'tertiary' },
         {
-          text: 'Delete',
+          text: t('observations.delete'),
           variant: 'danger',
           onPress: async () => {
             try {
@@ -188,7 +189,7 @@ const ObservationsScreen: React.FC = () => {
               await refresh();
             } catch (err) {
               console.error('Error deleting observation:', err);
-              Alert.alert('Error', 'Failed to delete observation.');
+              Alert.alert(t('common.error'), t('observations.deleteError'));
             }
           },
         },
@@ -220,7 +221,7 @@ const ObservationsScreen: React.FC = () => {
             <ActivityIndicator size="large" color={themeColors.primary} />
             <Text
               style={[styles.loadingText, { color: themeColors.onBackground }]}>
-              Loading observations...
+              {t('observations.loading')}
             </Text>
           </View>
         </SafeAreaView>
@@ -238,9 +239,9 @@ const ObservationsScreen: React.FC = () => {
           ]}>
           <EmptyState
             icon="alert-circle-outline"
-            title="Error Loading Observations"
+            title={t('observations.errorTitle')}
             message={error}
-            actionLabel="Retry"
+            actionLabel={t('common.retry')}
             onAction={refresh}
           />
         </SafeAreaView>
@@ -275,12 +276,11 @@ const ObservationsScreen: React.FC = () => {
                   marginBottom: showSubtitle ? 0 : odeSpacing.xs,
                 },
               ]}>
-              Observations
+              {t('observations.title')}
             </Text>
             {showSubtitle && (
               <Text style={[styles.subtitle, { color: themeColors.onSurface }]}>
-                {finalFiltered.length} observation
-                {finalFiltered.length !== 1 ? 's' : ''}
+                {t('observations.count', { count: finalFiltered.length })}
               </Text>
             )}
           </View>
@@ -304,7 +304,7 @@ const ObservationsScreen: React.FC = () => {
               style={styles.searchIcon}
             />
             <ODEInput
-              placeholder="Search observations..."
+              placeholder={t('observations.searchPlaceholder')}
               value={searchQuery}
               onChangeText={setSearchQuery}
               style={styles.searchInput}
@@ -332,7 +332,7 @@ const ObservationsScreen: React.FC = () => {
                 options={formTypes}
                 selectedId={selectedFormType}
                 onSelect={setSelectedFormType}
-                placeholder="All Forms"
+                placeholder={t('observations.allForms')}
                 style={{ alignSelf: 'stretch', maxWidth: undefined }}
               />
             </View>
@@ -351,13 +351,13 @@ const ObservationsScreen: React.FC = () => {
             icon="clipboard-text-outline"
             title={
               searchQuery || selectedFormType || syncStatus !== 'all'
-                ? 'No Observations Found'
-                : 'No Observations Yet'
+                ? t('observations.emptyFound')
+                : t('observations.emptyYet')
             }
             message={
               searchQuery || selectedFormType || syncStatus !== 'all'
-                ? 'Try adjusting your search or filter criteria.'
-                : 'Start filling out forms to create observations. Your data will appear here once saved.'
+                ? t('observations.emptyFoundMessage')
+                : t('observations.emptyYetMessage')
             }
           />
         ) : (
diff --git a/formulus/src/screens/SettingsScreen.tsx b/formulus/src/screens/SettingsScreen.tsx
index d82e6ec50..36f456f83 100644
--- a/formulus/src/screens/SettingsScreen.tsx
+++ b/formulus/src/screens/SettingsScreen.tsx
@@ -55,13 +55,14 @@ import {
   getSettingsHydrationSnapshot,
   loadSettingsHydrationFromStorage,
 } from '../services/SettingsHydrationCache';
-import { Button } from '../components/common';
+import { Button, LocalePicker } from '../components/common';
 import { useScreenShellStyle } from '../hooks/useScreenShellStyle';
 import Logo from '../../assets/images/logo.png';
-import { Moon, Monitor, Sun } from 'lucide-react-native';
-
-const HTTP_TRANSPORT_TOAST =
-  'HTTP is allowed, but we recommend HTTPS so traffic is encrypted (https://).';
+import { Moon, Monitor, Sun, Languages } from 'lucide-react-native';
+import { useTranslation } from 'react-i18next';
+import { localeSettingsService } from '../services/LocaleSettingsService';
+import { type UiLocalePreference } from '../lib/locale';
+import { syncFormulusI18nLanguage } from '../i18n';
 
 type SettingsScreenNavigationProp = BottomTabNavigationProp<
   MainTabParamList,
@@ -69,6 +70,7 @@ type SettingsScreenNavigationProp = BottomTabNavigationProp<
 >;
 
 const SettingsScreen = () => {
+  const { t } = useTranslation();
   const navigation = useNavigation<SettingsScreenNavigationProp>();
   const { themeColors, themeMode, setThemeMode, resolvedMode } = useAppTheme();
   const shellStyle = useScreenShellStyle();
@@ -91,6 +93,8 @@ const SettingsScreen = () => {
   const [isLoggingIn, setIsLoggingIn] = useState(false);
   const [showQRScanner, setShowQRScanner] = useState(false);
   const [version, setVersion] = useState('');
+  const [uiLocalePreference, setUiLocalePreference] =
+    useState<UiLocalePreference>('auto');
   const mountedRef = useRef(true);
 
   useEffect(() => {
@@ -111,6 +115,23 @@ const SettingsScreen = () => {
     load();
   }, []);
 
+  useEffect(() => {
+    void localeSettingsService.load().then(() => {
+      if (mountedRef.current) {
+        setUiLocalePreference(localeSettingsService.getPreference());
+      }
+    });
+  }, []);
+
+  const handleLocalePreference = useCallback(
+    async (preference: UiLocalePreference) => {
+      setUiLocalePreference(preference);
+      await localeSettingsService.setPreference(preference);
+      await syncFormulusI18nLanguage();
+    },
+    [],
+  );
+
   useEffect(() => {
     let cancelled = false;
 
@@ -187,7 +208,7 @@ const SettingsScreen = () => {
           await serverSwitchService.resetForServerChange(normalizedUrl);
           setInitialServerUrl(normalizedUrl);
           setServerUrl(normalizedUrl);
-          ToastService.showShort('Switched server and cleared local data.');
+          ToastService.showShort(t('settings.switchedServerCleared'));
         };
 
         const syncThenReset = async () => {
@@ -198,7 +219,9 @@ const SettingsScreen = () => {
           } catch (error) {
             console.error('Sync before server switch failed:', error);
             ToastService.showLong(
-              `${getUserFacingSyncErrorMessage(error)}\n\nPlease retry or proceed without syncing.`,
+              t('settings.syncBeforeSwitchFailed', {
+                error: getUserFacingSyncErrorMessage(error),
+              }),
             );
             return false;
           }
@@ -207,13 +230,16 @@ const SettingsScreen = () => {
         return await new Promise<boolean>(resolve => {
           const hasPending = pendingObservations > 0 || pendingAttachments > 0;
           const message = hasPending
-            ? `Unsynced observations: ${pendingObservations}\nUnsynced attachments: ${pendingAttachments}\n\nSync is recommended before switching.`
-            : 'Switching servers will wipe all local data for the previous server.';
+            ? t('settings.switchServerPendingMessage', {
+                observations: pendingObservations,
+                attachments: pendingAttachments,
+              })
+            : t('settings.switchServerWipeMessage');
 
           const buttons = hasPending
             ? [
                 {
-                  text: 'Cancel',
+                  text: t('common.cancel'),
                   variant: 'tertiary' as const,
                   onPress: () => {
                     setServerUrl(trimmedInitial);
@@ -221,7 +247,7 @@ const SettingsScreen = () => {
                   },
                 },
                 {
-                  text: 'Proceed without syncing',
+                  text: t('settings.proceedWithoutSync'),
                   variant: 'danger' as const,
                   onPress: () => {
                     (async () => {
@@ -230,21 +256,19 @@ const SettingsScreen = () => {
                         resolve(true);
                       } catch (error) {
                         console.error('Failed to switch server:', error);
-                        ToastService.showLong(
-                          'Failed to switch server. Please try again.',
-                        );
+                        ToastService.showLong(t('settings.switchServerFailed'));
                         resolve(false);
                       }
                     })();
                   },
                 },
                 {
-                  text: 'Sync then switch',
+                  text: t('settings.syncThenSwitch'),
                   variant: 'primary' as const,
                   onPress: () => {
                     (async () => {
                       if (syncService.getIsSyncing()) {
-                        ToastService.showShort('Sync already in progress...');
+                        ToastService.showShort(t('settings.syncInProgress'));
                         resolve(false);
                         return;
                       }
@@ -256,7 +280,7 @@ const SettingsScreen = () => {
               ]
             : [
                 {
-                  text: 'Cancel',
+                  text: t('common.cancel'),
                   variant: 'tertiary' as const,
                   onPress: () => {
                     setServerUrl(trimmedInitial);
@@ -264,7 +288,7 @@ const SettingsScreen = () => {
                   },
                 },
                 {
-                  text: 'Yes, wipe & switch',
+                  text: t('settings.yesWipeAndSwitch'),
                   variant: 'danger' as const,
                   onPress: () => {
                     (async () => {
@@ -273,9 +297,7 @@ const SettingsScreen = () => {
                         resolve(true);
                       } catch (error) {
                         console.error('Failed to switch server:', error);
-                        ToastService.showLong(
-                          'Failed to switch server. Please try again.',
-                        );
+                        ToastService.showLong(t('settings.switchServerFailed'));
                         resolve(false);
                       }
                     })();
@@ -284,18 +306,18 @@ const SettingsScreen = () => {
               ];
 
           showConfirm({
-            title: 'Switch server?',
+            title: t('settings.switchServerTitle'),
             message,
             buttons,
           });
         });
       } catch (error) {
         console.error('Failed to prepare server switch:', error);
-        ToastService.showLong('Unable to check pending data. Try again.');
+        ToastService.showLong(t('settings.checkPendingFailed'));
         return false;
       }
     },
-    [initialServerUrl, showConfirm],
+    [initialServerUrl, showConfirm, t],
   );
 
   const handleLogin = useCallback(async () => {
@@ -317,7 +339,7 @@ const SettingsScreen = () => {
     }
 
     if (norm.isHttp) {
-      ToastService.showLong(HTTP_TRANSPORT_TOAST);
+      ToastService.showLong(t('settings.httpTransportWarning'));
     }
 
     setServerUrl(norm.href);
@@ -334,13 +356,15 @@ const SettingsScreen = () => {
       await Keychain.setGenericPassword(trimmedUsername, trimmedPassword);
       await login(trimmedUsername, trimmedPassword);
       void loadSettingsHydrationFromStorage();
-      ToastService.showShort('Successfully logged in!');
+      ToastService.showShort(t('settings.loginSuccess'));
       navigation.navigate('Sync');
     } catch (error) {
       console.error('Login failed:', error);
       const message = isVersionMismatchError(error)
         ? error.message
-        : `Login failed: ${error && 'Please check your credentials.'}`;
+        : t('settings.loginFailed', {
+            message: t('settings.loginFailedCredentials'),
+          });
       ToastService.showLong(message);
     } finally {
       setIsLoggingIn(false);
@@ -352,6 +376,7 @@ const SettingsScreen = () => {
     isLoggingIn,
     handleServerSwitchIfNeeded,
     navigation,
+    t,
   ]);
 
   const handleQRResult = async (result: ScannerModalResults) => {
@@ -392,26 +417,28 @@ const SettingsScreen = () => {
           try {
             await login(settings.username, settings.password);
             void loadSettingsHydrationFromStorage();
-            ToastService.showShort('Successfully logged in!');
+            ToastService.showShort(t('settings.loginSuccess'));
             navigation.navigate('Sync');
           } catch (error) {
             console.error('Auto-login failed:', error);
-            const errorMessage =
-              error && 'Failed to login. Please check your credentials.';
-            ToastService.showLong(`Login failed: ${errorMessage}`);
+            ToastService.showLong(
+              t('settings.loginFailed', {
+                message: t('settings.loginFailedCredentials'),
+              }),
+            );
           }
         } else {
           void loadSettingsHydrationFromStorage();
-          ToastService.showShort('Settings updated successfully');
+          ToastService.showShort(t('settings.updated'));
         }
       } catch (error) {
         console.error('Failed to process QR code:', error);
-        const errorMessage =
-          error && 'Invalid QR code format. Please try again.';
-        ToastService.showLong(`QR code error: ${errorMessage}`);
+        ToastService.showLong(
+          t('settings.qrError', { message: t('settings.qrInvalid') }),
+        );
       }
     } else {
-      ToastService.showLong('Failed to scan QR code. Please try again.');
+      ToastService.showLong(t('settings.qrScanFailed'));
     }
   };
 
@@ -446,7 +473,7 @@ const SettingsScreen = () => {
               <Image source={Logo} style={styles.logo} resizeMode="contain" />
             </View>
             <Text style={[styles.brandName, { color: themeColors.onPrimary }]}>
-              Settings
+              {t('settings.title')}
             </Text>
           </View>
         </View>
@@ -462,15 +489,15 @@ const SettingsScreen = () => {
               styles.sectionHeaderFirst,
               { color: sectionHeaderColor },
             ]}>
-            App Settings
+            {t('settings.appSettings')}
           </Text>
           <Text style={[styles.titleSmall, { color: themeColors.onSurface }]}>
-            Please enter the details for your synkronus server
+            {t('settings.subtitle')}
           </Text>
 
           <View style={styles.inputContainer}>
             <ODEInput
-              placeholder="Server URL"
+              placeholder={t('settings.serverUrl')}
               value={serverUrl}
               onChangeText={setServerUrl}
               autoCapitalize="none"
@@ -480,7 +507,7 @@ const SettingsScreen = () => {
                 <TouchableOpacity
                   style={styles.qrButton}
                   onPress={() => setShowQRScanner(true)}
-                  accessibilityLabel="Scan QR code">
+                  accessibilityLabel={t('settings.scanQr')}>
                   <Icon
                     name="qrcode-scan"
                     size={24}
@@ -492,7 +519,7 @@ const SettingsScreen = () => {
           </View>
 
           <ODEInput
-            placeholder="Username"
+            placeholder={t('settings.username')}
             value={username}
             onChangeText={setUsername}
             autoCapitalize="none"
@@ -500,7 +527,7 @@ const SettingsScreen = () => {
           />
 
           <PasswordInput
-            placeholder="Password"
+            placeholder={t('settings.password')}
             value={password}
             onChangeText={setPassword}
             autoCapitalize="none"
@@ -509,7 +536,7 @@ const SettingsScreen = () => {
           />
 
           <Button
-            title={isLoggingIn ? 'Logging in...' : 'Login'}
+            title={isLoggingIn ? t('settings.loggingIn') : t('settings.login')}
             onPress={handleLogin}
             variant="primary"
             size="large"
@@ -534,7 +561,7 @@ const SettingsScreen = () => {
                   styles.appSettingsLabel,
                   { color: themeColors.onSurface },
                 ]}>
-                Theme:
+                {t('settings.theme.label')}
               </Text>
             </View>
 
@@ -586,6 +613,25 @@ const SettingsScreen = () => {
             </View>
           </View>
 
+          <View style={styles.themesInlineRow}>
+            <View style={styles.themesInlineLeft}>
+              <Languages size={22} color={themeColors.onSurface as string} />
+              <Text
+                style={[
+                  styles.appSettingsLabel,
+                  { color: themeColors.onSurface },
+                ]}>
+                {t('settings.language.label')}
+              </Text>
+            </View>
+            <View style={styles.languagePickerWrap}>
+              <LocalePicker
+                value={uiLocalePreference}
+                onChange={pref => void handleLocalePreference(pref)}
+              />
+            </View>
+          </View>
+
           <View style={styles.versionContainer}>
             {!!version && (
               <Text style={[styles.version, { color: themeColors.onSurface }]}>
@@ -708,6 +754,26 @@ const styles = StyleSheet.create({
   themeIconButton: {
     padding: odeSpacing.xs,
   },
+  languageOptionsRow: {
+    flex: 1,
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+    gap: odeSpacing.xs,
+    justifyContent: 'flex-end',
+  },
+  languageChip: {
+    borderWidth: 1,
+    borderRadius: 16,
+    paddingHorizontal: odeSpacing.sm,
+    paddingVertical: odeSpacing.xxs,
+  },
+  languageChipText: {
+    fontSize: odeTypography.bodySm,
+  },
+  languagePickerWrap: {
+    flex: 1,
+    alignItems: 'flex-end',
+  },
   inputContainer: {
     marginBottom: 1,
   },
diff --git a/formulus/src/screens/SyncScreen.tsx b/formulus/src/screens/SyncScreen.tsx
index 718d4742a..a65a78e3d 100644
--- a/formulus/src/screens/SyncScreen.tsx
+++ b/formulus/src/screens/SyncScreen.tsx
@@ -51,15 +51,12 @@ import {
   shouldShowSyncProgressCurrentItem,
   shouldShowSyncProgressPercent,
 } from '../sync/syncProgressUi';
+import { useTranslation } from 'react-i18next';
 
 type ActiveOperation = 'sync' | 'update' | 'sync_then_update' | null;
 
-const REPOSITORY_RESET_ALERT_TITLE = 'Server data was reset';
-
-const REPOSITORY_RESET_ALERT_MESSAGE =
-  'The server replaced its observation dataset (a new data generation). To sync again, this device must delete all local observations and all attachment files, including items that have not been uploaded yet.\n\nThis cannot be undone. Erase everything on this device and sync again?';
-
 const SyncScreen = () => {
+  const { t } = useTranslation();
   const { themeColors, resolvedMode } = useAppTheme();
   const shellStyle = useScreenShellStyle();
   const isDark = resolvedMode === 'dark';
@@ -225,12 +222,12 @@ const SyncScreen = () => {
         }
 
         Alert.alert(
-          REPOSITORY_RESET_ALERT_TITLE,
-          REPOSITORY_RESET_ALERT_MESSAGE,
+          t('sync.repositoryResetTitle'),
+          t('sync.repositoryResetMessage'),
           [
-            { text: 'Cancel', style: 'cancel' },
+            { text: t('common.cancel'), style: 'cancel' },
             {
-              text: 'Erase and sync',
+              text: t('sync.eraseAndSync'),
               style: 'destructive',
               onPress: () => {
                 void (async () => {
@@ -256,7 +253,7 @@ const SyncScreen = () => {
         );
       })();
     },
-    [startSync, finishSync, localSyncStateIsEmpty],
+    [startSync, finishSync, localSyncStateIsEmpty, t],
   );
 
   const handleSync = useCallback(async () => {
@@ -280,11 +277,11 @@ const SyncScreen = () => {
             await syncService.syncObservations(true);
             await refreshAfterOperation();
           },
-          'Sync failed',
+          t('sync.failed'),
         );
       } else {
         syncError = getUserFacingSyncErrorMessage(error);
-        Alert.alert('Sync Failed', syncError);
+        Alert.alert(t('sync.failed'), syncError);
       }
     } finally {
       finishSync(syncError);
@@ -296,6 +293,7 @@ const SyncScreen = () => {
     finishSync,
     refreshAfterOperation,
     runRepositoryResetRecovery,
+    t,
   ]);
 
   const performAppBundleUpdate = useCallback(async () => {
@@ -315,17 +313,14 @@ const SyncScreen = () => {
       const errorMessage = (error as Error).message;
       finishSync(errorMessage);
       if (errorMessage.includes('401')) {
-        Alert.alert(
-          'Authentication Error',
-          'Your session has expired. Please log in again.',
-        );
+        Alert.alert(t('sync.authErrorTitle'), t('sync.sessionExpired'));
       } else {
-        Alert.alert('Update Failed', errorMessage);
+        Alert.alert(t('sync.updateFailed'), errorMessage);
       }
     } finally {
       setActiveOperation(null);
     }
-  }, [startSync, finishSync, refreshAfterOperation]);
+  }, [startSync, finishSync, refreshAfterOperation, t]);
 
   const performSyncThenUpdate = useCallback(async () => {
     try {
@@ -357,12 +352,12 @@ const SyncScreen = () => {
             const fs = await formService.FormService.getInstance();
             await fs.invalidateCache();
           },
-          'Operation failed',
+          t('sync.operationFailed'),
         );
       } else {
         const errorMessage = getUserFacingSyncErrorMessage(error);
         finishSync(errorMessage);
-        Alert.alert('Operation Failed', errorMessage);
+        Alert.alert(t('sync.operationFailed'), errorMessage);
       }
     } finally {
       setActiveOperation(null);
@@ -372,6 +367,7 @@ const SyncScreen = () => {
     finishSync,
     refreshAfterOperation,
     runRepositoryResetRecovery,
+    t,
   ]);
 
   const handleCustomAppUpdate = useCallback(async () => {
@@ -379,7 +375,7 @@ const SyncScreen = () => {
 
     const userInfo = await getUserInfo();
     if (!userInfo) {
-      Alert.alert('Authentication Error', 'Please log in to update app bundle');
+      Alert.alert(t('sync.authErrorTitle'), t('sync.loginToUpdateBundle'));
       return;
     }
 
@@ -388,12 +384,12 @@ const SyncScreen = () => {
     if (hasPendingData) {
       const pendingCount = pendingObservations + pendingUploads.count;
       Alert.alert(
-        'Unsynchronized Data',
-        `You have ${pendingCount} unsynchronized item${pendingCount !== 1 ? 's' : ''}. Sync your data before updating to avoid data loss.`,
+        t('sync.unsynchronizedDataTitle'),
+        t('sync.unsynchronizedDataMessage', { count: pendingCount }),
         [
-          { text: 'Cancel', style: 'cancel' },
+          { text: t('common.cancel'), style: 'cancel' },
           {
-            text: 'Sync & Update',
+            text: t('sync.syncAndUpdate'),
             onPress: () => performSyncThenUpdate(),
           },
         ],
@@ -408,6 +404,7 @@ const SyncScreen = () => {
     pendingUploads.count,
     performAppBundleUpdate,
     performSyncThenUpdate,
+    t,
   ]);
 
   const checkForUpdates = useCallback(async () => {
@@ -439,13 +436,13 @@ const SyncScreen = () => {
   const getObservationStatusText = (): string => {
     if (isObservationSyncActive) {
       if (activeOperation === 'sync_then_update')
-        return 'Syncing & updating...';
-      return 'Syncing...';
+        return t('sync.syncingAndUpdating');
+      return t('sync.syncing');
     }
-    if (syncState.error) return 'Error';
+    if (syncState.error) return t('sync.error');
     if (pendingObservations > 0 || pendingUploads.count > 0)
-      return 'Pending sync';
-    return 'No pending local changes';
+      return t('sync.pendingSync');
+    return t('sync.noPendingChanges');
   };
 
   const observationStatus = getObservationStatusText();
@@ -570,7 +567,7 @@ const SyncScreen = () => {
         bg: bundleStatusUpdateBg,
         icon: 'arrow-down-circle' as const,
         iconColor: bundleStatusUpdateText,
-        label: 'Update available',
+        label: t('sync.updateAvailable'),
         textColor: bundleStatusUpdateText,
       };
     }
@@ -581,7 +578,7 @@ const SyncScreen = () => {
           : (colors.neutral[100] as string),
         icon: 'information-outline' as const,
         iconColor: mutedForeground,
-        label: 'Could not verify versions',
+        label: t('sync.couldNotVerifyVersions'),
         textColor: themeColors.onSurface as string,
       };
     }
@@ -589,7 +586,7 @@ const SyncScreen = () => {
       bg: bundleStatusOkBg,
       icon: 'check-circle' as const,
       iconColor: bundleSuccessGreen,
-      label: 'Up-to-date',
+      label: t('sync.upToDate'),
       textColor: bundleStatusOkText,
     };
   })();
@@ -597,10 +594,10 @@ const SyncScreen = () => {
   const hasPendingLocalObservationChanges =
     pendingObservations > 0 || pendingUploads.count > 0;
   const syncObservationsButtonLabel = syncState.isActive
-    ? 'Syncing...'
+    ? t('sync.syncing')
     : hasPendingLocalObservationChanges
-      ? 'Sync observations (pull+push)'
-      : 'Sync observations (pull)';
+      ? t('sync.syncObservationsPullPush')
+      : t('sync.syncObservationsPull');
 
   const showObservationProgress =
     syncState.isActive && syncState.progress && activeOperation !== 'update';
@@ -719,7 +716,7 @@ const SyncScreen = () => {
         ) : null}
         {syncState.canCancel && (
           <Button
-            title="Cancel"
+            title={t('common.cancel')}
             onPress={cancelSync}
             variant="danger"
             size="medium"
@@ -746,7 +743,9 @@ const SyncScreen = () => {
               borderBottomColor: themeColors.divider as string,
             },
           ]}>
-          <Text style={[styles.title, { color: titleColor }]}>Sync</Text>
+          <Text style={[styles.title, { color: titleColor }]}>
+            {t('sync.title')}
+          </Text>
         </View>
 
         <ScrollView
@@ -759,7 +758,7 @@ const SyncScreen = () => {
               styles.dataSectionHeading,
               { color: themeColors.onSurface as string },
             ]}>
-            Observations and attachments
+            {t('sync.observationsSection')}
           </Text>
           <View style={styles.statusCardsContainer}>
             <TouchableOpacity
@@ -810,7 +809,7 @@ const SyncScreen = () => {
                     styles.statusCardTitle,
                     { color: themeColors.onSurface as string },
                   ]}>
-                  Status
+                  {t('sync.status')}
                 </Text>
               </View>
               <Text
@@ -828,7 +827,7 @@ const SyncScreen = () => {
                       styles.statusCardSubtext,
                       { color: themeColors.onSurface as string },
                     ]}>
-                    Tap to sync now
+                    {t('sync.tapToSync')}
                   </Text>
                 )}
             </TouchableOpacity>
@@ -853,7 +852,7 @@ const SyncScreen = () => {
                     styles.statusCardTitle,
                     { color: themeColors.onSurface as string },
                   ]}>
-                  Last Sync
+                  {t('sync.lastSync')}
                 </Text>
               </View>
               <Text
@@ -861,7 +860,7 @@ const SyncScreen = () => {
                   styles.statusCardValue,
                   { color: themeColors.onSurface as string },
                 ]}>
-                {lastSync ? formatRelativeTime(lastSync) : 'Never'}
+                {lastSync ? formatRelativeTime(lastSync) : t('sync.never')}
               </Text>
             </View>
           </View>
@@ -881,7 +880,7 @@ const SyncScreen = () => {
                   styles.sectionTitle,
                   { color: themeColors.onSurface as string },
                 ]}>
-                Pending items
+                {t('sync.pendingItems')}
               </Text>
               {isReadOnly &&
                 (pendingObservations > 0 || pendingUploads.count > 0) && (
@@ -890,8 +889,7 @@ const SyncScreen = () => {
                       styles.readOnlyHint,
                       { color: themeColors.onSurface as string },
                     ]}>
-                    Read-only accounts cannot upload changes. Sync still
-                    downloads updates from the server.
+                    {t('sync.readOnlyHint')}
                   </Text>
                 )}
               {pendingObservations > 0 && (
@@ -907,15 +905,14 @@ const SyncScreen = () => {
                         styles.pendingItemLabel,
                         { color: themeColors.onSurface as string },
                       ]}>
-                      Observations
+                      {t('sync.observations')}
                     </Text>
                     <Text
                       style={[
                         styles.pendingItemValue,
                         { color: themeColors.onSurface as string },
                       ]}>
-                      {pendingObservations} record
-                      {pendingObservations !== 1 ? 's' : ''}
+                      {t('sync.record', { count: pendingObservations })}
                     </Text>
                   </View>
                 </View>
@@ -933,16 +930,17 @@ const SyncScreen = () => {
                         styles.pendingItemLabel,
                         { color: themeColors.onSurface as string },
                       ]}>
-                      Attachments
+                      {t('sync.attachments')}
                     </Text>
                     <Text
                       style={[
                         styles.pendingItemValue,
                         { color: themeColors.onSurface as string },
                       ]}>
-                      {pendingUploads.count} file
-                      {pendingUploads.count !== 1 ? 's' : ''} (
-                      {pendingUploads.sizeMB.toFixed(2)} MB)
+                      {t('sync.file', {
+                        count: pendingUploads.count,
+                        size: pendingUploads.sizeMB.toFixed(2),
+                      })}
                     </Text>
                   </View>
                 </View>
@@ -966,7 +964,7 @@ const SyncScreen = () => {
                   size={20}
                   color={colors.semantic.error.ios as string}
                 />
-                <Text style={styles.errorTitle}>Error</Text>
+                <Text style={styles.errorTitle}>{t('sync.error')}</Text>
               </View>
               <Text
                 style={[
@@ -976,7 +974,7 @@ const SyncScreen = () => {
                 {syncState.error}
               </Text>
               <Button
-                title="Dismiss"
+                title={t('sync.dismiss')}
                 onPress={clearError}
                 variant="danger"
                 size="medium"
@@ -1026,7 +1024,7 @@ const SyncScreen = () => {
               styles.appBundleSectionHeading,
               { color: themeColors.onSurface as string },
             ]}>
-            App bundle
+            {t('sync.appBundle')}
           </Text>
 
           <View
@@ -1041,7 +1039,7 @@ const SyncScreen = () => {
             ]}>
             <Text
               style={[styles.appBundleSubtitle, { color: mutedForeground }]}>
-              Form definitions and custom app assets
+              {t('sync.appBundleSubtitle')}
             </Text>
 
             <View style={styles.bundlePillActionsRow}>
@@ -1068,7 +1066,11 @@ const SyncScreen = () => {
                   <Button
                     variant="primary"
                     size="small"
-                    title={isUpdateButtonActive ? 'Updating...' : 'Update'}
+                    title={
+                      isUpdateButtonActive
+                        ? t('sync.updating')
+                        : t('sync.update')
+                    }
                     onPress={handleCustomAppUpdate}
                     disabled={syncState.isActive || !updateAvailable}
                     loading={isUpdateButtonActive}
@@ -1092,7 +1094,7 @@ const SyncScreen = () => {
                   styles.bundleVersionHeading,
                   { color: mutedForeground },
                 ]}>
-                Version
+                {t('sync.version')}
               </Text>
               <View style={styles.bundleVersionRows}>
                 <View style={styles.bundleVersionRow}>
@@ -1101,7 +1103,7 @@ const SyncScreen = () => {
                       styles.bundleVersionRole,
                       { color: themeColors.onSurface as string },
                     ]}>
-                    Local
+                    {t('sync.local')}
                   </Text>
                   <Text
                     selectable
@@ -1118,7 +1120,7 @@ const SyncScreen = () => {
                       styles.bundleVersionRole,
                       { color: themeColors.onSurface as string },
                     ]}>
-                    Server
+                    {t('sync.server')}
                   </Text>
                   <Text
                     selectable
@@ -1137,10 +1139,10 @@ const SyncScreen = () => {
                 style={[styles.appBundleFootnote, { color: mutedForeground }]}>
                 {serverBundleVersion === 'Unknown' &&
                 appBundleVersion === 'Unknown'
-                  ? 'Could not load bundle version information.'
+                  ? t('sync.bundleVersionUnavailable')
                   : serverBundleVersion === 'Unknown'
-                    ? 'Could not load server bundle version.'
-                    : 'Could not read local bundle version.'}
+                    ? t('sync.serverBundleUnknown')
+                    : t('sync.localBundleUnknown')}
               </Text>
             )}
           </View>
diff --git a/formulus/src/services/LocaleSettingsService.ts b/formulus/src/services/LocaleSettingsService.ts
new file mode 100644
index 000000000..fcff81596
--- /dev/null
+++ b/formulus/src/services/LocaleSettingsService.ts
@@ -0,0 +1,82 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import * as RNLocalize from 'react-native-localize';
+import {
+  resolveActiveLocale,
+  type OdeUiLocale,
+  type UiLocalePreference,
+} from '../lib/locale';
+import AppConfigService from './AppConfigService';
+
+const STORAGE_KEY = '@ode/uiLocale';
+
+export class LocaleSettingsService {
+  private static instance: LocaleSettingsService | null = null;
+
+  private preference: UiLocalePreference = 'auto';
+  private loaded = false;
+
+  static getInstance(): LocaleSettingsService {
+    if (!LocaleSettingsService.instance) {
+      LocaleSettingsService.instance = new LocaleSettingsService();
+    }
+    return LocaleSettingsService.instance;
+  }
+
+  async load(): Promise<void> {
+    if (this.loaded) return;
+    try {
+      const stored = await AsyncStorage.getItem(STORAGE_KEY);
+      if (
+        stored === 'auto' ||
+        stored === 'en' ||
+        stored === 'pt' ||
+        stored === 'fr'
+      ) {
+        this.preference = stored;
+      }
+    } catch (err) {
+      console.warn('[LocaleSettingsService] Failed to load preference:', err);
+    }
+    this.loaded = true;
+  }
+
+  getPreference(): UiLocalePreference {
+    return this.preference;
+  }
+
+  async setPreference(preference: UiLocalePreference): Promise<void> {
+    this.preference = preference;
+    this.loaded = true;
+    await AsyncStorage.setItem(STORAGE_KEY, preference);
+  }
+
+  getDeviceLocale(): string {
+    try {
+      const locales = RNLocalize.getLocales();
+      if (locales.length > 0 && locales[0]?.languageTag) {
+        return locales[0].languageTag;
+      }
+    } catch {
+      // ignore
+    }
+    return 'en';
+  }
+
+  /**
+   * Resolved catalog locale for Formplayer bridge and i18next.
+   */
+  async resolveActiveLocale(
+    sessionOverride?: string | null,
+  ): Promise<OdeUiLocale> {
+    await this.load();
+    const appConfig = await AppConfigService.getInstance().getConfig();
+    return resolveActiveLocale({
+      preference: this.preference,
+      deviceLocale: this.getDeviceLocale(),
+      bundleDefaultLocale: appConfig?.defaultLocale ?? null,
+      sessionOverride,
+    });
+  }
+}
+
+export const localeSettingsService = LocaleSettingsService.getInstance();
diff --git a/formulus/src/services/NotificationService.ts b/formulus/src/services/NotificationService.ts
index bb8cde3e1..8aba6004d 100644
--- a/formulus/src/services/NotificationService.ts
+++ b/formulus/src/services/NotificationService.ts
@@ -12,6 +12,7 @@ import {
   getSyncProgressDetailsForDisplay,
   shouldShowSyncProgressCurrentItem,
 } from '../sync/syncProgressUi';
+import { i18n } from '../i18n/instance';
 
 class NotificationService {
   private syncNotificationId = 'sync_progress';
@@ -55,7 +56,7 @@ class NotificationService {
       bodyParts.length > 0
         ? bodyParts.join(' · ')
         : indeterminate
-          ? 'In progress…'
+          ? i18n.t('sync.progress.inProgress')
           : percentage != null
             ? `${percentage}%`
             : 'In progress…';
diff --git a/formulus/src/services/SyncService.ts b/formulus/src/services/SyncService.ts
index 616de538c..8c5b4371f 100644
--- a/formulus/src/services/SyncService.ts
+++ b/formulus/src/services/SyncService.ts
@@ -19,6 +19,7 @@ import {
   isNumericAppBundleVersionString,
   normalizeAppBundleVersion,
 } from '../utils/appBundleVersion';
+import { i18n } from '../i18n/instance';
 type SyncStatusCallback = (status: string) => void;
 type SyncProgressDetailCallback = (progress: SyncProgress) => void;
 
@@ -218,7 +219,7 @@ export class SyncService {
         total: 0,
         phase: 'pull_observations',
         indeterminate: true,
-        details: 'Starting…',
+        details: i18n.t('sync.progress.starting'),
       });
 
       const finalVersion = await this.withAutoLoginRetry(
@@ -240,7 +241,7 @@ export class SyncService {
         current: 1,
         total: 1,
         phase: 'push_observations',
-        details: 'Complete',
+        details: i18n.t('sync.progress.complete'),
       });
       await AsyncStorage.setItem('@last_seen_version', finalVersion.toString());
 
@@ -368,7 +369,7 @@ export class SyncService {
       current: 0,
       total: 100,
       phase: 'app_bundle',
-      details: 'Preparing download…',
+      details: i18n.t('sync.progress.preparingDownload'),
     });
 
     try {
@@ -403,7 +404,7 @@ export class SyncService {
         current: 100,
         total: 100,
         phase: 'app_bundle',
-        details: 'Complete',
+        details: i18n.t('sync.progress.complete'),
       });
 
       appEvents.emit('bundleUpdated');
diff --git a/formulus/src/services/ToastService.ts b/formulus/src/services/ToastService.ts
index afc251be0..8bffbd87a 100644
--- a/formulus/src/services/ToastService.ts
+++ b/formulus/src/services/ToastService.ts
@@ -1,4 +1,5 @@
 import { ToastAndroid, Platform, Alert } from 'react-native';
+import { i18n } from '../i18n/instance';
 
 /**
  * Cross-platform toast notification service
@@ -13,7 +14,7 @@ export class ToastService {
       ToastAndroid.show(message, ToastAndroid.SHORT);
     } else {
       // iOS fallback - could be replaced with a third-party toast library
-      Alert.alert('Info', message);
+      Alert.alert(i18n.t('common.info'), message);
     }
   }
 
@@ -25,7 +26,7 @@ export class ToastService {
       ToastAndroid.show(message, ToastAndroid.LONG);
     } else {
       // iOS fallback
-      Alert.alert('Info', message);
+      Alert.alert(i18n.t('common.info'), message);
     }
   }
 
diff --git a/formulus/src/sync/__tests__/syncProgress.test.ts b/formulus/src/sync/__tests__/syncProgress.test.ts
index c305aa494..b9e602fb1 100644
--- a/formulus/src/sync/__tests__/syncProgress.test.ts
+++ b/formulus/src/sync/__tests__/syncProgress.test.ts
@@ -3,6 +3,11 @@ import {
   syncProgressPercent,
   syncProgressPhaseTitle,
 } from '../syncProgress';
+import { ensureI18nForTests } from '../../testUtils/i18nTestSetup';
+
+beforeAll(async () => {
+  await ensureI18nForTests();
+});
 
 describe('syncProgress', () => {
   it('formats count progress', () => {
diff --git a/formulus/src/sync/__tests__/syncProgressUi.test.ts b/formulus/src/sync/__tests__/syncProgressUi.test.ts
index 796749a33..33d3ad392 100644
--- a/formulus/src/sync/__tests__/syncProgressUi.test.ts
+++ b/formulus/src/sync/__tests__/syncProgressUi.test.ts
@@ -3,16 +3,21 @@ import {
   shouldShowSyncProgressCurrentItem,
   shouldShowSyncProgressPercent,
 } from '../syncProgressUi';
+import { ensureI18nForTests } from '../../testUtils/i18nTestSetup';
+
+beforeAll(async () => {
+  await ensureI18nForTests();
+});
 
 describe('syncProgressUi', () => {
-  it('maps records to observations for pull_observations display only', () => {
+  it('passes through localized details', () => {
     expect(
       getSyncProgressDetailsForDisplay({
         phase: 'pull_observations',
         current: 0,
         total: 0,
         indeterminate: true,
-        details: '1,500 records downloaded',
+        details: '1,500 observations downloaded',
       }),
     ).toBe('1,500 observations downloaded');
   });
diff --git a/formulus/src/sync/syncProgress.ts b/formulus/src/sync/syncProgress.ts
index 303c5c924..6bee97a51 100644
--- a/formulus/src/sync/syncProgress.ts
+++ b/formulus/src/sync/syncProgress.ts
@@ -2,6 +2,8 @@
  * Shared sync progress model for observation sync, attachments, and app bundle.
  */
 
+import { i18n } from '../i18n/instance';
+
 export type SyncProgressPhase =
   | 'pull_observations'
   | 'pull_attachments'
@@ -33,7 +35,10 @@ export function formatCountProgress(done: number, total: number): string {
   if (total <= 0) {
     return '';
   }
-  return `${Math.min(done, total)} of ${total}`;
+  return i18n.t('sync.progress.countOf', {
+    current: Math.min(done, total),
+    total,
+  });
 }
 
 export function syncProgressPercent(progress: SyncProgress): number | null {
@@ -48,16 +53,16 @@ export function syncProgressPercent(progress: SyncProgress): number | null {
 export function syncProgressPhaseTitle(phase: SyncProgressPhase): string {
   switch (phase) {
     case 'pull_observations':
-      return 'Syncing observations';
+      return i18n.t('sync.progress.phase.pull_observations');
     case 'pull_attachments':
-      return 'Downloading attachments';
+      return i18n.t('sync.progress.phase.pull_attachments');
     case 'push_attachments':
-      return 'Uploading attachments';
+      return i18n.t('sync.progress.phase.push_attachments');
     case 'push_observations':
-      return 'Uploading changes';
+      return i18n.t('sync.progress.phase.push_observations');
     case 'app_bundle':
-      return 'Updating forms';
+      return i18n.t('sync.progress.phase.app_bundle');
     default:
-      return 'Syncing';
+      return i18n.t('sync.progress.phase.default');
   }
 }
diff --git a/formulus/src/sync/syncProgressUi.ts b/formulus/src/sync/syncProgressUi.ts
index 5955221db..9eb4dc7b3 100644
--- a/formulus/src/sync/syncProgressUi.ts
+++ b/formulus/src/sync/syncProgressUi.ts
@@ -1,25 +1,18 @@
 import type { SyncProgress, SyncProgressPhase } from './syncProgress';
 import { syncProgressPercent, syncProgressPhaseTitle } from './syncProgress';
+import { i18n } from '../i18n/instance';
 
 const ATTACHMENT_PHASES: SyncProgressPhase[] = [
   'pull_attachments',
   'push_attachments',
 ];
 
-/** User-facing details; maps legacy "records" copy to "observations" for pull only. */
+/** User-facing details line (already localized at report time). */
 export function getSyncProgressDetailsForDisplay(
   progress: SyncProgress,
 ): string | undefined {
   const raw = progress.details?.trim();
-  if (!raw) {
-    return undefined;
-  }
-  if (progress.phase === 'pull_observations') {
-    return raw
-      .replace(/\brecords downloaded\b/gi, 'observations downloaded')
-      .replace(/\brecords\b/gi, 'observations');
-  }
-  return raw;
+  return raw || undefined;
 }
 
 export function shouldShowSyncProgressPercent(progress: SyncProgress): boolean {
@@ -54,9 +47,9 @@ export function getSyncProgressCardTitle(
 ): string {
   if (activeOperation === 'sync_then_update') {
     if (progress.phase === 'app_bundle') {
-      return 'Syncing & updating forms';
+      return i18n.t('sync.progress.syncingAndUpdatingForms');
     }
-    return 'Syncing & updating';
+    return i18n.t('sync.progress.syncingAndUpdating');
   }
   if (activeOperation === 'update') {
     return syncProgressPhaseTitle('app_bundle');
diff --git a/formulus/src/testUtils/i18nTestSetup.ts b/formulus/src/testUtils/i18nTestSetup.ts
new file mode 100644
index 000000000..c53f37d66
--- /dev/null
+++ b/formulus/src/testUtils/i18nTestSetup.ts
@@ -0,0 +1,20 @@
+import { initReactI18next } from 'react-i18next';
+import en from '../locales/en.json';
+import { i18n } from '../i18n/instance';
+
+let initialized = false;
+
+export async function ensureI18nForTests(): Promise<void> {
+  if (initialized || i18n.isInitialized) {
+    initialized = true;
+    return;
+  }
+  await i18n.use(initReactI18next).init({
+    lng: 'en',
+    resources: { en: { translation: en } },
+    fallbackLng: 'en',
+    interpolation: { escapeValue: false },
+    compatibilityJSON: 'v4',
+  });
+  initialized = true;
+}
diff --git a/formulus/src/testUtils/mocks/reactNativeLocalize.js b/formulus/src/testUtils/mocks/reactNativeLocalize.js
new file mode 100644
index 000000000..b2301d151
--- /dev/null
+++ b/formulus/src/testUtils/mocks/reactNativeLocalize.js
@@ -0,0 +1,26 @@
+/** Jest stub for react-native-localize (Node test environment). */
+const enUs = {
+  countryCode: 'US',
+  languageTag: 'en-US',
+  languageCode: 'en',
+  isRTL: false,
+};
+
+module.exports = {
+  getLocales: () => [enUs],
+  getNumberFormatSettings: () => ({
+    decimalSeparator: '.',
+    groupingSeparator: ',',
+  }),
+  getCalendar: () => 'gregorian',
+  getCountry: () => 'US',
+  getCurrencies: () => ['USD'],
+  getTemperatureUnit: () => 'celsius',
+  getTimeZone: () => 'America/New_York',
+  uses24HourClock: () => false,
+  usesMetricSystem: () => false,
+  findBestLanguageTag: () => ({
+    languageTag: 'en-US',
+    isRTL: false,
+  }),
+};
diff --git a/formulus/src/types/AppConfig.ts b/formulus/src/types/AppConfig.ts
index c0ea5358c..d8f4c09b6 100644
--- a/formulus/src/types/AppConfig.ts
+++ b/formulus/src/types/AppConfig.ts
@@ -117,6 +117,11 @@ export interface AppConfig {
   navigation?: NavigationConfig;
   /** Local index definitions for observation queries */
   observationIndexes?: ObservationIndexDef[];
+  /**
+   * Default UI locale when device language is not in ODE catalogs (en, pt, fr).
+   * Used when Formulus Settings language is Auto.
+   */
+  defaultLocale?: string;
 }
 
 // Keep this alias exported so app-config consumers can strongly type
diff --git a/formulus/src/utils/collectLinkedFormIds.ts b/formulus/src/utils/collectLinkedFormIds.ts
new file mode 100644
index 000000000..677308804
--- /dev/null
+++ b/formulus/src/utils/collectLinkedFormIds.ts
@@ -0,0 +1,35 @@
+/** Collect linkedForm ids from a form schema (recursive). */
+export function collectLinkedFormIds(
+  schema: unknown,
+  out: Set<string> = new Set(),
+): Set<string> {
+  if (!schema || typeof schema !== 'object') return out;
+  const obj = schema as Record<string, unknown>;
+
+  if (typeof obj.linkedForm === 'string' && obj.linkedForm.trim()) {
+    out.add(obj.linkedForm.trim());
+  }
+
+  if (obj.properties && typeof obj.properties === 'object') {
+    for (const val of Object.values(
+      obj.properties as Record<string, unknown>,
+    )) {
+      collectLinkedFormIds(val, out);
+    }
+  }
+
+  if (obj.items && typeof obj.items === 'object') {
+    collectLinkedFormIds(obj.items, out);
+  }
+
+  for (const key of ['allOf', 'anyOf', 'oneOf'] as const) {
+    const branch = obj[key];
+    if (Array.isArray(branch)) {
+      for (const sub of branch) {
+        collectLinkedFormIds(sub, out);
+      }
+    }
+  }
+
+  return out;
+}
diff --git a/formulus/src/webview/FormulusInterfaceDefinition.ts b/formulus/src/webview/FormulusInterfaceDefinition.ts
index 3be0c2205..d149227a6 100644
--- a/formulus/src/webview/FormulusInterfaceDefinition.ts
+++ b/formulus/src/webview/FormulusInterfaceDefinition.ts
@@ -41,7 +41,7 @@ export interface ExtensionMetadata {
  * Data passed to the Formulus app when a form is initialized
  * @property {string} formType - The form type (e.g. 'form1')
  * @property {string | null} observationId - The observation ID (generated by the database on first form submission). NULL if this is a new form.
- * @property {Record<string, unknown>} params - Host parameters for the formplayer WebView. Put **field prefills** in `params.defaultData` (a plain object). Top-level keys are reserved for bridge/UI: `defaultData`, `theme`, `darkMode`, `themeColors` (and any future keys added to the formplayer allowlist)—do not rely on those being stored on the observation. If `defaultData` is omitted, legacy behavior copies every other top-level key as prefill data (still excluding the reserved keys above). On load and submit, when the JSON Schema has non-empty root `properties`, the formplayer keeps only those property keys plus `locale` so polluted rows are cleaned on re-save.
+ * @property {Record<string, unknown>} params - Host parameters for the formplayer WebView. Put **field prefills** in `params.defaultData` (a plain object). Top-level keys are reserved for bridge/UI: `defaultData`, `theme`, `darkMode`, `themeColors`, `locale` (active UI language), `context` (session context)—do not rely on those being stored on the observation. If `defaultData` is omitted, legacy behavior copies every other top-level key as prefill data (still excluding the reserved keys above). On load and submit, when the JSON Schema has non-empty root `properties`, the formplayer keeps only those property keys plus optional observation metadata keys such as schema-declared `locale`.
  * @property {Record<string, unknown>} savedData - Previously saved form data (for editing)
  * @property {any} [formSchema] - JSON Schema for the form structure and validation (optional)
  * @property {any} [uiSchema] - UI Schema for form rendering layout (optional)
@@ -67,6 +67,17 @@ export interface FormInitData {
     custom_types: Record<string, { source: string }>;
     validators?: Record<string, { source: string }>;
   };
+  /**
+   * Linked child form specs for sub-observation column label resolution.
+   * Keys are form type ids (`linkedForm` values). Populated by Formulus at open time.
+   */
+  linkedFormSpecs?: Record<
+    string,
+    {
+      schema: unknown;
+      uiSchema: unknown;
+    }
+  >;
 }
 
 /**
diff --git a/formulus/src/webview/FormulusMessageHandlers.ts b/formulus/src/webview/FormulusMessageHandlers.ts
index 72ae442f9..8efb1a1c5 100644
--- a/formulus/src/webview/FormulusMessageHandlers.ts
+++ b/formulus/src/webview/FormulusMessageHandlers.ts
@@ -10,6 +10,7 @@ import RNFS from 'react-native-fs';
 import * as Keychain from 'react-native-keychain';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { Alert, Platform } from 'react-native';
+import { i18n } from '../i18n/instance';
 import * as ImagePicker from 'react-native-image-picker';
 import {
   check,
@@ -474,48 +475,55 @@ export function createFormulusMessageHandlers(): FormulusMessageHandlers {
           };
 
           // Show action sheet with camera and gallery options
-          Alert.alert('Select Image', 'Choose an option', [
-            {
-              text: 'Camera',
-              onPress: () => {
-                void (async () => {
-                  const perm = await ensureCameraPermission();
-                  if (perm !== RESULTS.GRANTED) {
-                    resolve({
-                      fieldId,
-                      status: 'error',
-                      message:
-                        perm === RESULTS.BLOCKED
-                          ? 'Camera access is blocked. Enable camera permission in system settings.'
-                          : 'Camera permission is required to take a photo.',
-                    });
-                    return;
-                  }
-                  ImagePicker.launchCamera(options, handleImagePickerResponse);
-                })();
+          Alert.alert(
+            i18n.t('media.selectImageTitle'),
+            i18n.t('media.selectImageMessage'),
+            [
+              {
+                text: i18n.t('media.camera'),
+                onPress: () => {
+                  void (async () => {
+                    const perm = await ensureCameraPermission();
+                    if (perm !== RESULTS.GRANTED) {
+                      resolve({
+                        fieldId,
+                        status: 'error',
+                        message:
+                          perm === RESULTS.BLOCKED
+                            ? 'Camera access is blocked. Enable camera permission in system settings.'
+                            : 'Camera permission is required to take a photo.',
+                      });
+                      return;
+                    }
+                    ImagePicker.launchCamera(
+                      options,
+                      handleImagePickerResponse,
+                    );
+                  })();
+                },
               },
-            },
-            {
-              text: 'Gallery',
-              onPress: () => {
-                ImagePicker.launchImageLibrary(
-                  options,
-                  handleImagePickerResponse,
-                );
+              {
+                text: i18n.t('media.gallery'),
+                onPress: () => {
+                  ImagePicker.launchImageLibrary(
+                    options,
+                    handleImagePickerResponse,
+                  );
+                },
               },
-            },
-            {
-              text: 'Cancel',
-              style: 'cancel',
-              onPress: () => {
-                resolve({
-                  fieldId,
-                  status: 'cancelled',
-                  message: 'Image selection cancelled by user',
-                });
+              {
+                text: i18n.t('common.cancel'),
+                style: 'cancel',
+                onPress: () => {
+                  resolve({
+                    fieldId,
+                    status: 'cancelled',
+                    message: 'Image selection cancelled by user',
+                  });
+                },
               },
-            },
-          ]);
+            ],
+          );
         } catch (error) {
           console.error('Error in native camera handler:', error);
           const errorMessage =