@@ -61,7 +61,8 @@ The minified UMD is ~13 KB; the unminified is ~26 KB.
 1. Bump `version` in `package.json`.
 2. `npm install --package-lock-only` — keeps the lockfile's own `version` field in step. Easy to forget; 2.0.5 shipped with a lockfile still claiming 2.0.4 (harmless — `npm ci` doesn't validate it and the tarball excludes it — but it drifts).
 3. `npm run build` — propagates the new version into the banner of each `dist/` JS file (via the build script) and syncs `devbridge-autocomplete.jquery.json`.
-4. Commit as `chore(release): <version>`, then tag `v<version>` and push the tag — `.github/workflows/release.yml` fires on `v*`, re-runs the full CI sweep, publishes to npm with provenance (OIDC, no token), and opens the GitHub Release. Registry propagation lags the workflow by a minute or two, so `npm view` can still report the previous version right after a green run — confirm against `https://registry.npmjs.org/devbridge-autocomplete` before assuming the publish failed.
+4. Update the version stamp in `docs/index.htm` (the `stamp__big` / `stamp__line3` spans, around line 33) — it's hand-maintained and visible on the live demo, so it drifts silently. It sat at 2.0.2 while npm was on 2.0.5.
+5. Commit as `chore(release): <version>`, then tag `v<version>` and push the tag — `.github/workflows/release.yml` fires on `v*`, re-runs the full CI sweep, publishes to npm with provenance (OIDC, no token), and opens the GitHub Release. Registry propagation lags the workflow by a minute or two, so `npm view` can still report the previous version right after a green run — confirm against `https://registry.npmjs.org/devbridge-autocomplete` before assuming the publish failed.
 
 ## Updating dependencies
 
 
@@ -30,8 +30,8 @@ <h1 class="lockup">
         </div>
         <aside class="stamp" aria-hidden="true">
             <span class="stamp__line1">Version</span>
-            <span class="stamp__big">2.0.2</span>
-            <span class="stamp__line3">May &middot; 2026</span>
+            <span class="stamp__big">2.0.5</span>
+            <span class="stamp__line3">Sep &middot; 2026</span>
         </aside>
     </header>
 
 
@@ -245,6 +245,7 @@ non-standard payload, use `paramName` and `transformResult`:
 ```js
 $('#autocomplete').autocomplete({
     paramName: 'searchString',
+    dataType: 'json',
     transformResult: function (response) {
         return {
             suggestions: response.myData.map((item) => ({
@@ -256,16 +257,30 @@ $('#autocomplete').autocomplete({
 });
 ```
 
-`transformResult` receives the raw payload `$.ajax` resolved with, so its
-type is up to your service. In TypeScript you can annotate the parameter
-with your own response shape:
+**`dataType: 'json'` matters here.** `transformResult` receives whatever
+`$.ajax` resolved with, and the default `dataType` is `'text'` — so
+without it your callback is handed the raw response **string**, and
+`response.myData` is `undefined`. (The built-in `transformResult` copes by
+running `JSON.parse` on string input; a custom one replaces that.) Either
+set `dataType: 'json'` and let jQuery parse, or parse it yourself:
+
+```js
+transformResult: function (response) {
+    const parsed = typeof response === 'string' ? JSON.parse(response) : response;
+    return { suggestions: parsed.myData.map(/* … */) };
+}
+```
+
+In TypeScript the parameter is typed loosely, since only your service
+knows the payload shape — annotate it with your own type:
 
 ```ts
 interface MyResponse {
     myData: { valueField: string; dataField: number }[];
 }
 
 $('#autocomplete').autocomplete({
+    dataType: 'json',
     transformResult: (response: MyResponse) => ({
         suggestions: response.myData.map((item) => ({
             value: item.valueField,
 
@@ -168,6 +168,62 @@ describe("Autocomplete Async — transformResult", () => {
     });
 });
 
+// The default dataType is "text", so a custom transformResult is handed the raw
+// response string. With dataType: "json" jQuery parses first and the callback
+// sees an object — the form the readme documents for non-standard payloads.
+describe("Autocomplete Async — transformResult with dataType json", () => {
+    let instance;
+    let receivedType;
+
+    beforeEach(async () => {
+        await new Promise((resolve) => {
+            const input = document.createElement("input");
+            const url = "/test-transform-json";
+            const autocomplete = new $.Autocomplete(input, {
+                serviceUrl: url,
+                dataType: "json",
+                transformResult: function (response) {
+                    receivedType = typeof response;
+                    setTimeout(resolve, 0);
+
+                    return {
+                        suggestions: response.myData.map(function (item) {
+                            return { value: item.valueField, data: item.dataField };
+                        }),
+                    };
+                },
+            });
+
+            $.mockjax({
+                url,
+                responseTime: 50,
+                contentType: "application/json",
+                responseText: {
+                    myData: [
+                        { valueField: "Canada", dataField: "CA" },
+                        { valueField: "Cameroon", dataField: "CM" },
+                    ],
+                },
+            });
+
+            instance = autocomplete;
+
+            input.value = "C";
+            autocomplete.onValueChange();
+        });
+    });
+
+    it("Should hand transformResult a parsed object", () => {
+        expect(receivedType).toBe("object");
+    });
+
+    it("Should map a non-standard payload onto suggestions", () => {
+        expect(instance.suggestions.length).toBe(2);
+        expect(instance.suggestions[0].value).toBe("Canada");
+        expect(instance.suggestions[0].data).toBe("CA");
+    });
+});
+
 describe("Autocomplete Async — optional server query field", () => {
     let instance;