From b961925de2ac0ee331bfe451989f39f2a7c5540b Mon Sep 17 00:00:00 2001
From: Anthony Stirling <77850077+Frooodle@users.noreply.github.com>
Date: Thu, 13 Aug 2026 20:48:47 +0100
Subject: [PATCH] Import and export XFDF and FDF form data in Fill Form

---
 .../public/locales/en-GB/translation.toml     |  10 +
 .../public/locales/en-US/translation.toml     |  10 +
 .../core/tests/stubbed/form-fill-xfdf.spec.ts | 173 +++++++
 .../core/tools/formFill/FormFill.module.css   |  18 +
 .../src/core/tools/formFill/FormFill.tsx      | 192 ++++++--
 .../core/tools/formFill/FormFillContext.tsx   |  16 +-
 .../src/core/utils/formDataExchange.test.ts   | 406 ++++++++++++++++
 .../editor/src/core/utils/formDataExchange.ts | 439 +++++++++++++++++
 .../src/core/utils/postscriptObjects.ts       | 450 ++++++++++++++++++
 9 files changed, 1684 insertions(+), 30 deletions(-)
 create mode 100644 frontend/editor/src/core/tests/stubbed/form-fill-xfdf.spec.ts
 create mode 100644 frontend/editor/src/core/utils/formDataExchange.test.ts
 create mode 100644 frontend/editor/src/core/utils/formDataExchange.ts
 create mode 100644 frontend/editor/src/core/utils/postscriptObjects.ts

diff --git a/frontend/editor/public/locales/en-GB/translation.toml b/frontend/editor/public/locales/en-GB/translation.toml
index bdf6a739ed..50c73afc73 100644
--- a/frontend/editor/public/locales/en-GB/translation.toml
+++ b/frontend/editor/public/locales/en-GB/translation.toml
@@ -4253,9 +4253,19 @@ issues = "GitHub"
 
 [formFill]
 allSaved = "All saved"
+exportAs = "Export data as"
+exportAsFormat = "Export as {{format}}"
 extractCsvError = "Failed to extract CSV"
 extractXlsxError = "Failed to extract XLSX"
 flattenAfterFilling = "Flatten after filling"
+importData = "Import form data"
+importError = "Failed to import form data"
+importSkipped_one = "{{count}} field is not in this PDF: {{names}}"
+importSkipped_other = "{{count}} fields are not in this PDF: {{names}}"
+importSkippedNames = "{{names}} and {{rest}} more"
+importSuccess_one = "Imported {{count}} field from {{format}}"
+importSuccess_other = "Imported {{count}} fields from {{format}}"
+importTooltip = "Import values from an Acrobat XFDF or FDF export"
 requiredAbbreviation = "req"
 requiredFieldsError = "Please fill in all required fields"
 rescanFields = "Re-scan fields"
diff --git a/frontend/editor/public/locales/en-US/translation.toml b/frontend/editor/public/locales/en-US/translation.toml
index d6b38bc2e8..cc59a054bc 100644
--- a/frontend/editor/public/locales/en-US/translation.toml
+++ b/frontend/editor/public/locales/en-US/translation.toml
@@ -4263,10 +4263,20 @@ issues = "GitHub"
 [formFill]
 allSaved = "All saved"
 analyzingFields = "Analysing form fields..."
+exportAs = "Export data as"
+exportAsFormat = "Export as {{format}}"
 extractCsvError = "Failed to extract CSV"
 extractXlsxError = "Failed to extract XLSX"
 filled = "filled"
 flattenAfterFilling = "Flatten after filling"
+importData = "Import form data"
+importError = "Failed to import form data"
+importSkipped_one = "{{count}} field is not in this PDF: {{names}}"
+importSkipped_other = "{{count}} fields are not in this PDF: {{names}}"
+importSkippedNames = "{{names}} and {{rest}} more"
+importSuccess_one = "Imported {{count}} field from {{format}}"
+importSuccess_other = "Imported {{count}} fields from {{format}}"
+importTooltip = "Import values from an Acrobat XFDF or FDF export"
 noFields = "No fillable form fields found in this PDF."
 placeholderEnter = "Enter"
 placeholderSelect = "Select"
diff --git a/frontend/editor/src/core/tests/stubbed/form-fill-xfdf.spec.ts b/frontend/editor/src/core/tests/stubbed/form-fill-xfdf.spec.ts
new file mode 100644
index 0000000000..293564244c
--- /dev/null
+++ b/frontend/editor/src/core/tests/stubbed/form-fill-xfdf.spec.ts
@@ -0,0 +1,173 @@
+import { test, expect } from "@app/tests/helpers/stub-test-base";
+import { uploadFiles } from "@app/tests/helpers/ui-helpers";
+import type { Page } from "@playwright/test";
+import path from "path";
+
+/**
+ * Stubbed coverage for the Form Fill tool's XFDF / FDF exchange.
+ *
+ * These are Acrobat's interchange formats for form *values*, so this is the
+ * seam that lets an Acrobat-based forms workflow move over: import an
+ * existing export, or hand a filled form back to a process that expects
+ * XFDF.
+ *
+ * The field list normally comes from the PDFBox backend; here
+ * `/api/v1/form/fields-with-coordinates` is stubbed so the flow runs without
+ * a server.
+ */
+
+const SAMPLE_PDF = path.join(
+  import.meta.dirname,
+  "../test-fixtures/sample.pdf",
+);
+
+const FIELDS = [
+  {
+    name: "FullName",
+    label: "Full name",
+    type: "text",
+    value: "",
+    options: null,
+    displayOptions: null,
+    required: false,
+    readOnly: false,
+    multiSelect: false,
+    multiline: false,
+    tooltip: null,
+    widgets: [
+      { pageIndex: 0, x: 100, y: 100, width: 200, height: 20, fontSize: 10 },
+    ],
+  },
+  {
+    name: "Address.Street",
+    label: "Street",
+    type: "text",
+    value: "",
+    options: null,
+    displayOptions: null,
+    required: false,
+    readOnly: false,
+    multiSelect: false,
+    multiline: false,
+    tooltip: null,
+    widgets: [
+      { pageIndex: 0, x: 100, y: 140, width: 200, height: 20, fontSize: 10 },
+    ],
+  },
+  {
+    name: "Languages",
+    label: "Languages",
+    type: "listbox",
+    value: "",
+    options: ["English", "French", "German"],
+    displayOptions: null,
+    required: false,
+    readOnly: false,
+    multiSelect: true,
+    multiline: false,
+    tooltip: null,
+    widgets: [
+      { pageIndex: 0, x: 100, y: 180, width: 200, height: 40, fontSize: 10 },
+    ],
+  },
+];
+
+/** A real-shaped Acrobat XFDF export, including a field this PDF lacks. */
+const XFDF = `<?xml version="1.0" encoding="UTF-8"?>
+<xfdf xmlns="http://ns.adobe.com/xfdf/" xml:space="preserve">
+  <f href="sample.pdf"/>
+  <fields>
+    <field name="FullName"><value>Ada Lovelace</value></field>
+    <field name="Address">
+      <field name="Street"><value>1 High Street</value></field>
+    </field>
+    <field name="Languages">
+      <value>English</value>
+      <value>French</value>
+    </field>
+    <field name="NotInThisPdf"><value>ignored</value></field>
+  </fields>
+</xfdf>
+`;
+
+async function openFormFill(page: Page): Promise<void> {
+  await page.route("**/api/v1/form/fields-with-coordinates", (route) =>
+    route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify(FIELDS),
+    }),
+  );
+  await page.goto("/form-fill");
+  await page.waitForLoadState("domcontentloaded");
+  await uploadFiles(page, SAMPLE_PDF);
+  // The panel only renders its actions once the field fetch resolves.
+  await expect(
+    page.getByRole("button", { name: /Import form data/i }),
+  ).toBeVisible({
+    timeout: 20_000,
+  });
+}
+
+test.describe("Form Fill — XFDF / FDF exchange", () => {
+  test("importing an XFDF export fills the matching fields and reports the rest", async ({
+    page,
+  }) => {
+    await openFormFill(page);
+
+    await page.locator('input[type="file"][accept*="xfdf"]').setInputFiles({
+      name: "export.xfdf",
+      mimeType: "application/vnd.adobe.xfdf",
+      buffer: Buffer.from(XFDF),
+    });
+
+    // Three of the four fields exist in this document. The two counts
+    // pluralise independently: "3 fields" imported, "1 field" skipped.
+    await expect(
+      page.getByText(
+        /Imported 3 fields from XFDF\. 1 field is not in this PDF: NotInThisPdf/,
+      ),
+    ).toBeVisible({ timeout: 10_000 });
+
+    // Values reached the form store: the panel's progress counter moves and
+    // the text input shows the imported value.
+    await expect(page.getByText("3 / 3 filled")).toBeVisible();
+    await expect(
+      page.locator('input[value="Ada Lovelace"]').first(),
+    ).toBeVisible();
+  });
+
+  test("a filled form exports as XFDF", async ({ page }) => {
+    await openFormFill(page);
+
+    await page.locator('input[type="file"][accept*="xfdf"]').setInputFiles({
+      name: "export.xfdf",
+      mimeType: "application/vnd.adobe.xfdf",
+      buffer: Buffer.from(XFDF),
+    });
+    await expect(page.getByText(/Imported 3 fields from XFDF/)).toBeVisible({
+      timeout: 10_000,
+    });
+
+    const downloadPromise = page.waitForEvent("download");
+    await page.getByRole("button", { name: /Export as XFDF/i }).click();
+    const download = await downloadPromise;
+    expect(download.suggestedFilename()).toMatch(/\.xfdf$/);
+  });
+
+  test("an unrecognised data file is rejected with a readable message", async ({
+    page,
+  }) => {
+    await openFormFill(page);
+
+    await page.locator('input[type="file"][accept*="xfdf"]').setInputFiles({
+      name: "notes.xfdf",
+      mimeType: "application/vnd.adobe.xfdf",
+      buffer: Buffer.from('{"FullName":"Ada"}'),
+    });
+
+    await expect(page.getByText(/Unrecognised form data file/)).toBeVisible({
+      timeout: 10_000,
+    });
+  });
+});
diff --git a/frontend/editor/src/core/tools/formFill/FormFill.module.css b/frontend/editor/src/core/tools/formFill/FormFill.module.css
index edd19d0814..1d30961ec4 100644
--- a/frontend/editor/src/core/tools/formFill/FormFill.module.css
+++ b/frontend/editor/src/core/tools/formFill/FormFill.module.css
@@ -106,6 +106,24 @@
   padding-right: 0.25rem;
 }
 
+/* Import is an input action, not one of the export formats, so it gets its
+   own full-width row. Four format buttons is already the most this panel
+   width fits without truncating their labels. */
+.importRow {
+  display: flex;
+}
+
+.importRow > button {
+  flex: 1;
+}
+
+.exportLabel {
+  display: flex;
+  align-items: center;
+  gap: 0.25rem;
+  margin-top: 0.125rem;
+}
+
 .fieldList {
   flex: 1;
   overflow: hidden;
diff --git a/frontend/editor/src/core/tools/formFill/FormFill.tsx b/frontend/editor/src/core/tools/formFill/FormFill.tsx
index 599d586319..a16a059f23 100644
--- a/frontend/editor/src/core/tools/formFill/FormFill.tsx
+++ b/frontend/editor/src/core/tools/formFill/FormFill.tsx
@@ -54,10 +54,16 @@ import FileCopyIcon from "@mui/icons-material/FileCopy";
 import BuildCircleIcon from "@mui/icons-material/BuildCircle";
 import DescriptionIcon from "@mui/icons-material/Description";
 import FileDownloadIcon from "@mui/icons-material/FileDownload";
+import FileUploadIcon from "@mui/icons-material/FileUpload";
 import {
   extractFormFieldsCsv,
   extractFormFieldsXlsx,
 } from "@app/tools/formFill/formApi";
+import {
+  buildXfdf,
+  parseFormDataFile,
+  reconcileImportedValues,
+} from "@app/utils/formDataExchange";
 import styles from "@app/tools/formFill/FormFill.module.css";
 
 // ---------------------------------------------------------------------------
@@ -149,6 +155,8 @@ const FormFill = (_props: BaseToolProps) => {
   const [saving, setSaving] = useState(false);
   const [extracting, setExtracting] = useState(false);
   const [saveError, setSaveError] = useState<string | null>(null);
+  const [importSummary, setImportSummary] = useState<string | null>(null);
+  const importInputRef = useRef<HTMLInputElement>(null);
 
   const [lastSavedFlatten, setLastSavedFlatten] = useState<boolean | null>(
     null,
@@ -210,6 +218,91 @@ const FormFill = (_props: BaseToolProps) => {
     }
   }, [currentFile, allValues]);
 
+  /**
+   * Export as XFDF - the interchange format Acrobat's "Import Data" reads, so
+   * a form filled here can be handed back to an Acrobat-based process.
+   */
+  const handleExportXfdf = useCallback(() => {
+    setExtracting(true);
+    try {
+      const multiSelectFields = formState.fields
+        .filter((field) => field.multiSelect)
+        .map((field) => field.name);
+      const xfdf = buildXfdf(allValues, {
+        pdfHref: currentFile instanceof File ? currentFile.name : undefined,
+        multiSelectFields,
+      });
+      const blob = new Blob([xfdf], { type: "application/vnd.adobe.xfdf" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = `form-data-${new Date().getTime()}.xfdf`;
+      a.click();
+      setTimeout(() => URL.revokeObjectURL(url), 250);
+    } finally {
+      setExtracting(false);
+    }
+  }, [allValues, currentFile, formState.fields]);
+
+  /**
+   * Import an Acrobat XFDF/FDF export into the open form. Values for fields
+   * this document doesn't have are reported rather than silently dropped.
+   */
+  const handleImportFormData = useCallback(
+    async (file: File) => {
+      setSaveError(null);
+      setImportSummary(null);
+      try {
+        const { values, format } = await parseFormDataFile(file);
+        const { applied, unmatched } = reconcileImportedValues(
+          values,
+          formState.fields.map((field) => field.name),
+        );
+        for (const [name, value] of Object.entries(applied)) {
+          setValue(name, value);
+        }
+        // Two sentences, not one: each count needs its own plural form, so
+        // "Imported 1 field" can sit next to "3 fields are not in this PDF".
+        const imported = t(
+          "formFill.importSuccess",
+          "Imported {{count}} field(s) from {{format}}",
+          { count: Object.keys(applied).length, format: format.toUpperCase() },
+        );
+        const NAME_LIMIT = 5;
+        const skipped =
+          unmatched.length > 0
+            ? t(
+                "formFill.importSkipped",
+                "{{count}} field(s) are not in this PDF: {{names}}",
+                {
+                  count: unmatched.length,
+                  names:
+                    unmatched.length > NAME_LIMIT
+                      ? t(
+                          "formFill.importSkippedNames",
+                          "{{names}} and {{rest}} more",
+                          {
+                            names: unmatched.slice(0, NAME_LIMIT).join(", "),
+                            rest: unmatched.length - NAME_LIMIT,
+                          },
+                        )
+                      : unmatched.join(", "),
+                },
+              )
+            : "";
+        setImportSummary([imported, skipped].filter(Boolean).join(". "));
+      } catch (err) {
+        console.error("[FormFill] Form data import failed:", err);
+        setSaveError(
+          err instanceof Error
+            ? err.message
+            : t("formFill.importError", "Failed to import form data"),
+        );
+      }
+    },
+    [formState.fields, setValue, t],
+  );
+
   const handleExtractXlsx = useCallback(async () => {
     if (!currentFile) return;
     setExtracting(true);
@@ -541,36 +634,71 @@ const FormFill = (_props: BaseToolProps) => {
                     </Tooltip>
                   </div>
 
+                  <div className={styles.importRow}>
+                    <Tooltip
+                      label={t(
+                        "formFill.importTooltip",
+                        "Import values from an Acrobat XFDF or FDF export",
+                      )}
+                      withArrow
+                      position="bottom"
+                    >
+                      <Button
+                        variant="secondary"
+                        leftSection={<FileUploadIcon sx={{ fontSize: 14 }} />}
+                        onClick={() => importInputRef.current?.click()}
+                        size="sm"
+                      >
+                        {t("formFill.importData", "Import form data")}
+                      </Button>
+                    </Tooltip>
+
+                    <input
+                      ref={importInputRef}
+                      type="file"
+                      accept=".xfdf,.fdf,application/vnd.adobe.xfdf,application/vnd.fdf"
+                      hidden
+                      onChange={(e) => {
+                        const file = e.currentTarget.files?.[0];
+                        // Clear first so re-picking the same file re-fires.
+                        e.currentTarget.value = "";
+                        if (file) void handleImportFormData(file);
+                      }}
+                    />
+                  </div>
+
+                  {/* Four formats don't fit this panel with an icon each, so
+                      the row is labelled once instead. */}
+                  <Text size="xs" c="dimmed" className={styles.exportLabel}>
+                    <FileDownloadIcon sx={{ fontSize: 12 }} />
+                    {t("formFill.exportAs", "Export data as")}
+                  </Text>
                   <div className={styles.secondaryActions}>
-                    <Button
-                      variant="secondary"
-                      leftSection={<FileDownloadIcon sx={{ fontSize: 14 }} />}
-                      loading={extracting}
-                      onClick={handleExtractJson}
-                      size="sm"
-                    >
-                      JSON
-                    </Button>
-
-                    <Button
-                      variant="secondary"
-                      leftSection={<FileDownloadIcon sx={{ fontSize: 14 }} />}
-                      loading={extracting}
-                      onClick={handleExtractCsv}
-                      size="sm"
-                    >
-                      CSV
-                    </Button>
-
-                    <Button
-                      variant="secondary"
-                      leftSection={<FileDownloadIcon sx={{ fontSize: 14 }} />}
-                      loading={extracting}
-                      onClick={handleExtractXlsx}
-                      size="sm"
-                    >
-                      XLSX
-                    </Button>
+                    {(
+                      [
+                        ["XFDF", handleExportXfdf],
+                        ["JSON", handleExtractJson],
+                        ["CSV", handleExtractCsv],
+                        ["XLSX", handleExtractXlsx],
+                      ] as const
+                    ).map(([label, onClick]) => (
+                      <Button
+                        key={label}
+                        variant="secondary"
+                        loading={extracting}
+                        onClick={() => void onClick()}
+                        size="sm"
+                        aria-label={t(
+                          "formFill.exportAsFormat",
+                          "Export as {{format}}",
+                          {
+                            format: label,
+                          },
+                        )}
+                      >
+                        {label}
+                      </Button>
+                    ))}
                   </div>
                 </div>
 
@@ -580,6 +708,12 @@ const FormFill = (_props: BaseToolProps) => {
                     <Text size="xs">{saveError}</Text>
                   </Alert>
                 )}
+
+                {importSummary && (
+                  <Alert color="blue" variant="light" p="xs" radius="sm">
+                    <Text size="xs">{importSummary}</Text>
+                  </Alert>
+                )}
               </>
             )}
 
diff --git a/frontend/editor/src/core/tools/formFill/FormFillContext.tsx b/frontend/editor/src/core/tools/formFill/FormFillContext.tsx
index 4377984111..a62c7488a0 100644
--- a/frontend/editor/src/core/tools/formFill/FormFillContext.tsx
+++ b/frontend/editor/src/core/tools/formFill/FormFillContext.tsx
@@ -60,8 +60,22 @@ class FormValuesStore {
 
   private _values: Record<string, string> = {};
 
+  /**
+   * Snapshot for useSyncExternalStore. `_values` is mutated in place to keep
+   * per-keystroke writes cheap, so returning it directly would hand React a
+   * reference that never changes — subscribers would never re-render and any
+   * memo keyed on it would stay stale. Copy lazily instead: the cost is paid
+   * once per change, and only by the components that read all values.
+   */
+  private _snapshot: Record<string, string> = {};
+  private _snapshotVersion = -1;
+
   get values(): Record<string, string> {
-    return this._values;
+    if (this._snapshotVersion !== this._version) {
+      this._snapshot = { ...this._values };
+      this._snapshotVersion = this._version;
+    }
+    return this._snapshot;
   }
 
   private _version = 0;
diff --git a/frontend/editor/src/core/utils/formDataExchange.test.ts b/frontend/editor/src/core/utils/formDataExchange.test.ts
new file mode 100644
index 0000000000..adf90db1e5
--- /dev/null
+++ b/frontend/editor/src/core/utils/formDataExchange.test.ts
@@ -0,0 +1,406 @@
+/**
+ * Unit tests for XFDF / FDF form-data exchange.
+ */
+
+import { describe, test, expect } from "vitest";
+import {
+  buildXfdf,
+  decodeLatin1,
+  looksLikeFdf,
+  looksLikeXfdf,
+  parseFdf,
+  parseFormDataFile,
+  parseXfdf,
+  reconcileImportedValues,
+} from "@app/utils/formDataExchange";
+
+const XFDF = `<?xml version="1.0" encoding="UTF-8"?>
+<xfdf xmlns="http://ns.adobe.com/xfdf/" xml:space="preserve">
+  <f href="application-form.pdf"/>
+  <ids original="7A9B" modified="7A9C"/>
+  <fields>
+    <field name="FullName">
+      <value>Ada Lovelace</value>
+    </field>
+    <field name="Address">
+      <field name="Street">
+        <value>1 High Street</value>
+      </field>
+      <field name="City">
+        <value>London</value>
+      </field>
+    </field>
+    <field name="AgreeToTerms">
+      <value>Yes</value>
+    </field>
+    <field name="Languages">
+      <value>English</value>
+      <value>French</value>
+    </field>
+    <field name="Notes">
+      <value>  leading and trailing spaces  </value>
+    </field>
+  </fields>
+</xfdf>
+`;
+
+const FDF = `%FDF-1.2
+1 0 obj
+<<
+/FDF
+<<
+/Fields [
+<< /T (FullName) /V (Ada Lovelace) >>
+<< /T (Address) /Kids [ << /T (Street) /V (1 High Street) >> << /T (City) /V (London) >> ] >>
+<< /T (AgreeToTerms) /V /Yes >>
+<< /T (Languages) /V [ (English) (French) ] >>
+<< /T (Escaped) /V (a \\(nested\\) value) >>
+]
+/F (application-form.pdf)
+>>
+>>
+endobj
+trailer
+<< /Root 1 0 R >>
+%%EOF
+`;
+
+/**
+ * Real Apryse output: no whitespace between elements, line breaks *inside*
+ * the tags, and `<f>` before `<fields>`.
+ */
+const APRYSE_XFDF = `<?xml version="1.0" encoding="UTF-8"?>
+<xfdf xmlns="http://ns.adobe.com/xfdf/" xml:space="preserve"
+><f href="form1.pdf"
+/><fields
+><field name="c1-1"
+><value
+>Yes</value
+></field
+><field name="c1-3"
+><value
+>Off</value
+></field
+><field name="f1-1"
+><value
+>John Smith</value
+></field
+></fields
+><ids original="67B7546B7635ED89E01C7BB03AA168C7" modified="4284ECDB48B3FF4398965B6C2FF19638"
+/></xfdf
+>`;
+
+/** Real output with /V before /T and a blank line before the header. */
+const SF52_FDF = `
+%FDF-1.2
+1 0 obj
+<<
+/FDF << /Fields [
+  << /V (Sample EdLevel)/T (EdLevel) >>
+<< /V (Sample DegAttan)/T (DegAttan) >>
+
+] >>
+>>
+endobj
+trailer
+<<
+/Root 1 0 R
+>>
+%%EOF
+`;
+
+/** Real DevExpress output: hex strings with UTF-16BE values throughout. */
+const HEX_FDF = `%FDF-1.2
+1 0 obj
+<</FDF <</Fields [<</T <67656E6572617465417070656172616E636573> /V <FEFF> >>
+ <</T <4C6173744E616D65> /V <FEFF0053006D006900740068> >>
+ <</T <46697273744E616D65> /V <FEFF004A006F0068006E0020> >>
+] >>
+ /Version /1#2E2 >>
+endobj
+trailer
+<</Root 1 0 R >>
+%%EOF
+`;
+
+/**
+ * Real Syncfusion output: each field is its own indirect object and /Fields
+ * is an array of references, reached through a second reference (/FDF 8 0 R).
+ */
+const INDIRECT_FDF = `%FDF-1.2
+1 0 obj<</T <46697273744E616D65> /V <41424344> >>endobj
+2 0 obj<</T <4C6173744E616D65> /V <58595A> >>endobj
+3 0 obj<</T <436F6D70616E79206E616D65> /V <53796E63667573696F6E> >>endobj
+8 0 obj<</F <4163726F466F726D31>  /Fields [1 0 R 2 0 R 3 0 R ]>>endobj
+9 0 obj<</Version /1.4 /FDF 8 0 R>>endobj
+trailer
+<</Root 9 0 R>>
+`;
+
+/**
+ * jsdom has no real `Blob.arrayBuffer()`, and setupTests stubs it with eight
+ * dummy bytes — so a plain `new File([...])` cannot be read back. Attach a
+ * working implementation for the files under test.
+ */
+function fileWithBytes(content: string | Uint8Array, name: string): File {
+  const bytes =
+    typeof content === "string" ? new TextEncoder().encode(content) : content;
+  const buffer = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(buffer).set(bytes);
+  const file = new File([buffer], name);
+  Object.defineProperty(file, "arrayBuffer", { value: async () => buffer });
+  return file;
+}
+
+/** Build an FDF byte array whose value is a UTF-16BE string, as Acrobat writes. */
+function fdfWithUtf16Value(fieldName: string, value: string): Uint8Array {
+  const bytes: number[] = [];
+  const push = (text: string) => {
+    for (const ch of text) bytes.push(ch.charCodeAt(0));
+  };
+  push(`%FDF-1.2\n1 0 obj\n<< /FDF << /Fields [ << /T (${fieldName}) /V (`);
+  bytes.push(0xfe, 0xff); // UTF-16BE byte-order mark
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    bytes.push((code >> 8) & 0xff, code & 0xff);
+  }
+  push(") >> ] >> >>\nendobj\n%%EOF\n");
+  return new Uint8Array(bytes);
+}
+
+describe("formDataExchange", () => {
+  describe("parseXfdf", () => {
+    test("reads flat and hierarchical field values", () => {
+      const { values, pdfHref, format } = parseXfdf(XFDF);
+      expect(format).toBe("xfdf");
+      expect(pdfHref).toBe("application-form.pdf");
+      expect(values.FullName).toBe("Ada Lovelace");
+      expect(values["Address.Street"]).toBe("1 High Street");
+      expect(values["Address.City"]).toBe("London");
+      expect(values.AgreeToTerms).toBe("Yes");
+    });
+
+    test("joins multiple values for multi-select fields", () => {
+      expect(parseXfdf(XFDF).values.Languages).toBe("English,French");
+    });
+
+    test("preserves whitespace, since xml:space is preserve", () => {
+      expect(parseXfdf(XFDF).values.Notes).toBe(
+        "  leading and trailing spaces  ",
+      );
+    });
+
+    test("a branch field with no value of its own is not emitted", () => {
+      expect(parseXfdf(XFDF).values).not.toHaveProperty("Address");
+    });
+
+    test("rejects malformed XML", () => {
+      expect(() => parseXfdf("<xfdf><fields></xfdf>")).toThrow(/not valid XML/);
+    });
+
+    test("rejects XML that is not XFDF", () => {
+      expect(() => parseXfdf('<?xml version="1.0"?><foo/>')).toThrow(
+        /expected an <xfdf> root/,
+      );
+    });
+  });
+
+  describe("parseFdf", () => {
+    test("reads values, Kids hierarchy and name values", () => {
+      const { values, pdfHref, format } = parseFdf(FDF);
+      expect(format).toBe("fdf");
+      expect(pdfHref).toBe("application-form.pdf");
+      expect(values.FullName).toBe("Ada Lovelace");
+      expect(values["Address.Street"]).toBe("1 High Street");
+      expect(values["Address.City"]).toBe("London");
+      // A checkbox export value is stored as a PDF name, not a string.
+      expect(values.AgreeToTerms).toBe("Yes");
+    });
+
+    test("joins array values for multi-select fields", () => {
+      expect(parseFdf(FDF).values.Languages).toBe("English,French");
+    });
+
+    test("decodes escaped parentheses", () => {
+      expect(parseFdf(FDF).values.Escaped).toBe("a (nested) value");
+    });
+
+    test("decodes UTF-16BE strings", () => {
+      const bytes = fdfWithUtf16Value("Name", "Ada Ada € ünïcode");
+      expect(parseFdf(bytes).values.Name).toBe("Ada Ada € ünïcode");
+    });
+
+    test("rejects a file with no /FDF dictionary", () => {
+      expect(() => parseFdf("%PDF-1.7\n<< /Type /Catalog >>\n")).toThrow(
+        /no \/FDF dictionary/,
+      );
+    });
+
+    test("rejects an FDF with no /Fields array", () => {
+      expect(() => parseFdf("%FDF-1.2\n<< /FDF << /F (x.pdf) >> >>\n")).toThrow(
+        /no \/Fields array/,
+      );
+    });
+  });
+
+  describe("real-world exports", () => {
+    test("Apryse XFDF with line breaks inside tags", () => {
+      const { values, pdfHref } = parseXfdf(APRYSE_XFDF);
+      expect(pdfHref).toBe("form1.pdf");
+      expect(values).toEqual({
+        "c1-1": "Yes",
+        "c1-3": "Off",
+        "f1-1": "John Smith",
+      });
+    });
+
+    test("FDF with /V before /T and a leading blank line", () => {
+      expect(parseFdf(SF52_FDF).values).toEqual({
+        EdLevel: "Sample EdLevel",
+        DegAttan: "Sample DegAttan",
+      });
+    });
+
+    test("FDF using hex strings and UTF-16BE values", () => {
+      expect(parseFdf(HEX_FDF).values).toEqual({
+        generateAppearances: "",
+        LastName: "Smith",
+        FirstName: "John ",
+      });
+    });
+
+    test("FDF whose fields are indirect objects behind a /FDF reference", () => {
+      const { values, pdfHref } = parseFdf(INDIRECT_FDF);
+      expect(pdfHref).toBe("AcroForm1");
+      expect(values).toEqual({
+        FirstName: "ABCD",
+        LastName: "XYZ",
+        "Company name": "Syncfusion",
+      });
+    });
+
+    test("a reference cycle terminates with an error instead of hanging", () => {
+      const cyclic = `%FDF-1.2
+1 0 obj<</FDF 2 0 R>>endobj
+2 0 obj 1 0 R endobj
+trailer<</Root 1 0 R>>
+`;
+      // Which error it lands on doesn't matter; not hanging does.
+      expect(() => parseFdf(cyclic)).toThrow(/no form data|no \/FDF/);
+    });
+  });
+
+  describe("format detection", () => {
+    test("recognises each format and rejects the other", () => {
+      expect(looksLikeXfdf(XFDF)).toBe(true);
+      expect(looksLikeFdf(XFDF)).toBe(false);
+      expect(looksLikeFdf(FDF)).toBe(true);
+      expect(looksLikeXfdf(FDF)).toBe(false);
+    });
+  });
+
+  describe("buildXfdf", () => {
+    test("round-trips flat, hierarchical and multi-select values", () => {
+      const values = {
+        FullName: "Ada Lovelace",
+        "Address.Street": "1 High Street",
+        Languages: "English,French",
+      };
+      const xml = buildXfdf(values, {
+        pdfHref: "application-form.pdf",
+        multiSelectFields: ["Languages"],
+      });
+
+      const reparsed = parseXfdf(xml);
+      expect(reparsed.values).toEqual(values);
+      expect(reparsed.pdfHref).toBe("application-form.pdf");
+      // The hierarchy is rebuilt as nested elements, not a literal dotted name.
+      expect(xml).toContain('<field name="Address">');
+      expect(xml).toContain('<field name="Street">');
+    });
+
+    test("commas in a single-value field are not split into two values", () => {
+      const xml = buildXfdf({ Address: "1 High Street, London" });
+      expect(parseXfdf(xml).values.Address).toBe("1 High Street, London");
+      expect(xml.match(/<value>/g)).toHaveLength(1);
+    });
+
+    test("escapes XML metacharacters in names and values", () => {
+      const xml = buildXfdf({ "a&b": '<script> "quoted"' });
+      expect(xml).toContain('name="a&amp;b"');
+      expect(xml).toContain("&lt;script&gt; &quot;quoted&quot;");
+      expect(parseXfdf(xml).values["a&b"]).toBe('<script> "quoted"');
+    });
+
+    test("omits the <f> element when no href is given", () => {
+      expect(buildXfdf({ A: "1" })).not.toContain("<f ");
+    });
+
+    test("an empty form still produces valid XFDF", () => {
+      expect(parseXfdf(buildXfdf({})).values).toEqual({});
+    });
+  });
+
+  describe("parseFormDataFile", () => {
+    test("detects XFDF from content, not the extension", async () => {
+      const file = fileWithBytes(XFDF, "data.txt");
+      expect((await parseFormDataFile(file)).format).toBe("xfdf");
+    });
+
+    test("detects FDF from content, not the extension", async () => {
+      const file = fileWithBytes(FDF, "data.txt");
+      expect((await parseFormDataFile(file)).format).toBe("fdf");
+    });
+
+    test("reads UTF-8 XFDF correctly", async () => {
+      const xml = buildXfdf({ Name: "Ünïcode € dash" });
+      const file = fileWithBytes(xml, "data.xfdf");
+      expect((await parseFormDataFile(file)).values.Name).toBe(
+        "Ünïcode € dash",
+      );
+    });
+
+    test("reads binary FDF with UTF-16 values", async () => {
+      const file = fileWithBytes(
+        fdfWithUtf16Value("Name", "Ünïcode € dash"),
+        "data.fdf",
+      );
+      expect((await parseFormDataFile(file)).values.Name).toBe(
+        "Ünïcode € dash",
+      );
+    });
+
+    test("rejects anything else", async () => {
+      const file = fileWithBytes('{"a":1}', "data.json");
+      await expect(parseFormDataFile(file)).rejects.toThrow(
+        /Unrecognised form data file/,
+      );
+    });
+  });
+
+  describe("decodeLatin1", () => {
+    test("maps every byte to one character", () => {
+      const bytes = new Uint8Array([0x00, 0x41, 0xfe, 0xff]);
+      const text = decodeLatin1(bytes);
+      expect(text).toHaveLength(4);
+      expect(text.charCodeAt(2)).toBe(0xfe);
+    });
+  });
+
+  describe("reconcileImportedValues", () => {
+    test("splits values into applied and unmatched", () => {
+      const { applied, unmatched } = reconcileImportedValues(
+        { A: "1", B: "2", C: "3" },
+        ["A", "C"],
+      );
+      expect(applied).toEqual({ A: "1", C: "3" });
+      expect(unmatched).toEqual(["B"]);
+    });
+
+    test("an empty document matches nothing", () => {
+      const { applied, unmatched } = reconcileImportedValues({ A: "1" }, []);
+      expect(applied).toEqual({});
+      expect(unmatched).toEqual(["A"]);
+    });
+  });
+});
diff --git a/frontend/editor/src/core/utils/formDataExchange.ts b/frontend/editor/src/core/utils/formDataExchange.ts
new file mode 100644
index 0000000000..cc93e70390
--- /dev/null
+++ b/frontend/editor/src/core/utils/formDataExchange.ts
@@ -0,0 +1,439 @@
+/**
+ * XFDF and FDF form-data exchange.
+ *
+ * These are Acrobat's two interchange formats for the *values* of a PDF form,
+ * separate from the document itself. They are what a "submit form" button
+ * posts, what "Export Data" writes, and what most enterprise form pipelines
+ * hand around - so reading and writing them is the difference between
+ * inheriting an Acrobat forms workflow and having to rebuild it.
+ *
+ * **XFDF** (ISO 19444-1) is XML:
+ *
+ *   <xfdf xmlns="http://ns.adobe.com/xfdf/" xml:space="preserve">
+ *     <f href="form.pdf"/>
+ *     <fields>
+ *       <field name="Name"><value>Ada</value></field>
+ *       <field name="Address">
+ *         <field name="Street"><value>1 High St</value></field>
+ *       </field>
+ *     </fields>
+ *   </xfdf>
+ *
+ * Nested `<field>` elements build a dotted fully-qualified name
+ * (`Address.Street`), matching how PDF names hierarchical fields. A field
+ * with several `<value>` children is a multi-select list box.
+ *
+ * **FDF** is PDF object syntax:
+ *
+ *   %FDF-1.2
+ *   1 0 obj << /FDF << /Fields [ << /T (Name) /V (Ada) >> ] /F (form.pdf) >> >>
+ *   endobj
+ *
+ * with `/Kids` for hierarchy and `/V` holding the value - a string for text
+ * fields, a name for checkboxes and radio groups.
+ */
+
+import {
+  psArray,
+  psDict,
+  psName,
+  PsName,
+  PsRef,
+  readObjects,
+  type PsDict,
+  type PsValue,
+} from "@app/utils/postscriptObjects";
+
+export type FormDataFormat = "xfdf" | "fdf";
+
+export interface FormDataImport {
+  format: FormDataFormat;
+  /**
+   * Field values keyed by fully-qualified name. Multi-select values are
+   * comma-joined, matching how the form store holds them.
+   */
+  values: Record<string, string>;
+  /** `<f href>` / `/F` - the PDF the data was exported from, if declared. */
+  pdfHref?: string;
+}
+
+/** Join a hierarchical field path the way PDF fully-qualified names do. */
+const qualify = (path: string[]): string => path.join(".");
+
+// ---------------------------------------------------------------------------
+// XFDF
+// ---------------------------------------------------------------------------
+
+const XFDF_NS = "http://ns.adobe.com/xfdf/";
+
+/**
+ * Parse XFDF text into field values.
+ *
+ * @throws if the text is not well-formed XML or has no `<xfdf>` root.
+ */
+export function parseXfdf(xmlText: string): FormDataImport {
+  const doc = new DOMParser().parseFromString(xmlText, "application/xml");
+
+  // DOMParser signals XML syntax errors with a <parsererror> node.
+  const parserError = doc.getElementsByTagName("parsererror")[0];
+  if (parserError) {
+    throw new Error(
+      `File is not valid XML: ${parserError.textContent?.trim().split("\n")[0] ?? "unknown error"}`,
+    );
+  }
+
+  const root = doc.documentElement;
+  if (!root || root.localName !== "xfdf") {
+    throw new Error("Not an XFDF file: expected an <xfdf> root element.");
+  }
+
+  const values: Record<string, string> = {};
+
+  const walk = (container: Element, path: string[]): void => {
+    for (const child of Array.from(container.children)) {
+      if (child.localName !== "field") continue;
+      const name = child.getAttribute("name");
+      if (!name) continue;
+      const nextPath = [...path, name];
+
+      // A field is either a leaf holding <value>s or a branch holding
+      // more <field>s. Adobe permits both, so collect values first.
+      const valueNodes = Array.from(child.children).filter(
+        (node) => node.localName === "value",
+      );
+      if (valueNodes.length > 0) {
+        // xml:space="preserve" is the XFDF default; never trim.
+        values[qualify(nextPath)] = valueNodes
+          .map((node) => node.textContent ?? "")
+          .join(",");
+      }
+      walk(child, nextPath);
+    }
+  };
+
+  const fieldsEl = Array.from(root.children).find(
+    (child) => child.localName === "fields",
+  );
+  if (fieldsEl) walk(fieldsEl, []);
+
+  const fEl = Array.from(root.children).find(
+    (child) => child.localName === "f",
+  );
+  const href = fEl?.getAttribute("href") ?? undefined;
+
+  return { format: "xfdf", values, pdfHref: href };
+}
+
+/** True when the text looks like XFDF. */
+export function looksLikeXfdf(text: string): boolean {
+  const head = text.slice(0, 2048);
+  return head.includes(XFDF_NS) || /<xfdf[\s>]/.test(head);
+}
+
+const XML_ESCAPES: Record<string, string> = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+};
+
+const escapeXml = (value: string): string =>
+  value.replace(/[&<>"]/g, (ch) => XML_ESCAPES[ch]);
+
+/**
+ * A tree node used to rebuild the `<field>` hierarchy from dotted names on
+ * export, so `Address.Street` round-trips as nested elements rather than a
+ * single field literally named "Address.Street".
+ */
+interface FieldNode {
+  children: Map<string, FieldNode>;
+  values?: string[];
+}
+
+const emptyNode = (): FieldNode => ({ children: new Map() });
+
+function buildFieldTree(
+  values: Record<string, string>,
+  multiSelectFields: ReadonlySet<string>,
+): FieldNode {
+  const root = emptyNode();
+  for (const [name, value] of Object.entries(values)) {
+    let node = root;
+    for (const segment of name.split(".")) {
+      let child = node.children.get(segment);
+      if (!child) {
+        child = emptyNode();
+        node.children.set(segment, child);
+      }
+      node = child;
+    }
+    // Only split on commas for fields the form actually declares as
+    // multi-select - a comma in an address line is not a value separator.
+    node.values = multiSelectFields.has(name)
+      ? value.split(",").filter((part) => part.length > 0)
+      : [value];
+  }
+  return root;
+}
+
+function serializeFieldNode(
+  name: string,
+  node: FieldNode,
+  indent: string,
+): string {
+  const lines: string[] = [`${indent}<field name="${escapeXml(name)}">`];
+  for (const value of node.values ?? []) {
+    lines.push(`${indent}  <value>${escapeXml(value)}</value>`);
+  }
+  for (const [childName, child] of node.children) {
+    lines.push(serializeFieldNode(childName, child, `${indent}  `));
+  }
+  lines.push(`${indent}</field>`);
+  return lines.join("\n");
+}
+
+export interface BuildXfdfOptions {
+  /** Written as `<f href>` so Acrobat can reopen the source document. */
+  pdfHref?: string;
+  /**
+   * Fields whose value is a comma-joined multi-selection, so they can be
+   * written back out as separate `<value>` elements.
+   */
+  multiSelectFields?: Iterable<string>;
+}
+
+/**
+ * Serialize form values as XFDF.
+ *
+ * The output is accepted by Acrobat's Import Data and by any XFDF-aware form
+ * server, which is the point: a form filled in Stirling can be handed back to
+ * an Acrobat-based process.
+ */
+export function buildXfdf(
+  values: Record<string, string>,
+  options: BuildXfdfOptions = {},
+): string {
+  const tree = buildFieldTree(values, new Set(options.multiSelectFields ?? []));
+  const fields = Array.from(tree.children).map(([name, node]) =>
+    serializeFieldNode(name, node, "    "),
+  );
+
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<xfdf xmlns="http://ns.adobe.com/xfdf/" xml:space="preserve">',
+    ...(options.pdfHref ? [`  <f href="${escapeXml(options.pdfHref)}"/>`] : []),
+    "  <fields>",
+    ...fields,
+    "  </fields>",
+    "</xfdf>",
+    "",
+  ].join("\n");
+}
+
+// ---------------------------------------------------------------------------
+// FDF
+// ---------------------------------------------------------------------------
+
+/**
+ * Decode a PDF text string. Strings prefixed with the UTF-16BE byte-order
+ * mark carry non-Latin text; everything else is PDFDocEncoding, which is
+ * close enough to latin1 for field values.
+ */
+function decodePdfString(raw: string): string {
+  if (
+    raw.length >= 2 &&
+    raw.charCodeAt(0) === 0xfe &&
+    raw.charCodeAt(1) === 0xff
+  ) {
+    let out = "";
+    for (let i = 2; i + 1 < raw.length; i += 2) {
+      out += String.fromCharCode(
+        (raw.charCodeAt(i) << 8) | raw.charCodeAt(i + 1),
+      );
+    }
+    return out;
+  }
+  return raw;
+}
+
+/**
+ * Follow indirect references to their object bodies. Writers such as
+ * Syncfusion emit every field as its own `N 0 obj`, so `/Fields` is an array
+ * of references rather than inline dictionaries.
+ */
+type Resolver = (value: PsValue) => PsValue;
+
+function makeResolver(indirect: Map<number, PsValue>): Resolver {
+  return function resolve(value: PsValue): PsValue {
+    const seen = new Set<number>();
+    let current = value;
+    while (current instanceof PsRef) {
+      // A reference cycle would otherwise spin forever.
+      if (seen.has(current.objectNumber)) return null;
+      seen.add(current.objectNumber);
+      current = indirect.get(current.objectNumber) ?? null;
+    }
+    return current;
+  };
+}
+
+/** Render an FDF `/V` entry as the string the form store holds. */
+function fdfValueToString(
+  value: PsValue,
+  resolve: Resolver,
+): string | undefined {
+  const resolved = resolve(value);
+  if (typeof resolved === "string") return decodePdfString(resolved);
+  // Checkboxes and radio groups store their export value as a name.
+  if (resolved instanceof PsName) return resolved.name;
+  if (typeof resolved === "number") return String(resolved);
+  if (Array.isArray(resolved)) {
+    // Multi-select list boxes hold an array of selected export values.
+    const parts = resolved
+      .map((item) => fdfValueToString(item, resolve))
+      .filter((item): item is string => item !== undefined);
+    return parts.length > 0 ? parts.join(",") : undefined;
+  }
+  return undefined;
+}
+
+function walkFdfFields(
+  fields: PsValue[],
+  path: string[],
+  values: Record<string, string>,
+  resolve: Resolver,
+): void {
+  for (const entry of fields) {
+    const field = psDict(resolve(entry));
+    if (!field) continue;
+    const title = resolve(field.T);
+    const name =
+      typeof title === "string" ? decodePdfString(title) : psName(title);
+    if (!name) continue;
+    const nextPath = [...path, name];
+
+    if (field.V !== undefined) {
+      const value = fdfValueToString(field.V, resolve);
+      if (value !== undefined) values[qualify(nextPath)] = value;
+    }
+    const kids = psArray(resolve(field.Kids));
+    if (kids) walkFdfFields(kids, nextPath, values, resolve);
+  }
+}
+
+/**
+ * Decode bytes as latin1 so every byte maps to one char, preserving the
+ * UTF-16 sequences inside PDF strings for {@link decodePdfString}.
+ */
+export function decodeLatin1(bytes: ArrayBuffer | Uint8Array): string {
+  const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  let out = "";
+  // Chunked to stay clear of the argument-count limit on large files.
+  const CHUNK = 0x8000;
+  for (let i = 0; i < view.length; i += CHUNK) {
+    out += String.fromCharCode(...view.subarray(i, i + CHUNK));
+  }
+  return out;
+}
+
+/**
+ * Parse FDF into field values.
+ *
+ * @param source Raw FDF bytes, or latin1-decoded text.
+ * @throws if no `/FDF` dictionary with a `/Fields` array is present.
+ */
+export function parseFdf(
+  source: ArrayBuffer | Uint8Array | string,
+): FormDataImport {
+  const text = typeof source === "string" ? source : decodeLatin1(source);
+  const { topLevelDicts, indirect } = readObjects(text);
+  const resolve = makeResolver(indirect);
+
+  let fdf: PsDict | undefined;
+  for (const dict of topLevelDicts) {
+    const candidate = psDict(resolve(dict.FDF));
+    if (candidate) {
+      fdf = candidate;
+      break;
+    }
+  }
+  if (!fdf) {
+    throw new Error(
+      "Not an FDF file: no /FDF dictionary found. Acrobat writes '<< /FDF << /Fields [...] >> >>'.",
+    );
+  }
+
+  const fields = psArray(resolve(fdf.Fields));
+  if (!fields) {
+    throw new Error(
+      "FDF file has no /Fields array - there is no form data to import.",
+    );
+  }
+
+  const values: Record<string, string> = {};
+  walkFdfFields(fields, [], values, resolve);
+
+  const href = resolve(fdf.F);
+  return {
+    format: "fdf",
+    values,
+    pdfHref: typeof href === "string" ? decodePdfString(href) : undefined,
+  };
+}
+
+/** True when the text looks like an FDF file. */
+export function looksLikeFdf(text: string): boolean {
+  return (
+    /%FDF-/.test(text.slice(0, 1024)) || /\/FDF\s*<</.test(text.slice(0, 8192))
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Format-sniffing entry point
+// ---------------------------------------------------------------------------
+
+/**
+ * Read an exported form-data file, detecting XFDF vs FDF from its contents
+ * rather than its extension.
+ *
+ * @throws with a user-readable message when the file is neither.
+ */
+export async function parseFormDataFile(
+  file: File | Blob,
+): Promise<FormDataImport> {
+  const buffer = await file.arrayBuffer();
+  const latin1 = decodeLatin1(buffer);
+
+  if (looksLikeFdf(latin1)) return parseFdf(latin1);
+  if (looksLikeXfdf(latin1)) {
+    // XFDF is XML and may be UTF-8; re-decode before handing it to DOMParser.
+    return parseXfdf(new TextDecoder("utf-8").decode(buffer));
+  }
+  throw new Error(
+    "Unrecognised form data file. Expected XFDF (<xfdf> XML) or FDF (%FDF-).",
+  );
+}
+
+/**
+ * Restrict imported values to fields the open document actually has, so a
+ * mismatched export cannot inject junk keys into the form store.
+ *
+ * Returns the values to apply plus the names that were dropped, which the UI
+ * reports rather than silently ignoring.
+ */
+export function reconcileImportedValues(
+  imported: Record<string, string>,
+  knownFieldNames: Iterable<string>,
+): { applied: Record<string, string>; unmatched: string[] } {
+  const known = new Set(knownFieldNames);
+  const applied: Record<string, string> = {};
+  const unmatched: string[] = [];
+  for (const [name, value] of Object.entries(imported)) {
+    if (known.has(name)) {
+      applied[name] = value;
+    } else {
+      unmatched.push(name);
+    }
+  }
+  return { applied, unmatched };
+}
diff --git a/frontend/editor/src/core/utils/postscriptObjects.ts b/frontend/editor/src/core/utils/postscriptObjects.ts
new file mode 100644
index 0000000000..b15bfeef18
--- /dev/null
+++ b/frontend/editor/src/core/utils/postscriptObjects.ts
@@ -0,0 +1,450 @@
+/**
+ * Minimal reader for PostScript / PDF object syntax.
+ *
+ * Shared by the two Adobe migration importers, which both consume files
+ * written in this syntax:
+ * - Distiller `.joboptions` - a `<< … >> setdistillerparams` dictionary
+ * - Acrobat `.fdf` form data - `1 0 obj << /FDF << … >> >> endobj`
+ *
+ * This is deliberately not a PDF parser: there is no xref, no stream
+ * decoding and no indirect-reference resolution. It reads the object
+ * *syntax* - dictionaries, arrays, names, strings, numbers - which is all
+ * either format needs.
+ *
+ * Strings are returned as raw bytes widened to one char each (latin1), so
+ * callers can detect a UTF-16 BOM and re-decode. Feed it latin1-decoded text
+ * for byte fidelity.
+ */
+
+/** A PostScript/PDF name (`/Bicubic`), kept distinct from a `(string)`. */
+export class PsName {
+  constructor(public readonly name: string) {}
+  toString(): string {
+    return this.name;
+  }
+}
+
+/**
+ * A PDF indirect reference (`8 0 R`). Only FDF uses these; resolve them with
+ * the `indirect` map from {@link readObjects}.
+ */
+export class PsRef {
+  constructor(
+    public readonly objectNumber: number,
+    public readonly generation: number,
+  ) {}
+}
+
+export type PsValue =
+  | string
+  | number
+  | boolean
+  | null
+  | PsName
+  | PsRef
+  | PsValue[]
+  | PsDict;
+
+export interface PsDict {
+  [key: string]: PsValue;
+}
+
+type Token =
+  | { kind: "dictOpen" }
+  | { kind: "dictClose" }
+  | { kind: "arrayOpen" }
+  | { kind: "arrayClose" }
+  | { kind: "name"; value: string }
+  | { kind: "string"; value: string }
+  | { kind: "number"; value: number }
+  | { kind: "boolean"; value: boolean }
+  | { kind: "null" }
+  | { kind: "operator"; value: string };
+
+const isWhitespace = (ch: string): boolean =>
+  ch === " " ||
+  ch === "\t" ||
+  ch === "\r" ||
+  ch === "\n" ||
+  ch === "\f" ||
+  ch === "\0";
+
+const isDelimiter = (ch: string): boolean =>
+  ch === "(" ||
+  ch === ")" ||
+  ch === "<" ||
+  ch === ">" ||
+  ch === "[" ||
+  ch === "]" ||
+  ch === "{" ||
+  ch === "}" ||
+  ch === "/" ||
+  ch === "%";
+
+/**
+ * Read a `(...)` literal string, honouring nested parentheses and the
+ * backslash escapes both PostScript and PDF allow (including `\ddd` octal).
+ */
+function readLiteralString(src: string, start: number): [string, number] {
+  let depth = 1;
+  let i = start;
+  let out = "";
+  while (i < src.length && depth > 0) {
+    const ch = src[i];
+    if (ch === "\\") {
+      const next = src[i + 1];
+      i += 2;
+      switch (next) {
+        case "n":
+          out += "\n";
+          break;
+        case "r":
+          out += "\r";
+          break;
+        case "t":
+          out += "\t";
+          break;
+        case "b":
+          out += "\b";
+          break;
+        case "f":
+          out += "\f";
+          break;
+        case "(":
+        case ")":
+        case "\\":
+          out += next;
+          break;
+        case "\n":
+          break; // line continuation
+        case "\r":
+          if (src[i] === "\n") i++;
+          break;
+        default:
+          if (next >= "0" && next <= "7") {
+            let octal = next;
+            while (octal.length < 3 && src[i] >= "0" && src[i] <= "7") {
+              octal += src[i];
+              i++;
+            }
+            out += String.fromCharCode(parseInt(octal, 8));
+          } else {
+            out += next ?? "";
+          }
+      }
+      continue;
+    }
+    if (ch === "(") depth++;
+    if (ch === ")") {
+      depth--;
+      if (depth === 0) {
+        i++;
+        break;
+      }
+    }
+    out += ch;
+    i++;
+  }
+  return [out, i];
+}
+
+/** Read a `<...>` hex string into its decoded bytes. */
+function readHexString(src: string, start: number): [string, number] {
+  let i = start;
+  let hex = "";
+  while (i < src.length && src[i] !== ">") {
+    if (!isWhitespace(src[i])) hex += src[i];
+    i++;
+  }
+  i++; // consume '>'
+  // An odd digit count is padded with a trailing zero, per the PDF spec.
+  if (hex.length % 2 === 1) hex += "0";
+  let out = "";
+  for (let j = 0; j + 1 < hex.length; j += 2) {
+    const code = parseInt(hex.slice(j, j + 2), 16);
+    if (!Number.isNaN(code)) out += String.fromCharCode(code);
+  }
+  return [out, i];
+}
+
+/**
+ * `#XX` hex escapes are legal inside PDF names (`/A#20B` is "A B"). Harmless
+ * to apply to PostScript names, which never contain `#`.
+ */
+const decodeNameEscapes = (raw: string): string =>
+  raw.includes("#")
+    ? raw.replace(/#([0-9a-fA-F]{2})/g, (_, hex) =>
+        String.fromCharCode(parseInt(hex, 16)),
+      )
+    : raw;
+
+function tokenize(src: string): Token[] {
+  const tokens: Token[] = [];
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+
+    if (isWhitespace(ch)) {
+      i++;
+      continue;
+    }
+
+    // Comments run to end of line. `%!PS`, `%FDF-1.2` and `%%EOF` are all
+    // just comments.
+    if (ch === "%") {
+      while (i < src.length && src[i] !== "\n" && src[i] !== "\r") i++;
+      continue;
+    }
+
+    if (ch === "<" && src[i + 1] === "<") {
+      tokens.push({ kind: "dictOpen" });
+      i += 2;
+      continue;
+    }
+    if (ch === ">" && src[i + 1] === ">") {
+      tokens.push({ kind: "dictClose" });
+      i += 2;
+      continue;
+    }
+    if (ch === "<") {
+      const [value, next] = readHexString(src, i + 1);
+      tokens.push({ kind: "string", value });
+      i = next;
+      continue;
+    }
+    if (ch === "[") {
+      tokens.push({ kind: "arrayOpen" });
+      i++;
+      continue;
+    }
+    if (ch === "]") {
+      tokens.push({ kind: "arrayClose" });
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      const [value, next] = readLiteralString(src, i + 1);
+      tokens.push({ kind: "string", value });
+      i = next;
+      continue;
+    }
+    // Procedure braces carry no data; drop the delimiters and let the
+    // contents tokenize as ordinary values.
+    if (ch === "{" || ch === "}") {
+      i++;
+      continue;
+    }
+    if (ch === "/") {
+      i++;
+      let name = "";
+      while (i < src.length && !isWhitespace(src[i]) && !isDelimiter(src[i])) {
+        name += src[i];
+        i++;
+      }
+      tokens.push({ kind: "name", value: decodeNameEscapes(name) });
+      continue;
+    }
+
+    let word = "";
+    while (i < src.length && !isWhitespace(src[i]) && !isDelimiter(src[i])) {
+      word += src[i];
+      i++;
+    }
+    if (word.length === 0) {
+      i++; // unrecognised delimiter, e.g. a stray ')'
+      continue;
+    }
+    if (word === "true" || word === "false") {
+      tokens.push({ kind: "boolean", value: word === "true" });
+    } else if (word === "null") {
+      tokens.push({ kind: "null" });
+    } else if (/^[+-]?(\d+\.?\d*|\.\d+)(e[+-]?\d+)?$/i.test(word)) {
+      tokens.push({ kind: "number", value: Number(word) });
+    } else {
+      tokens.push({ kind: "operator", value: word });
+    }
+  }
+  return tokens;
+}
+
+interface ParseCursor {
+  index: number;
+}
+
+/**
+ * Detect the `<num> <gen> R` indirect-reference triple. Without this, `8 0 R`
+ * would read as the number 8 and the reference would be lost.
+ */
+function readReferenceAt(
+  tokens: Token[],
+  index: number,
+): { ref: PsRef; next: number } | undefined {
+  const first = tokens[index];
+  const second = tokens[index + 1];
+  const third = tokens[index + 2];
+  if (
+    first?.kind === "number" &&
+    second?.kind === "number" &&
+    third?.kind === "operator" &&
+    third.value === "R"
+  ) {
+    return { ref: new PsRef(first.value, second.value), next: index + 3 };
+  }
+  return undefined;
+}
+
+function parseValue(tokens: Token[], cursor: ParseCursor): PsValue {
+  const token = tokens[cursor.index];
+  if (!token) return null;
+  // A close token means the key had no value; leave it for the caller so the
+  // enclosing dictionary/array still terminates correctly.
+  if (token.kind === "dictClose" || token.kind === "arrayClose") return null;
+
+  const reference = readReferenceAt(tokens, cursor.index);
+  if (reference) {
+    cursor.index = reference.next;
+    return reference.ref;
+  }
+
+  cursor.index++;
+  switch (token.kind) {
+    case "dictOpen":
+      return parseDict(tokens, cursor);
+    case "arrayOpen": {
+      const items: PsValue[] = [];
+      while (cursor.index < tokens.length) {
+        const next = tokens[cursor.index];
+        if (!next) break;
+        if (next.kind === "arrayClose") {
+          cursor.index++;
+          break;
+        }
+        if (next.kind === "dictClose") break; // malformed; let the dict close
+        items.push(parseValue(tokens, cursor));
+      }
+      return items;
+    }
+    case "name":
+      return new PsName(token.value);
+    case "string":
+      return token.value;
+    case "number":
+      return token.value;
+    case "boolean":
+      return token.value;
+    case "null":
+      return null;
+    default:
+      // A bare operator in value position (`R`, `obj`, …) is not data.
+      return new PsName(token.value);
+  }
+}
+
+/** Parse tokens positioned just after a `<<` up to the matching `>>`. */
+function parseDict(tokens: Token[], cursor: ParseCursor): PsDict {
+  const dict: PsDict = {};
+  while (cursor.index < tokens.length) {
+    const token = tokens[cursor.index];
+    if (!token) break;
+    if (token.kind === "dictClose") {
+      cursor.index++;
+      break;
+    }
+    if (token.kind !== "name") {
+      // Skip anything that isn't a key - keeps a malformed file from
+      // derailing the rest of the dictionary.
+      cursor.index++;
+      continue;
+    }
+    cursor.index++;
+    dict[token.value] = parseValue(tokens, cursor);
+  }
+  return dict;
+}
+
+export interface PostScriptObjects {
+  /**
+   * Every dictionary not nested inside another dictionary or array, in file
+   * order - so an FDF's `1 0 obj << … >>` body and its `trailer << … >>` each
+   * yield one entry, and a `.joboptions` file usually yields exactly one.
+   */
+  topLevelDicts: PsDict[];
+  /**
+   * Bodies of `<num> <gen> obj … endobj` definitions, keyed by object number,
+   * so {@link PsRef} values can be resolved.
+   */
+  indirect: Map<number, PsValue>;
+}
+
+/** Read every object in the source in a single tokenizing pass. */
+export function readObjects(src: string): PostScriptObjects {
+  const tokens = tokenize(src);
+  const topLevelDicts: PsDict[] = [];
+  const indirect = new Map<number, PsValue>();
+  const cursor: ParseCursor = { index: 0 };
+
+  while (cursor.index < tokens.length) {
+    // `<num> <gen> obj` opens an indirect definition. Capture the number so
+    // the body can be looked up, then let the body parse normally.
+    const first = tokens[cursor.index];
+    const second = tokens[cursor.index + 1];
+    const third = tokens[cursor.index + 2];
+    if (
+      first?.kind === "number" &&
+      second?.kind === "number" &&
+      third?.kind === "operator" &&
+      third.value === "obj"
+    ) {
+      cursor.index += 3;
+      const body = parseValue(tokens, cursor);
+      indirect.set(first.value, body);
+      const bodyDict = psDict(body);
+      if (bodyDict) topLevelDicts.push(bodyDict);
+      continue;
+    }
+
+    cursor.index++;
+    if (first.kind === "dictOpen") {
+      topLevelDicts.push(parseDict(tokens, cursor));
+    }
+  }
+
+  return { topLevelDicts, indirect };
+}
+
+/**
+ * Convenience wrapper over {@link readObjects} for callers that only need the
+ * dictionaries and have no indirect references to resolve.
+ */
+export function collectTopLevelDicts(src: string): PsDict[] {
+  return readObjects(src).topLevelDicts;
+}
+
+// ---------------------------------------------------------------------------
+// Typed accessors
+// ---------------------------------------------------------------------------
+
+export const psBoolean = (value: PsValue): boolean | undefined =>
+  typeof value === "boolean" ? value : undefined;
+
+export const psNumber = (value: PsValue): number | undefined =>
+  typeof value === "number" && Number.isFinite(value) ? value : undefined;
+
+/** Read a `/Name`, tolerating writers that quote it as a string. */
+export const psName = (value: PsValue): string | undefined => {
+  if (value instanceof PsName) return value.name;
+  if (typeof value === "string") return value;
+  return undefined;
+};
+
+export const psDict = (value: PsValue): PsDict | undefined =>
+  value !== null &&
+  typeof value === "object" &&
+  !Array.isArray(value) &&
+  !(value instanceof PsName) &&
+  !(value instanceof PsRef)
+    ? (value as PsDict)
+    : undefined;
+
+export const psArray = (value: PsValue): PsValue[] | undefined =>
+  Array.isArray(value) ? value : undefined;