diff --git a/README.md b/README.md
index 7737bd9..5a10a31 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,7 @@
 | [docs/03-roadmap.md](docs/03-roadmap.md) | Lộ trình theo phase, mục tiêu, phương pháp, định nghĩa hoàn thành (DoD) |
 | [docs/04-architecture.md](docs/04-architecture.md) | Kiến trúc kỹ thuật chi tiết (sẽ chi tiết hóa dần) |
 | [docs/14-foxit-gap-analysis.md](docs/14-foxit-gap-analysis.md) | Đánh giá định hướng/công nghệ/tiến độ so với tham vọng thay Foxit; các khoảng cách còn lại + giải pháp |
+| [docs/17-phase6-summary.md](docs/17-phase6-summary.md) | Tổng kết Phase 6 (Form/AcroForm) |
 
 ## Trạng thái hiện tại
 
@@ -48,7 +49,12 @@
   - [x] UI thanh "🔒 Bảo mật": redact 2 bước như Foxit, Đặt/Gỡ mật khẩu + quyền, Xoá metadata, **Tạo Digital ID / Ký số / Kiểm tra chữ ký / Lưu tối ưu**
   - [ ] Về sau: timestamp PAdES-T/LTV, đọc PFX/PKCS#12, multi-sig incremental — xem [docs/15-phase5-summary.md](docs/15-phase5-summary.md) mục 6.6
   - **Checklist test cho bạn**: [docs/16-phase5-user-tests.md](docs/16-phase5-user-tests.md) (mới: S13–S19)
-- [ ] **Phase 6 — Form (AcroForm)** (kế tiếp) — xem [docs/03-roadmap.md](docs/03-roadmap.md)
+- [x] **Phase 6 — Form (AcroForm)** ✅ lõi hoàn tất (67/67 test engine xanh)
+  - [x] Engine `form.rs`: liệt kê field (text/checkbox/radio/combo/list), điền (giữ tiếng Việt qua UTF-16BE + NeedAppearances), tạo field mới (text/checkbox/combo), flatten (PDFium), export/import **FDF** + export **CSV** — round-trip test
+  - [x] UI thanh "📝 Form": Điền form (modal liệt kê field theo loại), Thêm field, Flatten, Xuất FDF/CSV, Nhập FDF
+  - [ ] Follow-up: radio-group/list/pushbutton khi tạo, XFDF, vẽ appearance riêng, điền overlay trực tiếp trên trang — xem [docs/17-phase6-summary.md](docs/17-phase6-summary.md)
+  - **Checklist test cho bạn**: [docs/18-phase6-user-tests.md](docs/18-phase6-user-tests.md)
+- [ ] **Phase 7 — OCR & Convert** (kế tiếp) — xem [docs/03-roadmap.md](docs/03-roadmap.md)
 
 Build & chạy: xem [docs/05-dev-setup.md](docs/05-dev-setup.md).
 
diff --git a/app/src-tauri/Cargo.lock b/app/src-tauri/Cargo.lock
index 031593a..c045219 100644
--- a/app/src-tauri/Cargo.lock
+++ b/app/src-tauri/Cargo.lock
@@ -1161,6 +1161,7 @@ dependencies = [
  "base64 0.22.1",
  "ff-engine",
  "image",
+ "lopdf",
  "pdfium-render",
  "serde",
  "serde_json",
diff --git a/app/src-tauri/Cargo.toml b/app/src-tauri/Cargo.toml
index ae91d47..8943cd4 100644
--- a/app/src-tauri/Cargo.toml
+++ b/app/src-tauri/Cargo.toml
@@ -19,6 +19,7 @@ serde_json = "1"
 base64 = "0.22"
 image = "0.25"
 pdfium-render = "0.8"
+lopdf = "0.36"
 ff-engine = { path = "../../crates/ff-engine" }
 
 [profile.release]
diff --git a/app/src-tauri/src/main.rs b/app/src-tauri/src/main.rs
index 7a7d1d2..36f2cc6 100644
--- a/app/src-tauri/src/main.rs
+++ b/app/src-tauri/src/main.rs
@@ -1006,6 +1006,181 @@ fn pick_any_file(app: tauri::AppHandle) -> Option<String> {
     app.dialog().file().blocking_pick_file().map(|fp| fp.to_string())
 }
 
+// ---------- Phase 6: Form (AcroForm) ----------
+
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+struct FormFieldDto {
+    name: String,
+    kind: String,
+    value: Option<String>,
+    page_index: Option<u16>,
+    rect: Option<[f32; 4]>,
+    on_state: Option<String>,
+    options: Vec<String>,
+    read_only: bool,
+}
+
+/// Liệt kê field của form. Chuẩn hoá qua qpdf nếu lopdf không đọc thẳng được.
+#[tauri::command]
+fn form_list(path: String) -> Result<Vec<FormFieldDto>, String> {
+    let p = std::path::Path::new(&path);
+    let fields = match ff_engine::list_form_fields(p) {
+        Ok(f) => f,
+        Err(_) => {
+            let norm = std::env::temp_dir().join(format!("ff_form_norm_{}.pdf", std::process::id()));
+            ff_engine::repair(p, &norm).map_err(|e| e.to_string())?;
+            let r = ff_engine::list_form_fields(&norm).map_err(|e| e.to_string());
+            let _ = std::fs::remove_file(&norm);
+            r?
+        }
+    };
+    Ok(fields
+        .into_iter()
+        .map(|f| FormFieldDto {
+            name: f.name,
+            kind: f.kind.as_str().to_string(),
+            value: f.value,
+            page_index: f.page_index,
+            rect: f.rect,
+            on_state: f.on_state,
+            options: f.options,
+            read_only: f.read_only,
+        })
+        .collect())
+}
+
+#[derive(serde::Deserialize)]
+struct FieldValueDto {
+    name: String,
+    value: String,
+}
+
+/// Chuẩn hoá input qua qpdf (lopdf cần trailer chuẩn) rồi trả path dùng được.
+fn normalized_for_lopdf(input: &str) -> Result<(std::path::PathBuf, Option<std::path::PathBuf>), String> {
+    let p = std::path::PathBuf::from(input);
+    if lopdf::Document::load(&p).is_ok() {
+        return Ok((p, None));
+    }
+    let norm = std::env::temp_dir().join(format!("ff_form_in_{}.pdf", std::process::id()));
+    ff_engine::repair(&p, &norm).map_err(|e| e.to_string())?;
+    Ok((norm.clone(), Some(norm)))
+}
+
+/// Điền form theo danh sách (tên, giá trị), ghi ra `output`.
+#[tauri::command]
+fn form_fill(input: String, values: Vec<FieldValueDto>, output: String) -> Result<usize, String> {
+    let (src, tmp) = normalized_for_lopdf(&input)?;
+    let vals: Vec<ff_engine::FieldValue> = values
+        .into_iter()
+        .map(|v| ff_engine::FieldValue { name: v.name, value: v.value })
+        .collect();
+    let r = ff_engine::fill_form_fields(&src, &vals, std::path::Path::new(&output))
+        .map_err(|e| e.to_string());
+    if let Some(t) = tmp {
+        let _ = std::fs::remove_file(t);
+    }
+    r
+}
+
+/// Flatten form (in giá trị vào trang, bỏ tương tác).
+#[tauri::command]
+fn form_flatten(input: String, output: String, password: Option<String>) -> Result<(), String> {
+    let pdfium = pdfium()?;
+    ff_engine::flatten_form(
+        &pdfium,
+        std::path::Path::new(&input),
+        std::path::Path::new(&output),
+        password.as_deref(),
+    )
+    .map_err(|e| e.to_string())
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct NewFieldDto {
+    name: String,
+    kind: String,
+    page_index: u16,
+    rect: [f32; 4],
+    #[serde(default)]
+    value: String,
+    #[serde(default)]
+    options: Vec<String>,
+}
+
+/// Tạo field mới (text/checkbox/combo).
+#[tauri::command]
+fn form_create(input: String, fields: Vec<NewFieldDto>, output: String) -> Result<(), String> {
+    let (src, tmp) = normalized_for_lopdf(&input)?;
+    let mapped: Vec<ff_engine::NewField> = fields
+        .into_iter()
+        .map(|f| ff_engine::NewField {
+            name: f.name,
+            kind: match f.kind.as_str() {
+                "checkbox" => ff_engine::FieldKind::Checkbox,
+                "combo" => ff_engine::FieldKind::Combo,
+                _ => ff_engine::FieldKind::Text,
+            },
+            page_index: f.page_index,
+            rect: f.rect,
+            value: f.value,
+            options: f.options,
+        })
+        .collect();
+    let r = ff_engine::create_form_fields(&src, &mapped, std::path::Path::new(&output))
+        .map_err(|e| e.to_string());
+    if let Some(t) = tmp {
+        let _ = std::fs::remove_file(t);
+    }
+    r
+}
+
+/// Xuất dữ liệu form ra FDF hoặc CSV theo phần mở rộng của `output`.
+#[tauri::command]
+fn form_export(input: String, output: String) -> Result<(), String> {
+    let p = std::path::Path::new(&output);
+    let inp = std::path::Path::new(&input);
+    if output.to_lowercase().ends_with(".csv") {
+        ff_engine::export_csv(inp, p).map_err(|e| e.to_string())
+    } else {
+        ff_engine::export_fdf(inp, p).map_err(|e| e.to_string())
+    }
+}
+
+/// Import FDF vào form, ghi ra `output`.
+#[tauri::command]
+fn form_import_fdf(input: String, fdf: String, output: String) -> Result<usize, String> {
+    let (src, tmp) = normalized_for_lopdf(&input)?;
+    let r = ff_engine::import_fdf(&src, std::path::Path::new(&fdf), std::path::Path::new(&output))
+        .map_err(|e| e.to_string());
+    if let Some(t) = tmp {
+        let _ = std::fs::remove_file(t);
+    }
+    r
+}
+
+/// Hộp thoại lưu file FDF.
+#[tauri::command]
+fn pick_save_data(app: tauri::AppHandle) -> Option<String> {
+    app.dialog()
+        .file()
+        .add_filter("Dữ liệu form", &["fdf", "csv"])
+        .set_file_name("form-data.fdf")
+        .blocking_save_file()
+        .map(|fp| fp.to_string())
+}
+
+/// Hộp thoại chọn file FDF để import.
+#[tauri::command]
+fn pick_fdf(app: tauri::AppHandle) -> Option<String> {
+    app.dialog()
+        .file()
+        .add_filter("FDF", &["fdf"])
+        .blocking_pick_file()
+        .map(|fp| fp.to_string())
+}
+
 /// Hộp thoại lưu file PEM (Digital ID).
 #[tauri::command]
 fn pick_save_pem(app: tauri::AppHandle) -> Option<String> {
@@ -1085,8 +1260,16 @@ fn main() {
             sig_create_id,
             sig_sign,
             sig_verify,
+            form_list,
+            form_fill,
+            form_flatten,
+            form_create,
+            form_export,
+            form_import_fdf,
             pick_any_file,
             pick_save_pem,
+            pick_save_data,
+            pick_fdf,
             pick_image
         ])
         .run(tauri::generate_context!())
diff --git a/app/src/index.html b/app/src/index.html
index 77e1856..b1f1c6c 100644
--- a/app/src/index.html
+++ b/app/src/index.html
@@ -36,6 +36,7 @@
       <span class="sep"></span>
       <button id="organizeModeBtn" title="Tổ chức trang">🗂 Tổ chức trang</button>
       <button id="editModeBtn" title="Sửa nội dung trang">✏️ Sửa nội dung</button>
+      <button id="formModeBtn" title="Form: điền, tạo field, flatten, FDF/CSV">📝 Form</button>
       <button id="secModeBtn" title="Bảo mật: redact, mật khẩu, metadata">🔒 Bảo mật</button>
       <div class="spacer"></div>
       <span id="status" class="status"></span>
@@ -103,6 +104,19 @@
       <button id="edSave" disabled>💾 Lưu thay đổi nội dung</button>
     </div>
 
+    <div id="formBar" class="editbar hidden">
+      <span class="annolabel">Form:</span>
+      <button id="fmFill" title="Xem & điền các field của form">📋 Điền form (<span id="fmCount">0</span>)</button>
+      <button id="fmCreate" title="Thêm field mới (text/checkbox/combo)">➕ Thêm field</button>
+      <button id="fmFlatten" title="In giá trị vào trang, bỏ tính tương tác">🧷 Flatten</button>
+      <span class="sep"></span>
+      <button id="fmExportFdf" title="Xuất dữ liệu form ra FDF">⬆ Xuất FDF</button>
+      <button id="fmExportCsv" title="Xuất dữ liệu form ra CSV">⬆ Xuất CSV</button>
+      <button id="fmImportFdf" title="Nhập dữ liệu form từ FDF">⬇ Nhập FDF</button>
+      <span class="spacer"></span>
+      <span id="formHint" class="status"></span>
+    </div>
+
     <div id="secBar" class="editbar hidden">
       <span class="annolabel">Bảo mật:</span>
       <button id="secRedactTool" class="atool" data-tool="redact" title="Kéo chuột trên trang để đánh dấu vùng cần bôi đen — nội dung bị XOÁ THẬT khi áp dụng">⬛ Đánh dấu redact</button>
diff --git a/app/src/main.js b/app/src/main.js
index 17e150b..9a1fcd7 100644
--- a/app/src/main.js
+++ b/app/src/main.js
@@ -41,6 +41,8 @@ const state = {
   editTemps: [],          // mọi file tạm đã materialize trong phiên sửa (để dọn)
   secMode: false,         // thanh Bảo mật (Phase 5) đang mở
   redactMarks: [],        // [{page, rect{left,bottom,right,top}}] chờ áp dụng
+  formMode: false,        // thanh Form (Phase 6) đang mở
+  formFields: [],         // field đọc từ tài liệu hiện tại
 };
 const UNDO_LIMIT = 50;
 let annotIdSeq = 1;
@@ -75,6 +77,7 @@ async function loadDocument(path) {
     state.redoStack = [];
     state.redactMarks = [];
     updateRedactButtons();
+    state.formFields = [];
     updateUndoRedoButtons();
     setTool(null);
     updateAnnotCount();
@@ -2675,6 +2678,189 @@ async function saveEdits() {
   }
 }
 
+// ---------- Phase 6: Form (AcroForm) ----------
+
+function toggleFormMode() {
+  state.formMode = !state.formMode;
+  $("formBar").classList.toggle("hidden", !state.formMode);
+  $("formModeBtn").classList.toggle("active", state.formMode);
+  $("formHint").textContent = "";
+  if (state.formMode) refreshFormCount();
+}
+
+async function refreshFormCount() {
+  try {
+    const fields = await invoke("form_list", { path: state.path });
+    state.formFields = fields;
+    $("fmCount").textContent = fields.length;
+    $("formHint").textContent = fields.length
+      ? `${fields.length} field trong tài liệu`
+      : "Tài liệu chưa có field form — dùng “Thêm field”.";
+  } catch (e) {
+    $("formHint").textContent = "Lỗi đọc form: " + e;
+  }
+}
+
+// Modal liệt kê field + input để điền, nút Lưu.
+async function openFillForm() {
+  let fields;
+  try {
+    fields = await invoke("form_list", { path: state.path });
+  } catch (e) {
+    $("formHint").textContent = "Lỗi đọc form: " + e;
+    return;
+  }
+  if (!fields.length) {
+    openModal("Điền form", `<p class="muted">Tài liệu chưa có field form nào. Hãy dùng “➕ Thêm field”.</p>
+      <div class="foot"><button id="ffClose" class="primary">Đóng</button></div>`)
+      .querySelector("#ffClose").addEventListener("click", closeModal);
+    return;
+  }
+  const rows = fields
+    .map((f, i) => {
+      const label = `${escapeHtml(f.name)} <span class="muted">(${f.kind}${f.pageIndex != null ? `, trang ${f.pageIndex + 1}` : ""})</span>`;
+      let input;
+      if (f.kind === "checkbox" || f.kind === "radio") {
+        const on = f.value && f.value !== "Off";
+        input = `<input type="checkbox" id="ffv${i}" ${on ? "checked" : ""} ${f.readOnly ? "disabled" : ""}>`;
+      } else if ((f.kind === "combo" || f.kind === "list") && f.options.length) {
+        const opts = f.options
+          .map((o) => `<option ${o === f.value ? "selected" : ""}>${escapeHtml(o)}</option>`)
+          .join("");
+        input = `<select id="ffv${i}" ${f.readOnly ? "disabled" : ""}><option value=""></option>${opts}</select>`;
+      } else {
+        input = `<input type="text" id="ffv${i}" value="${escapeHtml(f.value || "")}" ${f.readOnly ? "disabled" : ""}>`;
+      }
+      return `<tr><td>${label}</td><td>${input}</td></tr>`;
+    })
+    .join("");
+  const box = openModal("Điền form", `
+    <table class="form-table"><tbody>${rows}</tbody></table>
+    <div class="err" id="ffErr"></div>
+    <div class="foot"><button id="ffCancel">Huỷ</button><button id="ffOk" class="primary">Lưu &amp; áp dụng…</button></div>
+  `);
+  box.querySelector("#ffCancel").addEventListener("click", closeModal);
+  box.querySelector("#ffOk").addEventListener("click", async () => {
+    const values = fields.map((f, i) => {
+      const el = box.querySelector(`#ffv${i}`);
+      let value;
+      if (f.kind === "checkbox" || f.kind === "radio") value = el.checked ? "on" : "off";
+      else value = el.value;
+      return { name: f.name, value };
+    });
+    const out = await invoke("pick_save_pdf");
+    if (!out) return;
+    try {
+      const n = await invoke("form_fill", { input: state.path, values, output: out });
+      closeModal();
+      $("status").textContent = `Đã điền ${n} field → ${shortName(out)}`;
+      loadDocument(out);
+    } catch (e) {
+      box.querySelector("#ffErr").textContent = "Lỗi: " + e;
+    }
+  });
+}
+
+function openCreateFieldDialog() {
+  const box = openModal("Thêm field mới", `
+    <label>Tên field</label>
+    <input type="text" id="nfName" placeholder="hoTen">
+    <label>Loại</label>
+    <select id="nfKind">
+      <option value="text">Text (ô nhập chữ)</option>
+      <option value="checkbox">Checkbox</option>
+      <option value="combo">Combo box (chọn 1)</option>
+    </select>
+    <div class="row">
+      <div><label>Trang</label><input type="number" id="nfPage" value="1" min="1"></div>
+      <div><label>Cỡ (rộng×cao pt)</label><input type="text" id="nfSize" value="200x20"></div>
+    </div>
+    <div class="row">
+      <div><label>Vị trí X (pt)</label><input type="number" id="nfX" value="80"></div>
+      <div><label>Vị trí Y từ đáy (pt)</label><input type="number" id="nfY" value="700"></div>
+    </div>
+    <label id="nfOptLabel" class="hidden">Lựa chọn (cách nhau dấu phẩy)</label>
+    <input type="text" id="nfOpts" class="hidden" placeholder="Nam, Nữ, Khác">
+    <div class="err" id="nfErr"></div>
+    <div class="foot"><button id="nfCancel">Huỷ</button><button id="nfOk" class="primary">Tạo &amp; lưu…</button></div>
+  `);
+  const kindSel = box.querySelector("#nfKind");
+  const toggleOpts = () => {
+    const isCombo = kindSel.value === "combo";
+    box.querySelector("#nfOptLabel").classList.toggle("hidden", !isCombo);
+    box.querySelector("#nfOpts").classList.toggle("hidden", !isCombo);
+  };
+  kindSel.addEventListener("change", toggleOpts);
+  box.querySelector("#nfCancel").addEventListener("click", closeModal);
+  box.querySelector("#nfOk").addEventListener("click", async () => {
+    const name = box.querySelector("#nfName").value.trim();
+    const err = box.querySelector("#nfErr");
+    if (!name) { err.textContent = "Cần nhập tên field."; return; }
+    const kind = kindSel.value;
+    const page = Math.max(1, Number(box.querySelector("#nfPage").value) || 1) - 1;
+    const m = box.querySelector("#nfSize").value.match(/^\s*(\d+)\s*[x×]\s*(\d+)\s*$/);
+    if (!m) { err.textContent = "Cỡ phải dạng rộng×cao, vd 200x20."; return; }
+    const w = Number(m[1]), h = Number(m[2]);
+    const x = Number(box.querySelector("#nfX").value) || 0;
+    const y = Number(box.querySelector("#nfY").value) || 0;
+    const options = kind === "combo"
+      ? box.querySelector("#nfOpts").value.split(",").map((s) => s.trim()).filter(Boolean)
+      : [];
+    const field = { name, kind, pageIndex: page, rect: [x, y, x + w, y + h], value: "", options };
+    const out = await invoke("pick_save_pdf");
+    if (!out) return;
+    try {
+      await invoke("form_create", { input: state.path, fields: [field], output: out });
+      closeModal();
+      $("status").textContent = `Đã tạo field “${name}” → ${shortName(out)}`;
+      loadDocument(out);
+    } catch (e) {
+      err.textContent = "Lỗi: " + e;
+    }
+  });
+}
+
+async function flattenFormAction() {
+  const out = await invoke("pick_save_pdf");
+  if (!out) return;
+  try {
+    await invoke("form_flatten", { input: state.path, output: out, password: null });
+    $("status").textContent = `Đã flatten form → ${shortName(out)}`;
+    loadDocument(out);
+  } catch (e) {
+    $("formHint").textContent = "Lỗi flatten: " + e;
+  }
+}
+
+async function exportFormData(kind) {
+  const out = await invoke("pick_save_data");
+  if (!out) return;
+  // Đảm bảo đúng đuôi theo lựa chọn.
+  let target = out;
+  if (kind === "csv" && !/\.csv$/i.test(target)) target = target.replace(/\.[^.]*$/, "") + ".csv";
+  if (kind === "fdf" && !/\.fdf$/i.test(target)) target = target.replace(/\.[^.]*$/, "") + ".fdf";
+  try {
+    await invoke("form_export", { input: state.path, output: target });
+    $("formHint").textContent = `Đã xuất dữ liệu form → ${shortName(target)}`;
+  } catch (e) {
+    $("formHint").textContent = "Lỗi xuất: " + e;
+  }
+}
+
+async function importFormFdf() {
+  const fdf = await invoke("pick_fdf");
+  if (!fdf) return;
+  const out = await invoke("pick_save_pdf");
+  if (!out) return;
+  try {
+    const n = await invoke("form_import_fdf", { input: state.path, fdf, output: out });
+    $("status").textContent = `Đã nhập ${n} field từ FDF → ${shortName(out)}`;
+    loadDocument(out);
+  } catch (e) {
+    $("formHint").textContent = "Lỗi nhập FDF: " + e;
+  }
+}
+
 // ---------- Phase 5: Bảo mật (redact / mật khẩu / metadata) ----------
 
 function toggleSecMode() {
@@ -3039,6 +3225,15 @@ $("modalOverlay").addEventListener("click", (e) => {
   if (e.target.id === "modalOverlay") closeModal();
 });
 
+// Form (Phase 6)
+$("formModeBtn").addEventListener("click", toggleFormMode);
+$("fmFill").addEventListener("click", openFillForm);
+$("fmCreate").addEventListener("click", openCreateFieldDialog);
+$("fmFlatten").addEventListener("click", flattenFormAction);
+$("fmExportFdf").addEventListener("click", () => exportFormData("fdf"));
+$("fmExportCsv").addEventListener("click", () => exportFormData("csv"));
+$("fmImportFdf").addEventListener("click", importFormFdf);
+
 // Bảo mật (Phase 5)
 $("secModeBtn").addEventListener("click", toggleSecMode);
 $("secRedactApply").addEventListener("click", applyRedactions);
diff --git a/app/src/styles.css b/app/src/styles.css
index 7e9f5b1..eea8d90 100644
--- a/app/src/styles.css
+++ b/app/src/styles.css
@@ -413,6 +413,12 @@ body.tool-active .annotlayer * { pointer-events: none; }
   box-sizing: content-box;
 }
 
+/* Bảng điền form (Phase 6) */
+.form-table { width: 100%; border-collapse: collapse; margin: 4px 0 12px; }
+.form-table td { padding: 5px 8px; border-bottom: 1px solid var(--border, #ddd); font-size: 13px; vertical-align: middle; }
+.form-table td:first-child { width: 55%; }
+.form-table input[type="text"], .form-table select { width: 100%; box-sizing: border-box; }
+
 /* Bảng kết quả kiểm tra chữ ký (Phase 5) */
 .sig-table { width: 100%; border-collapse: collapse; margin: 4px 0 12px; }
 .sig-table th, .sig-table td { text-align: left; padding: 5px 8px; border-bottom: 1px solid var(--border, #ddd); font-size: 13px; }
diff --git a/crates/ff-engine/src/form.rs b/crates/ff-engine/src/form.rs
new file mode 100644
index 0000000..2e7163f
--- /dev/null
+++ b/crates/ff-engine/src/form.rs
@@ -0,0 +1,788 @@
+//! Form AcroForm (Phase 6): liệt kê / điền / tạo field, flatten, và
+//! export/import FDF. Thao tác tầng PDF object qua `lopdf` cho phần đọc/ghi
+//! cấu trúc (đáng tin & portable), dùng PDFium chỉ để flatten.
+//!
+//! Kiểu field (khoá `/FT`):
+//! - `/Tx`  — text
+//! - `/Btn` — nút: checkbox / radio / push-button (phân biệt bằng cờ `/Ff`)
+//! - `/Ch`  — choice: combo-box / list-box
+//! - `/Sig` — chữ ký (xử lý ở `sign.rs`)
+//!
+//! Điền field: đặt `/V`; với checkbox/radio đặt cả `/AS` của widget về đúng
+//! tên trạng thái bật; bật `NeedAppearances=true` để viewer tự dựng lại
+//! appearance (cách portable nhất, mọi viewer hiểu).
+
+use std::collections::BTreeMap;
+use std::path::Path;
+
+use lopdf::{Dictionary, Document, Object, ObjectId};
+
+use crate::EngineError;
+
+fn le<E: std::fmt::Display>(ctx: &str) -> impl Fn(E) -> EngineError + '_ {
+    move |e| EngineError::Pdfium(format!("form {ctx}: {e}"))
+}
+
+/// Loại field rút gọn cho UI.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum FieldKind {
+    Text,
+    Checkbox,
+    Radio,
+    Combo,
+    List,
+    Button,
+    Signature,
+    Unknown,
+}
+
+impl FieldKind {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            FieldKind::Text => "text",
+            FieldKind::Checkbox => "checkbox",
+            FieldKind::Radio => "radio",
+            FieldKind::Combo => "combo",
+            FieldKind::List => "list",
+            FieldKind::Button => "button",
+            FieldKind::Signature => "signature",
+            FieldKind::Unknown => "unknown",
+        }
+    }
+}
+
+/// Thông tin 1 field cho UI.
+#[derive(Clone, Debug)]
+pub struct FormField {
+    /// Tên đầy đủ (fully-qualified) của field.
+    pub name: String,
+    pub kind: FieldKind,
+    /// Giá trị hiện tại (text; hoặc tên trạng thái bật của checkbox/radio).
+    pub value: Option<String>,
+    /// Trang chứa widget đầu tiên (0-based) nếu xác định được.
+    pub page_index: Option<u16>,
+    /// Khung widget đầu tiên [left, bottom, right, top] (điểm PDF).
+    pub rect: Option<[f32; 4]>,
+    /// Với checkbox/radio: tên trạng thái BẬT (để đặt /V và /AS khi tick).
+    pub on_state: Option<String>,
+    /// Với combo/list: các lựa chọn.
+    pub options: Vec<String>,
+    pub read_only: bool,
+}
+
+fn bit(flags: i64, i: u32) -> bool {
+    flags & (1 << (i - 1)) != 0
+}
+
+/// Bản đồ ObjectId của widget → chỉ số trang (0-based), dựng từ /Annots mỗi trang.
+fn widget_page_map(doc: &Document) -> BTreeMap<ObjectId, u16> {
+    let mut map = BTreeMap::new();
+    for (page_no, page_id) in doc.get_pages() {
+        if let Ok(page) = doc.get_object(page_id).and_then(Object::as_dict) {
+            if let Ok(annots) = page.get(b"Annots").and_then(Object::as_array) {
+                for a in annots {
+                    if let Ok(id) = a.as_reference() {
+                        map.insert(id, (page_no - 1) as u16);
+                    }
+                }
+            }
+        }
+    }
+    map
+}
+
+fn text_of(obj: &Object) -> Option<String> {
+    match obj {
+        Object::String(bytes, _) => Some(decode_pdf_text(bytes)),
+        Object::Name(bytes) => Some(String::from_utf8_lossy(bytes).into_owned()),
+        _ => None,
+    }
+}
+
+/// Giải mã chuỗi text PDF: UTF-16BE (BOM FE FF) hoặc PDFDocEncoding≈Latin-1.
+fn decode_pdf_text(bytes: &[u8]) -> String {
+    if bytes.len() >= 2 && bytes[0] == 0xFE && bytes[1] == 0xFF {
+        let u16s: Vec<u16> = bytes[2..]
+            .chunks_exact(2)
+            .map(|c| u16::from_be_bytes([c[0], c[1]]))
+            .collect();
+        String::from_utf16_lossy(&u16s)
+    } else {
+        bytes.iter().map(|&b| b as char).collect()
+    }
+}
+
+/// Mã hoá chuỗi thành text PDF: ASCII → literal; có ký tự ngoài Latin-1 →
+/// UTF-16BE (để tiếng Việt/CJK đúng).
+fn encode_pdf_text(s: &str) -> Object {
+    if s.chars().all(|c| (c as u32) < 128) {
+        Object::string_literal(s.to_string())
+    } else {
+        let mut bytes = vec![0xFE, 0xFF];
+        for u in s.encode_utf16() {
+            bytes.extend_from_slice(&u.to_be_bytes());
+        }
+        Object::String(bytes, lopdf::StringFormat::Hexadecimal)
+    }
+}
+
+/// Kiểu + trạng thái bật (on-state) của 1 field, suy từ /FT, /Ff và các /AP.
+fn classify(doc: &Document, dict: &Dictionary) -> (FieldKind, Option<String>) {
+    let ft = dict.get(b"FT").and_then(Object::as_name).ok().map(|n| n.to_vec());
+    let ft = ft.as_deref();
+    let flags = dict.get(b"Ff").and_then(Object::as_i64).unwrap_or(0);
+    match ft {
+        Some(b"Tx") => (FieldKind::Text, None),
+        Some(b"Btn") => {
+            if bit(flags, 17) {
+                (FieldKind::Button, None) // pushbutton
+            } else if bit(flags, 16) {
+                (FieldKind::Radio, on_state(doc, dict))
+            } else {
+                (FieldKind::Checkbox, on_state(doc, dict))
+            }
+        }
+        Some(b"Ch") => {
+            if bit(flags, 18) {
+                (FieldKind::Combo, None)
+            } else {
+                (FieldKind::List, None)
+            }
+        }
+        Some(b"Sig") => (FieldKind::Signature, None),
+        _ => (FieldKind::Unknown, None),
+    }
+}
+
+/// Tên trạng thái BẬT của checkbox/radio: khoá khác "Off" trong /AP /N.
+fn on_state(doc: &Document, dict: &Dictionary) -> Option<String> {
+    // Widget có thể là chính field, hoặc nằm trong /Kids.
+    let widget = if dict.has(b"AP") {
+        Some(dict)
+    } else {
+        dict.get(b"Kids")
+            .and_then(Object::as_array)
+            .ok()
+            .and_then(|kids| kids.first())
+            .and_then(|k| k.as_reference().ok())
+            .and_then(|id| doc.get_object(id).and_then(Object::as_dict).ok())
+    }?;
+    let ap = widget.get(b"AP").and_then(Object::as_dict).ok()?;
+    let n = ap.get(b"N").and_then(Object::as_dict).ok()?;
+    n.iter()
+        .map(|(k, _)| String::from_utf8_lossy(k).into_owned())
+        .find(|k| k != "Off")
+}
+
+fn field_rect(doc: &Document, dict: &Dictionary) -> Option<[f32; 4]> {
+    let src = if dict.has(b"Rect") {
+        Some(dict)
+    } else {
+        dict.get(b"Kids")
+            .and_then(Object::as_array)
+            .ok()
+            .and_then(|kids| kids.first())
+            .and_then(|k| k.as_reference().ok())
+            .and_then(|id| doc.get_object(id).and_then(Object::as_dict).ok())
+    }?;
+    let arr = src.get(b"Rect").and_then(Object::as_array).ok()?;
+    if arr.len() != 4 {
+        return None;
+    }
+    let v: Vec<f32> = arr.iter().filter_map(|o| o.as_float().ok().or_else(|| o.as_i64().ok().map(|i| i as f32))).collect();
+    if v.len() != 4 {
+        return None;
+    }
+    // Chuẩn hoá left<right, bottom<top.
+    Some([v[0].min(v[2]), v[1].min(v[3]), v[0].max(v[2]), v[1].max(v[3])])
+}
+
+fn field_page(_doc: &Document, dict: &Dictionary, wmap: &BTreeMap<ObjectId, u16>, self_id: ObjectId) -> Option<u16> {
+    // Nếu field TỰ là widget (có trong wmap).
+    if let Some(p) = wmap.get(&self_id) {
+        return Some(*p);
+    }
+    // Widget con.
+    let kids = dict.get(b"Kids").and_then(Object::as_array).ok()?;
+    for k in kids {
+        if let Ok(id) = k.as_reference() {
+            if let Some(p) = wmap.get(&id) {
+                return Some(*p);
+            }
+        }
+    }
+    None
+}
+
+/// Duyệt cây field (đệ quy /Kids là field con — phân biệt widget con bằng việc
+/// KHÔNG có /FT riêng và có /Rect). Trả (ObjectId, tên đầy đủ, dict).
+fn collect_fields(doc: &Document) -> Vec<(ObjectId, String, Dictionary)> {
+    fn walk(
+        doc: &Document,
+        id: ObjectId,
+        prefix: &str,
+        out: &mut Vec<(ObjectId, String, Dictionary)>,
+    ) {
+        let Ok(dict) = doc.get_object(id).and_then(Object::as_dict) else { return };
+        let partial = dict.get(b"T").ok().and_then(text_of);
+        let full = match &partial {
+            Some(t) if prefix.is_empty() => t.clone(),
+            Some(t) => format!("{prefix}.{t}"),
+            None => prefix.to_string(),
+        };
+        // Kids là FIELD con khi phần tử có /T (tên riêng); widget con thì không.
+        let kid_fields: Vec<ObjectId> = dict
+            .get(b"Kids")
+            .and_then(Object::as_array)
+            .ok()
+            .map(|kids| {
+                kids.iter()
+                    .filter_map(|k| k.as_reference().ok())
+                    .filter(|kid| {
+                        doc.get_object(*kid)
+                            .and_then(Object::as_dict)
+                            .map(|d| d.has(b"T"))
+                            .unwrap_or(false)
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+
+        if kid_fields.is_empty() {
+            // Field lá (hoặc field có widget con không tên).
+            if partial.is_some() || dict.has(b"FT") {
+                out.push((id, full.clone(), dict.clone()));
+            }
+        } else {
+            for kid in kid_fields {
+                walk(doc, kid, &full, out);
+            }
+        }
+    }
+
+    let mut out = Vec::new();
+    if let Some(fields) = acroform_fields(doc) {
+        for f in fields {
+            if let Ok(id) = f.as_reference() {
+                walk(doc, id, "", &mut out);
+            }
+        }
+    }
+    out
+}
+
+fn acroform_fields(doc: &Document) -> Option<Vec<Object>> {
+    let acro = doc.catalog().ok()?.get(b"AcroForm").ok()?;
+    let acro = match acro {
+        Object::Reference(id) => doc.get_object(*id).and_then(Object::as_dict).ok()?,
+        Object::Dictionary(d) => d,
+        _ => return None,
+    };
+    acro.get(b"Fields").and_then(Object::as_array).ok().cloned()
+}
+
+/// Kế thừa /FT từ cha nếu field lá không tự khai (radio/checkbox thường vậy).
+fn effective_ft(doc: &Document, dict: &Dictionary) -> Option<Vec<u8>> {
+    if let Ok(ft) = dict.get(b"FT").and_then(Object::as_name) {
+        return Some(ft.to_vec());
+    }
+    let mut parent = dict.get(b"Parent").and_then(Object::as_reference).ok();
+    while let Some(pid) = parent {
+        let p = doc.get_object(pid).and_then(Object::as_dict).ok()?;
+        if let Ok(ft) = p.get(b"FT").and_then(Object::as_name) {
+            return Some(ft.to_vec());
+        }
+        parent = p.get(b"Parent").and_then(Object::as_reference).ok();
+    }
+    None
+}
+
+/// Liệt kê mọi field của form.
+pub fn list_form_fields(input: &Path) -> Result<Vec<FormField>, EngineError> {
+    let doc = Document::load(input).map_err(le("load"))?;
+    let wmap = widget_page_map(&doc);
+    let mut out = Vec::new();
+    for (id, name, mut dict) in collect_fields(&doc) {
+        // Bổ sung /FT kế thừa để classify đúng.
+        if !dict.has(b"FT") {
+            if let Some(ft) = effective_ft(&doc, &dict) {
+                dict.set("FT", Object::Name(ft));
+            }
+        }
+        let (kind, on) = classify(&doc, &dict);
+        let value = dict.get(b"V").ok().and_then(text_of);
+        let options = choice_options(&dict);
+        let read_only = bit(dict.get(b"Ff").and_then(Object::as_i64).unwrap_or(0), 1);
+        out.push(FormField {
+            name,
+            kind,
+            value,
+            page_index: field_page(&doc, &dict, &wmap, id),
+            rect: field_rect(&doc, &dict),
+            on_state: on,
+            options,
+            read_only,
+        });
+    }
+    Ok(out)
+}
+
+fn choice_options(dict: &Dictionary) -> Vec<String> {
+    let Ok(opt) = dict.get(b"Opt").and_then(Object::as_array) else { return Vec::new() };
+    opt.iter()
+        .filter_map(|o| match o {
+            Object::Array(pair) => pair.get(1).and_then(text_of).or_else(|| pair.first().and_then(text_of)),
+            other => text_of(other),
+        })
+        .collect()
+}
+
+/// Cặp (tên field, giá trị) để điền.
+#[derive(Clone, Debug)]
+pub struct FieldValue {
+    pub name: String,
+    pub value: String,
+}
+
+/// Điền các field theo tên. Với checkbox/radio: value="on"/"true"/"yes"/"1" →
+/// bật (dùng on-state của field); "off"/rỗng → tắt. Text/combo/list: đặt /V.
+pub fn fill_form_fields(input: &Path, values: &[FieldValue], output: &Path) -> Result<usize, EngineError> {
+    let mut doc = Document::load(input).map_err(le("load"))?;
+    let lookup: BTreeMap<&str, &str> = values.iter().map(|v| (v.name.as_str(), v.value.as_str())).collect();
+
+    let fields = collect_fields(&doc);
+    let mut filled = 0usize;
+    for (id, name, dict) in fields {
+        let Some(&val) = lookup.get(name.as_str()) else { continue };
+        let ft = effective_ft(&doc, &dict);
+        let is_btn = ft.as_deref() == Some(b"Btn");
+        if is_btn {
+            let on = on_state(&doc, &dict).unwrap_or_else(|| "Yes".into());
+            let turn_on = matches!(val.to_ascii_lowercase().as_str(), "on" | "true" | "yes" | "1" | "checked");
+            let state = if turn_on { on.as_str() } else { "Off" };
+            set_button_state(&mut doc, id, &dict, state);
+        } else {
+            if let Ok(f) = doc.get_object_mut(id).and_then(Object::as_dict_mut) {
+                f.set("V", encode_pdf_text(val));
+                f.remove(b"AP"); // buộc dựng lại appearance
+            }
+        }
+        filled += 1;
+    }
+
+    if filled > 0 {
+        set_need_appearances(&mut doc, true);
+    }
+    doc.save(output).map_err(le("save"))?;
+    Ok(filled)
+}
+
+/// Đặt /V của field + /AS của mọi widget (field hoặc /Kids) về `state`.
+fn set_button_state(doc: &mut Document, id: ObjectId, dict: &Dictionary, state: &str) {
+    let state_name = Object::Name(state.as_bytes().to_vec());
+    // /V trên field.
+    if let Ok(f) = doc.get_object_mut(id).and_then(Object::as_dict_mut) {
+        f.set("V", state_name.clone());
+    }
+    // /AS trên widget: field tự là widget?
+    let widget_ids: Vec<ObjectId> = if dict.has(b"AP") || dict.has(b"Rect") {
+        vec![id]
+    } else {
+        dict.get(b"Kids")
+            .and_then(Object::as_array)
+            .ok()
+            .map(|kids| kids.iter().filter_map(|k| k.as_reference().ok()).collect())
+            .unwrap_or_default()
+    };
+    for wid in widget_ids {
+        // /AS chỉ đặt tên trạng thái nếu widget có appearance tương ứng, ngược
+        // lại vẫn đặt (viewer tự xử lý qua NeedAppearances).
+        if let Ok(w) = doc.get_object_mut(wid).and_then(Object::as_dict_mut) {
+            w.set("AS", Object::Name(state.as_bytes().to_vec()));
+        }
+    }
+}
+
+fn set_need_appearances(doc: &mut Document, need: bool) {
+    let acro_id = doc.catalog().ok().and_then(|c| c.get(b"AcroForm").ok()).and_then(|o| o.as_reference().ok());
+    if let Some(id) = acro_id {
+        if let Ok(acro) = doc.get_object_mut(id).and_then(Object::as_dict_mut) {
+            acro.set("NeedAppearances", Object::Boolean(need));
+        }
+    }
+}
+
+/// Flatten form: "in" giá trị field vào nội dung trang, bỏ tính tương tác.
+/// Dùng flatten của PDFium (cần appearance đã dựng → chạy sau khi điền + qpdf).
+pub fn flatten_form(
+    pdfium: &pdfium_render::prelude::Pdfium,
+    input: &Path,
+    output: &Path,
+    password: Option<&str>,
+) -> Result<(), EngineError> {
+    let document = pdfium
+        .load_pdf_from_file(input, password)
+        .map_err(|e| EngineError::Pdfium(format!("form flatten load: {e}")))?;
+    for (i, mut page) in document.pages().iter().enumerate() {
+        page.flatten()
+            .map_err(|e| EngineError::Pdfium(format!("flatten trang {i}: {e}")))?;
+    }
+    document
+        .save_to_file(output)
+        .map_err(|e| EngineError::Pdfium(format!("form flatten save: {e}")))?;
+    Ok(())
+}
+
+// ---- FDF export / import ----
+
+/// Xuất giá trị field ra FDF (Forms Data Format) — chuẩn trao đổi dữ liệu form.
+pub fn export_fdf(input: &Path, output: &Path) -> Result<(), EngineError> {
+    let fields = list_form_fields(input)?;
+    let mut body = String::new();
+    for f in &fields {
+        if matches!(f.kind, FieldKind::Button | FieldKind::Signature) && f.value.is_none() {
+            continue;
+        }
+        let v = f.value.clone().unwrap_or_default();
+        body.push_str(&format!(
+            "<< /T {} /V {} >>\n",
+            serialize_pdf_text(&f.name),
+            serialize_pdf_text(&v)
+        ));
+    }
+    let fdf = format!(
+        "%FDF-1.2\n1 0 obj\n<< /FDF << /Fields [\n{body}] >> >>\nendobj\ntrailer\n<< /Root 1 0 R >>\n%%EOF\n"
+    );
+    std::fs::write(output, fdf)?;
+    Ok(())
+}
+
+/// Chuỗi text PDF cho FDF: ASCII → literal `(...)`; có ký tự Unicode → hex
+/// UTF-16BE `<FEFF...>` (portable, Acrobat đọc được, round-trip tiếng Việt).
+fn serialize_pdf_text(s: &str) -> String {
+    if s.chars().all(|c| (c as u32) < 128) {
+        let mut out = String::from("(");
+        for c in s.chars() {
+            if matches!(c, '(' | ')' | '\\') {
+                out.push('\\');
+            }
+            out.push(c);
+        }
+        out.push(')');
+        out
+    } else {
+        let mut out = String::from("<FEFF");
+        for u in s.encode_utf16() {
+            out.push_str(&format!("{u:04X}"));
+        }
+        out.push('>');
+        out
+    }
+}
+
+/// Đọc FDF → danh sách (tên, giá trị). Parser tối giản cho FDF do ta/Acrobat xuất.
+pub fn parse_fdf(fdf_path: &Path) -> Result<Vec<FieldValue>, EngineError> {
+    let text = std::fs::read_to_string(fdf_path)?;
+    let bytes = text.as_bytes();
+    let mut out = Vec::new();
+    let mut i = 0;
+    // Tìm từng cụm "/T <text> ... /V <text>" (literal hoặc hex).
+    while let Some(t_rel) = find_from(bytes, b"/T", i) {
+        let (name, after_t) = match read_pdf_value(bytes, t_rel + 2) {
+            Some(x) => x,
+            None => {
+                i = t_rel + 2;
+                continue;
+            }
+        };
+        // /V có thể đứng sau, trước /T kế tiếp.
+        let next_t = find_from(bytes, b"/T", after_t).unwrap_or(bytes.len());
+        let value = if let Some(v_rel) = find_from(bytes, b"/V", after_t) {
+            if v_rel < next_t {
+                read_pdf_value(bytes, v_rel + 2).map(|(v, _)| v).unwrap_or_default()
+            } else {
+                String::new()
+            }
+        } else {
+            String::new()
+        };
+        out.push(FieldValue { name, value });
+        i = after_t;
+    }
+    Ok(out)
+}
+
+/// Import FDF vào PDF (điền các field tương ứng).
+pub fn import_fdf(input: &Path, fdf_path: &Path, output: &Path) -> Result<usize, EngineError> {
+    let values = parse_fdf(fdf_path)?;
+    fill_form_fields(input, &values, output)
+}
+
+/// Xuất CSV 2 cột name,value.
+pub fn export_csv(input: &Path, output: &Path) -> Result<(), EngineError> {
+    let fields = list_form_fields(input)?;
+    let mut s = String::from("name,value\n");
+    for f in &fields {
+        if matches!(f.kind, FieldKind::Button | FieldKind::Signature) && f.value.is_none() {
+            continue;
+        }
+        s.push_str(&csv_cell(&f.name));
+        s.push(',');
+        s.push_str(&csv_cell(&f.value.clone().unwrap_or_default()));
+        s.push('\n');
+    }
+    std::fs::write(output, s)?;
+    Ok(())
+}
+
+fn csv_cell(s: &str) -> String {
+    if s.contains([',', '"', '\n']) {
+        format!("\"{}\"", s.replace('"', "\"\""))
+    } else {
+        s.to_string()
+    }
+}
+
+// ---- helpers cho parser FDF ----
+
+fn find_from(hay: &[u8], needle: &[u8], from: usize) -> Option<usize> {
+    if needle.is_empty() || from + needle.len() > hay.len() {
+        return None;
+    }
+    (from..=hay.len() - needle.len()).find(|&i| &hay[i..i + needle.len()] == needle)
+}
+
+/// Đọc 1 giá trị PDF (literal `(..)` hoặc name `/..`) bắt đầu quét từ `from`.
+fn read_pdf_value(bytes: &[u8], from: usize) -> Option<(String, usize)> {
+    let mut i = from;
+    while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+        i += 1;
+    }
+    if i >= bytes.len() {
+        return None;
+    }
+    if bytes[i] == b'(' {
+        read_pdf_literal(bytes, i)
+    } else if bytes[i] == b'<' {
+        read_pdf_hex(bytes, i)
+    } else if bytes[i] == b'/' {
+        let start = i + 1;
+        let mut j = start;
+        while j < bytes.len() && !bytes[j].is_ascii_whitespace() && bytes[j] != b'/' && bytes[j] != b'>' {
+            j += 1;
+        }
+        Some((String::from_utf8_lossy(&bytes[start..j]).into_owned(), j))
+    } else {
+        None
+    }
+}
+
+/// Đọc hex string PDF `<...>` (đã loại nhầm `<<` dict ở caller). Trả (text, sau `>`).
+fn read_pdf_hex(bytes: &[u8], from: usize) -> Option<(String, usize)> {
+    let mut i = from;
+    while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+        i += 1;
+    }
+    if i >= bytes.len() || bytes[i] != b'<' {
+        return None;
+    }
+    i += 1;
+    let mut hex = Vec::new();
+    while i < bytes.len() && bytes[i] != b'>' {
+        if !bytes[i].is_ascii_whitespace() {
+            hex.push(bytes[i]);
+        }
+        i += 1;
+    }
+    if i >= bytes.len() {
+        return None;
+    }
+    i += 1; // qua '>'
+    if hex.len() % 2 != 0 {
+        hex.push(b'0');
+    }
+    let raw: Vec<u8> = hex
+        .chunks_exact(2)
+        .filter_map(|c| {
+            let hi = (c[0] as char).to_digit(16)?;
+            let lo = (c[1] as char).to_digit(16)?;
+            Some(((hi << 4) | lo) as u8)
+        })
+        .collect();
+    Some((decode_pdf_text(&raw), i))
+}
+
+/// Đọc literal string PDF `(...)` (xử lý escape + UTF-16BE BOM). `from` trỏ tại
+/// hoặc trước dấu `(`. Trả (chuỗi, offset sau `)`).
+fn read_pdf_literal(bytes: &[u8], from: usize) -> Option<(String, usize)> {
+    let mut i = from;
+    while i < bytes.len() && bytes[i] != b'(' {
+        if !bytes[i].is_ascii_whitespace() {
+            return None;
+        }
+        i += 1;
+    }
+    if i >= bytes.len() {
+        return None;
+    }
+    i += 1; // qua '('
+    let mut raw: Vec<u8> = Vec::new();
+    let mut depth = 1;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'\\' if i + 1 < bytes.len() => {
+                raw.push(bytes[i + 1]);
+                i += 2;
+            }
+            b'(' => {
+                depth += 1;
+                raw.push(b'(');
+                i += 1;
+            }
+            b')' => {
+                depth -= 1;
+                if depth == 0 {
+                    i += 1;
+                    break;
+                }
+                raw.push(b')');
+                i += 1;
+            }
+            b => {
+                raw.push(b);
+                i += 1;
+            }
+        }
+    }
+    Some((decode_pdf_text(&raw), i))
+}
+
+// ---- Tạo field mới ----
+
+/// Đặc tả tạo 1 field mới trên 1 trang.
+#[derive(Clone, Debug)]
+pub struct NewField {
+    pub name: String,
+    pub kind: FieldKind,
+    pub page_index: u16,
+    /// [left, bottom, right, top] điểm PDF.
+    pub rect: [f32; 4],
+    /// Text: giá trị mặc định; Combo: giá trị chọn; Checkbox: "on"/"off".
+    pub value: String,
+    /// Combo/list options.
+    pub options: Vec<String>,
+}
+
+/// Tạo các field mới, ghi ra `output`. Widget cơ bản (viền mảnh) + appearance
+/// nhờ NeedAppearances. Text/checkbox/combo.
+pub fn create_form_fields(input: &Path, fields: &[NewField], output: &Path) -> Result<(), EngineError> {
+    let mut doc = Document::load(input).map_err(le("load"))?;
+    let pages: BTreeMap<u32, ObjectId> = doc.get_pages();
+
+    let mut new_field_ids: Vec<ObjectId> = Vec::new();
+    for nf in fields {
+        let Some(&page_id) = pages.get(&(nf.page_index as u32 + 1)) else { continue };
+        let rect = Object::Array(vec![
+            nf.rect[0].into(),
+            nf.rect[1].into(),
+            nf.rect[2].into(),
+            nf.rect[3].into(),
+        ]);
+        let mut d = Dictionary::new();
+        d.set("Type", Object::Name(b"Annot".to_vec()));
+        d.set("Subtype", Object::Name(b"Widget".to_vec()));
+        d.set("T", encode_pdf_text(&nf.name));
+        d.set("Rect", rect);
+        d.set("P", Object::Reference(page_id));
+        d.set("F", Object::Integer(4)); // Print
+        // Viền + nền nhạt cho dễ thấy.
+        let mut mk = Dictionary::new();
+        mk.set("BC", Object::Array(vec![0.into(), 0.into(), 0.into()]));
+        mk.set("BG", Object::Array(vec![0.95.into(), 0.95.into(), 0.95.into()]));
+        d.set("MK", Object::Dictionary(mk));
+
+        match nf.kind {
+            FieldKind::Text => {
+                d.set("FT", Object::Name(b"Tx".to_vec()));
+                if !nf.value.is_empty() {
+                    d.set("V", encode_pdf_text(&nf.value));
+                }
+                d.set("DA", Object::string_literal("/Helv 0 Tf 0 g"));
+            }
+            FieldKind::Checkbox => {
+                d.set("FT", Object::Name(b"Btn".to_vec()));
+                let on = matches!(nf.value.to_ascii_lowercase().as_str(), "on" | "true" | "yes" | "1" | "checked");
+                d.set("V", Object::Name(if on { b"Yes".to_vec() } else { b"Off".to_vec() }));
+                d.set("AS", Object::Name(if on { b"Yes".to_vec() } else { b"Off".to_vec() }));
+                // /AP /N với 2 trạng thái rỗng (viewer dựng qua NeedAppearances).
+                d.set("DA", Object::string_literal("/ZaDb 0 Tf 0 g"));
+            }
+            FieldKind::Combo => {
+                d.set("FT", Object::Name(b"Ch".to_vec()));
+                d.set("Ff", Object::Integer(1 << 17)); // Combo flag (bit 18)
+                let opts: Vec<Object> = nf.options.iter().map(|o| encode_pdf_text(o)).collect();
+                d.set("Opt", Object::Array(opts));
+                if !nf.value.is_empty() {
+                    d.set("V", encode_pdf_text(&nf.value));
+                }
+                d.set("DA", Object::string_literal("/Helv 0 Tf 0 g"));
+            }
+            _ => {
+                // Loại chưa hỗ trợ tạo → bỏ qua an toàn.
+                continue;
+            }
+        }
+
+        let fid = doc.add_object(Object::Dictionary(d));
+        new_field_ids.push(fid);
+
+        // Gắn widget vào /Annots của trang.
+        if let Ok(page) = doc.get_object_mut(page_id).and_then(Object::as_dict_mut) {
+            match page.get(b"Annots").and_then(Object::as_array).cloned() {
+                Ok(mut arr) => {
+                    arr.push(Object::Reference(fid));
+                    page.set("Annots", Object::Array(arr));
+                }
+                Err(_) => {
+                    page.set("Annots", Object::Array(vec![Object::Reference(fid)]));
+                }
+            }
+        }
+    }
+
+    ensure_acroform(&mut doc, &new_field_ids)?;
+    set_need_appearances(&mut doc, true);
+    doc.save(output).map_err(le("save"))?;
+    Ok(())
+}
+
+/// Đảm bảo có /AcroForm với /Fields chứa các field mới + /DR font cơ bản.
+fn ensure_acroform(doc: &mut Document, new_ids: &[ObjectId]) -> Result<(), EngineError> {
+    let root_id = doc.trailer.get(b"Root").and_then(Object::as_reference).map_err(le("root"))?;
+    let existing = doc
+        .catalog()
+        .ok()
+        .and_then(|c| c.get(b"AcroForm").ok())
+        .and_then(|o| o.as_reference().ok());
+
+    let acro_id = match existing {
+        Some(id) => id,
+        None => {
+            let mut acro = Dictionary::new();
+            acro.set("Fields", Object::Array(Vec::new()));
+            let id = doc.add_object(Object::Dictionary(acro));
+            if let Ok(cat) = doc.get_object_mut(root_id).and_then(Object::as_dict_mut) {
+                cat.set("AcroForm", Object::Reference(id));
+            }
+            id
+        }
+    };
+    if let Ok(acro) = doc.get_object_mut(acro_id).and_then(Object::as_dict_mut) {
+        let mut fields = acro.get(b"Fields").and_then(Object::as_array).cloned().unwrap_or_default();
+        for id in new_ids {
+            fields.push(Object::Reference(*id));
+        }
+        acro.set("Fields", Object::Array(fields));
+    }
+    Ok(())
+}
diff --git a/crates/ff-engine/src/lib.rs b/crates/ff-engine/src/lib.rs
index b2069ce..1177672 100644
--- a/crates/ff-engine/src/lib.rs
+++ b/crates/ff-engine/src/lib.rs
@@ -7,6 +7,7 @@
 pub mod annot;
 pub mod edit;
 pub(crate) mod fontmatch;
+pub mod form;
 pub mod meta;
 pub mod organize;
 pub mod qpdf;
@@ -29,6 +30,10 @@ pub use qpdf::{
     decrypt_remove_password, encrypt_with_password, encrypt_with_password_perms, ensure_openable,
     find_qpdf, optimize_save, repair, Permissions,
 };
+pub use form::{
+    create_form_fields, export_csv, export_fdf, fill_form_fields, flatten_form, import_fdf,
+    list_form_fields, parse_fdf, FieldKind, FieldValue, FormField, NewField,
+};
 pub use redact::redact_areas;
 pub use sign::{generate_self_signed_id, sign_pdf, verify_signatures, SignatureCheck};
 pub use render::{bind_pdfium, page_count, render_page_png, PageImage};
diff --git a/crates/ff-engine/tests/form_roundtrip.rs b/crates/ff-engine/tests/form_roundtrip.rs
new file mode 100644
index 0000000..7644c1c
--- /dev/null
+++ b/crates/ff-engine/tests/form_roundtrip.rs
@@ -0,0 +1,179 @@
+//! Test Form AcroForm (Phase 6): tạo field → liệt kê → điền → export/import
+//! FDF & CSV → flatten. Cần binary `qpdf` để chuẩn hoá fixture cho lopdf.
+
+use std::path::PathBuf;
+
+use ff_engine::{FieldKind, FieldValue, NewField};
+
+fn workspace_root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("..")
+        .join("..")
+        .canonicalize()
+        .expect("workspace root")
+}
+
+fn pdfium() -> pdfium_render::prelude::Pdfium {
+    if std::env::var("FOFREEXIT_PDFIUM_PATH").is_err() {
+        std::env::set_var("FOFREEXIT_PDFIUM_PATH", workspace_root());
+    }
+    if std::env::var("FOFREEXIT_QPDF_PATH").is_err() {
+        std::env::set_var("FOFREEXIT_QPDF_PATH", "/usr/bin");
+    }
+    ff_engine::bind_pdfium().expect("nạp PDFium")
+}
+
+fn tmp(name: &str) -> PathBuf {
+    let p = std::env::temp_dir().join(name);
+    let _ = std::fs::remove_file(&p);
+    p
+}
+
+/// Dựng fixture form: chuẩn hoá sample rồi thêm 1 text + 1 checkbox + 1 combo.
+fn make_form_fixture(out: &std::path::Path) {
+    std::env::set_var("FOFREEXIT_QPDF_PATH", "/usr/bin");
+    let norm = tmp("ff_form_norm.pdf");
+    ff_engine::repair(&workspace_root().join("corpus").join("sample-multipage.pdf"), &norm)
+        .expect("normalize");
+    let fields = vec![
+        NewField {
+            name: "hoTen".into(),
+            kind: FieldKind::Text,
+            page_index: 0,
+            rect: [80.0, 700.0, 320.0, 720.0],
+            value: String::new(),
+            options: vec![],
+        },
+        NewField {
+            name: "dongY".into(),
+            kind: FieldKind::Checkbox,
+            page_index: 0,
+            rect: [80.0, 660.0, 96.0, 676.0],
+            value: "off".into(),
+            options: vec![],
+        },
+        NewField {
+            name: "gioiTinh".into(),
+            kind: FieldKind::Combo,
+            page_index: 0,
+            rect: [80.0, 620.0, 240.0, 640.0],
+            value: String::new(),
+            options: vec!["Nam".into(), "Nữ".into(), "Khác".into()],
+        },
+    ];
+    ff_engine::create_form_fields(&norm, &fields, out).expect("create fields");
+}
+
+#[test]
+fn create_and_list_fields() {
+    let _ = pdfium();
+    let fx = tmp("ff_form_fx.pdf");
+    make_form_fixture(&fx);
+
+    let fields = ff_engine::list_form_fields(&fx).expect("list");
+    assert_eq!(fields.len(), 3, "phải có 3 field: {:?}", fields.iter().map(|f| &f.name).collect::<Vec<_>>());
+    let by_name = |n: &str| fields.iter().find(|f| f.name == n).unwrap_or_else(|| panic!("thiếu {n}"));
+    assert_eq!(by_name("hoTen").kind, FieldKind::Text);
+    assert_eq!(by_name("dongY").kind, FieldKind::Checkbox);
+    let combo = by_name("gioiTinh");
+    assert_eq!(combo.kind, FieldKind::Combo);
+    assert_eq!(combo.options, vec!["Nam".to_string(), "Nữ".into(), "Khác".into()]);
+    // Field nằm đúng trang 0 và có rect.
+    assert_eq!(by_name("hoTen").page_index, Some(0));
+    assert!(by_name("hoTen").rect.is_some());
+}
+
+#[test]
+fn fill_text_checkbox_combo_round_trips() {
+    let _ = pdfium();
+    let fx = tmp("ff_form_fill_fx.pdf");
+    let out = tmp("ff_form_filled.pdf");
+    make_form_fixture(&fx);
+
+    let values = vec![
+        FieldValue { name: "hoTen".into(), value: "Nguyễn Văn A".into() },
+        FieldValue { name: "dongY".into(), value: "on".into() },
+        FieldValue { name: "gioiTinh".into(), value: "Nữ".into() },
+    ];
+    let n = ff_engine::fill_form_fields(&fx, &values, &out).expect("fill");
+    assert_eq!(n, 3, "phải điền 3 field");
+
+    let fields = ff_engine::list_form_fields(&out).expect("list out");
+    let get = |n: &str| fields.iter().find(|f| f.name == n).unwrap();
+    assert_eq!(get("hoTen").value.as_deref(), Some("Nguyễn Văn A"), "text (tiếng Việt) round-trip");
+    assert_eq!(get("gioiTinh").value.as_deref(), Some("Nữ"));
+    // Checkbox bật → /V là tên on-state (khác "Off").
+    let cb = get("dongY").value.clone().unwrap_or_default();
+    assert!(cb != "Off" && !cb.is_empty(), "checkbox bật phải có on-state, được {cb:?}");
+}
+
+#[test]
+fn fdf_export_import_round_trip() {
+    let _ = pdfium();
+    let fx = tmp("ff_form_fdf_fx.pdf");
+    let filled = tmp("ff_form_fdf_filled.pdf");
+    let fdf = tmp("ff_form_out.fdf");
+    let reimported = tmp("ff_form_reimport.pdf");
+    make_form_fixture(&fx);
+
+    let values = vec![
+        FieldValue { name: "hoTen".into(), value: "Trần Thị B".into() },
+        FieldValue { name: "gioiTinh".into(), value: "Khác".into() },
+    ];
+    ff_engine::fill_form_fields(&fx, &values, &filled).expect("fill");
+    ff_engine::export_fdf(&filled, &fdf).expect("export fdf");
+
+    // FDF chứa tên + giá trị.
+    let parsed = ff_engine::parse_fdf(&fdf).expect("parse fdf");
+    let hoten = parsed.iter().find(|v| v.name == "hoTen").expect("hoTen trong fdf");
+    assert_eq!(hoten.value, "Trần Thị B");
+
+    // Import FDF vào fixture rỗng → giá trị được điền lại.
+    let n = ff_engine::import_fdf(&fx, &fdf, &reimported).expect("import fdf");
+    assert!(n >= 2, "import phải điền ≥2 field");
+    let fields = ff_engine::list_form_fields(&reimported).expect("list reimport");
+    assert_eq!(
+        fields.iter().find(|f| f.name == "hoTen").unwrap().value.as_deref(),
+        Some("Trần Thị B")
+    );
+}
+
+#[test]
+fn export_csv_has_rows() {
+    let _ = pdfium();
+    let fx = tmp("ff_form_csv_fx.pdf");
+    let filled = tmp("ff_form_csv_filled.pdf");
+    let csv = tmp("ff_form_out.csv");
+    make_form_fixture(&fx);
+    ff_engine::fill_form_fields(
+        &fx,
+        &[FieldValue { name: "hoTen".into(), value: "CSV Test".into() }],
+        &filled,
+    )
+    .expect("fill");
+    ff_engine::export_csv(&filled, &csv).expect("export csv");
+
+    let text = std::fs::read_to_string(&csv).expect("đọc csv");
+    assert!(text.starts_with("name,value"), "CSV phải có header");
+    assert!(text.contains("hoTen,CSV Test"), "CSV phải chứa giá trị: {text}");
+}
+
+#[test]
+fn flatten_removes_interactive_fields() {
+    let pdf = pdfium();
+    let fx = tmp("ff_form_flat_fx.pdf");
+    let filled = tmp("ff_form_flat_filled.pdf");
+    let flat = tmp("ff_form_flat.pdf");
+    make_form_fixture(&fx);
+    ff_engine::fill_form_fields(
+        &fx,
+        &[FieldValue { name: "hoTen".into(), value: "Flatten Me".into() }],
+        &filled,
+    )
+    .expect("fill");
+
+    ff_engine::flatten_form(&pdf, &filled, &flat, None).expect("flatten");
+    // Sau flatten không còn field tương tác.
+    let fields = ff_engine::list_form_fields(&flat).expect("list flat");
+    assert!(fields.is_empty(), "flatten phải bỏ hết field tương tác, còn: {:?}", fields.iter().map(|f| &f.name).collect::<Vec<_>>());
+}
diff --git a/docs/03-roadmap.md b/docs/03-roadmap.md
index a49e810..7c25ec5 100644
--- a/docs/03-roadmap.md
+++ b/docs/03-roadmap.md
@@ -50,11 +50,11 @@ Một ứng dụng desktop có thể **xem, chú thích, tổ chức trang, và
 - Xoá metadata/ẩn; **chữ ký số** (PAdES, byte range, incremental update giữ chữ ký).
 **DoD:** mã hoá/giải mã round-trip; redaction qua kiểm chứng không còn text bị bôi; ký số được Acrobat xác thực hợp lệ.
 
-## Phase 6 — Form (AcroForm)
+## Phase 6 — Form (AcroForm) ✅ HOÀN TẤT lõi (67/67 test — xem [docs/17-phase6-summary.md](17-phase6-summary.md))
 **Mục tiêu:** Điền & tạo form.
-- Điền form có sẵn, lưu; flatten form.
-- Tạo field: text/checkbox/radio/dropdown/button; import/export dữ liệu (FDF/CSV).
-**DoD:** điền & lưu giữ dữ liệu; tạo form mới mở được ở Acrobat; export/import round-trip.
+- [x] Điền form có sẵn, lưu; flatten form.
+- [x] Tạo field: text/checkbox/combo (radio-group/list/pushbutton: follow-up); import/export dữ liệu FDF + export CSV.
+**DoD:** ✅ điền & lưu giữ dữ liệu (gồm tiếng Việt); tạo form mới; export/import FDF round-trip. Follow-up: XFDF, radio-group/list/pushbutton khi tạo.
 
 ## Phase 7 — OCR & Convert
 **Mục tiêu:** Hai tính năng "đáng tiền" còn lại, qua dự án mở.
diff --git a/docs/14-foxit-gap-analysis.md b/docs/14-foxit-gap-analysis.md
index 030b7d9..72b5fc2 100644
--- a/docs/14-foxit-gap-analysis.md
+++ b/docs/14-foxit-gap-analysis.md
@@ -101,7 +101,7 @@ Xếp theo mức độ ảnh hưởng trải nghiệm:
 | Nhóm | Đường đi đã chốt trong roadmap | Rủi ro công nghệ |
 |---|---|---|
 | ~~Bảo mật, redaction, chữ ký số PAdES (Phase 5)~~ ✅ ĐÃ LÀM | AES-256+quyền, redaction thật (tỉa ký tự), **chữ ký số PKCS#7/CMS + xác thực + phát hiện giả mạo** (`sign.rs`), lưu tối ưu — 62/62 test | Đã giải; còn lại timestamp/LTV/PFX/multi-sig (docs/15 mục 6.6) |
-| Form AcroForm (Phase 6) | PDFium có FPDF_FORMFILL đầy đủ (fill/flatten); tạo field mới bằng lopdf | Thấp-trung bình |
+| ~~Form AcroForm (Phase 6)~~ ✅ ĐÃ LÀM | Liệt kê/điền/tạo field (lopdf) + flatten (PDFium) + FDF/CSV — 67/67 test (`form.rs`) | Đã giải; còn XFDF, radio-group/list/pushbutton khi tạo (docs/17 mục 6) |
 | OCR (Phase 7) | Tesseract (tiếng Việt có traineddata chuẩn) + lớp text ẩn — kỹ thuật giống watermark.rs đã làm | Thấp, chủ yếu là chất lượng tiền xử lý ảnh |
 | Convert Office↔PDF (Phase 7) | LibreOffice headless; PDF→Word "đủ dùng" trước | PDF→Word giữ layout hoàn hảo là bài khó với CẢ Foxit — đặt kỳ vọng "tương đương Foxit" chứ không hơn |
 | So sánh PDF, in ấn, installer (Phase 8) | render diff đã có nền; Tauri bundler | Thấp |
@@ -136,13 +136,16 @@ redaction thật kiểm chứng được, xoá metadata — docs/15)**.
 **Phase 5 đã HOÀN TẤT** (iter 1+2): mã hoá+quyền, gỡ mật khẩu, redaction thật
 + tỉa ký tự, xoá metadata, **chữ ký số PKCS#7/PAdES + xác thực**, lưu tối ưu.
 
+**Phase 6 đã HOÀN TẤT lõi**: liệt kê/điền/tạo field, flatten, FDF/CSV.
+
 Thứ tự đề xuất tiếp theo, bám giá trị người dùng:
-1. **Phase 6 — Form (AcroForm)**: điền form (PDFium FPDF_FORMFILL), flatten,
-   tạo field text/checkbox/radio/dropdown, import/export FDF/CSV.
-2. Phase 7 OCR/Convert → Phase 8 phát hành (theo roadmap).
+1. **Phase 7 — OCR & Convert**: OCR Tesseract (Việt+Anh) tạo lớp text ẩn;
+   convert Office↔PDF qua LibreOffice headless; PDF→Word/Excel "đủ dùng".
+2. Phase 8 — phát hành (installer, so sánh PDF, in ấn, đa ngôn ngữ UI).
 3. Song song, rải theo từng phase: mở rộng font matching (3.4), nấc 1 của
    hiệu năng phiên sửa (3.2) khi chạm file lớn thực tế, v2 của reflow
-   (justify/xoay — mục 3.1), và nâng chữ ký (timestamp/LTV/PFX/multi-sig).
+   (justify/xoay — mục 3.1), nâng chữ ký (timestamp/LTV/PFX/multi-sig), và
+   nâng form (XFDF, radio-group/list/pushbutton, appearance riêng).
 
 ## 6. Checklist FINAL TARGET & RULE cho chính tài liệu này
 - [x] Đối chiếu từng tính năng với hành vi Foxit làm chuẩn nghiệm thu.
diff --git a/docs/17-phase6-summary.md b/docs/17-phase6-summary.md
new file mode 100644
index 0000000..7f90818
--- /dev/null
+++ b/docs/17-phase6-summary.md
@@ -0,0 +1,67 @@
+# 17 — Tổng kết Phase 6 (Form — AcroForm)
+
+> Trạng thái: **HOÀN TẤT lõi.** Liệt kê / điền / tạo field, flatten,
+> export/import FDF + export CSV. 5 test round-trip mới, tổng engine **67/67
+> xanh** (ngoài 2 fixture qpdf Linux). Chi tiết & giới hạn ở mục 4–5.
+
+## 1. Khảo sát Foxit (chuẩn nghiệm thu)
+- **Fill & Sign / Form**: điền field có sẵn (text/checkbox/radio/combo/list),
+  lưu giữ dữ liệu; **Flatten** biến field thành nội dung tĩnh.
+- **Prepare Form**: tạo field mới (text/checkbox/radio/dropdown/button).
+- **Import/Export Form Data**: FDF/XFDF/CSV để trao đổi dữ liệu.
+
+## 2. Lựa chọn kỹ thuật
+- **Đọc/ghi cấu trúc AcroForm bằng `lopdf`** (thao tác tầng PDF object) —
+  portable, không cần khởi tạo form-environment của PDFium (vốn phức tạp và
+  phụ thuộc build). **Flatten dùng PDFium** (`page.flatten()`).
+- Điền field đặt `NeedAppearances=true` để MỌI viewer tự dựng lại appearance —
+  cách tương thích rộng nhất, không phải tự vẽ appearance stream cho từng loại.
+
+## 3. Đã làm — Engine (`form.rs`)
+- **`list_form_fields`**: duyệt cây `/AcroForm/Fields` (đệ quy /Kids là field
+  con), suy tên đầy đủ (fully-qualified), phân loại theo `/FT` + cờ `/Ff`
+  (checkbox vs radio vs pushbutton; combo vs list), đọc `/V`, options, on-state
+  (tên trạng thái bật khác "Off" trong /AP /N), trang chứa widget + rect.
+  Kế thừa `/FT` từ cha cho field lá không tự khai.
+- **`fill_form_fields`**: text/combo/list đặt `/V` (UTF-16BE cho tiếng Việt),
+  xoá `/AP` để dựng lại; checkbox/radio đặt `/V` + `/AS` widget về on-state;
+  bật NeedAppearances.
+- **`flatten_form`**: PDFium flatten từng trang → in field vào nội dung, bỏ
+  tương tác.
+- **`create_form_fields`**: tạo widget + field text/checkbox/combo (viền + nền
+  nhạt, /DA font mặc định), gắn vào `/Annots` trang + `/AcroForm/Fields`, tạo
+  AcroForm nếu chưa có.
+- **FDF & CSV**: `export_fdf` (literal cho ASCII, hex UTF-16BE cho Unicode —
+  round-trip tiếng Việt), `parse_fdf`/`import_fdf` (parser đọc cả literal `(..)`
+  và hex `<..>`), `export_csv`.
+
+## 4. Tauri + UI (thanh "📝 Form")
+- Commands: `form_list`, `form_fill`, `form_flatten`, `form_create`,
+  `form_export` (FDF/CSV theo đuôi), `form_import_fdf`; picker
+  `pick_save_data`/`pick_fdf`. Mọi command tự chuẩn hoá qua qpdf khi lopdf
+  không đọc thẳng trailer phi chuẩn.
+- **📋 Điền form**: modal liệt kê mọi field với input đúng loại (text→ô nhập,
+  checkbox→tick, combo→select) → Lưu & áp dụng ra file mới.
+- **➕ Thêm field**: dialog chọn loại/tên/trang/vị trí/cỡ (+ options cho combo).
+- **🧷 Flatten**, **⬆ Xuất FDF / CSV**, **⬇ Nhập FDF**.
+- Không dùng prompt/alert; đếm số field hiển thị trên nút.
+
+## 5. Test (5 mới → engine 67/67)
+- `create_and_list_fields` — tạo 3 field (text/checkbox/combo) rồi liệt kê
+  đúng loại + options + trang + rect.
+- `fill_text_checkbox_combo_round_trips` — điền (text tiếng Việt, checkbox bật,
+  combo chọn) rồi đọc lại đúng giá trị.
+- `fdf_export_import_round_trip` — điền → export FDF → parse thấy giá trị →
+  import vào fixture rỗng → giá trị được điền lại (tiếng Việt đúng).
+- `export_csv_has_rows` — CSV có header + dòng name,value.
+- `flatten_removes_interactive_fields` — sau flatten không còn field tương tác.
+
+## 6. Giới hạn (v-sau, không chặn dùng)
+- Tạo field mới: hỗ trợ text/checkbox/combo; radio-group nhiều nút, list-box,
+  pushbutton (action) chưa tạo (đọc/điền thì được).
+- Chưa vẽ appearance stream riêng → phụ thuộc NeedAppearances (Chrome/Foxit/
+  Acrobat đều dựng; vài viewer tối giản có thể không). Flatten khắc phục khi
+  cần bản “cứng”.
+- Chưa XFDF (XML); mới FDF + CSV. Chưa validate/format (số, ngày) theo JS của
+  field. Điền trên UI qua danh sách (chưa overlay click trực tiếp lên trang —
+  cân nhắc cho vòng sau như edit-stage).
diff --git a/docs/18-phase6-user-tests.md b/docs/18-phase6-user-tests.md
new file mode 100644
index 0000000..edc358d
--- /dev/null
+++ b/docs/18-phase6-user-tests.md
@@ -0,0 +1,35 @@
+# 18 — Checklist test thủ công Phase 6 (Form)
+
+Quan trọng nhất: **điền form lưu giữ dữ liệu** (F3) và **file mở đúng ở
+Foxit/Adobe** (F4, F8), vì đây là dữ liệu người dùng nhập.
+
+## Chạy
+```powershell
+cd c:\Project\FoFreeXit\app\src-tauri
+cargo run
+```
+
+## Bảng test
+| # | Thao tác | Kỳ vọng | KQ |
+|---|----------|---------|----|
+| F1 | Mở 1 PDF, bấm **📝 Form** | Hiện thanh Form; nút “Điền form (n)” cho biết số field | |
+| F2 | Bấm **➕ Thêm field** → tạo 1 Text “hoTen” trang 1 → lưu | File mới mở lên, thanh Form đếm tăng | |
+| F3 | Bấm **📋 Điền form** → nhập “Nguyễn Văn A” vào hoTen → Lưu | File mới; mở lại thấy giá trị đã điền | |
+| F4 | Mở file F3 ở **Foxit/Adobe** | Field hoTen hiển thị đúng “Nguyễn Văn A” (tiếng Việt đúng dấu) | |
+| F5 | Thêm 1 **Checkbox** và 1 **Combo** (Nam/Nữ/Khác) → Điền form: tick checkbox, chọn combo → Lưu | Mở lại: checkbox đang tick, combo đúng lựa chọn | |
+| F6 | **⬆ Xuất FDF** → mở file .fdf bằng Notepad | Có tên field + giá trị (tiếng Việt dạng `<FEFF...>`) | |
+| F7 | Trên 1 file form rỗng: **⬇ Nhập FDF** (chọn file F6) → Lưu | Các field được điền lại từ FDF | |
+| F8 | **🧷 Flatten** file đã điền → mở ở Foxit | Giá trị vẫn hiển thị nhưng KHÔNG còn là field bấm/sửa được | |
+| F9 | **⬆ Xuất CSV** → mở bằng Excel | 2 cột name,value đúng dữ liệu | |
+| F10 | Mở form PDF THẬT (mẫu Acrobat) → **📋 Điền form** | Liệt kê đúng các field có sẵn, điền & lưu giữ được | |
+
+## Mẫu phản hồi
+```
+[Mã] (vd F4) — Phần mềm mở: <Foxit/Adobe/Chrome> — Hiện tượng: <mô tả> —
+Kỳ vọng: <...> — Ưu tiên: cao/vừa/thấp
+```
+
+> Giới hạn đã biết: tạo field mới hỗ trợ text/checkbox/combo (radio-group/
+> list/pushbutton chưa tạo — đọc/điền thì được); dựa vào NeedAppearances để
+> viewer dựng hình field (Flatten cho bản “cứng”); mới FDF+CSV, chưa XFDF —
+> xem `docs/17-phase6-summary.md` mục 6.