JS 侧：invoke 与回调

  const callbacks = new Map()

  function registerCallback(callback, once) {
    const identifier = uid()
    callbacks.set(identifier, (data) => {
      if (once) {
        unregisterCallback(identifier)
      }
      return callback && callback(data)
    })
    return identifier
  }

  function unregisterCallback(id) {
    callbacks.delete(id)
  }

  function runCallback(id, data) {
    const callback = callbacks.get(id)
    if (callback) {
      callback(data)
    } else {
      console.warn(
        `[TAURI] Couldn't find callback id ${id}. This might happen when the app is reloaded while Rust is running an asynchronous operation.`
      )
    }
  }

        const callback = registerCallback((r) => {
          resolve(r)
          unregisterCallback(error)
        }, true)
        const error = registerCallback((e) => {
          reject(e)
          unregisterCallback(callback)
        }, true)

(function (message) {
  if (
    message instanceof ArrayBuffer
    || ArrayBuffer.isView(message)
    || Array.isArray(message)
  ) {
    return {
      contentType: 'application/octet-stream',
      data: message
    }
  } else {
    const data = JSON.stringify(message, (_k, val) => {
      // if this value changes, make sure to update it in:
      // 1. ipc.js
      // 2. core.ts
      const SERIALIZE_TO_IPC_FN = '__TAURI_TO_IPC_KEY__'

      if (val instanceof Map) {
        return Object.fromEntries(val.entries())
      } else if (val instanceof Uint8Array) {
        return Array.from(val)
      } else if (val instanceof ArrayBuffer) {
        return Array.from(new Uint8Array(val))
      } else if (
        typeof val === 'object'
        && val !== null
        && SERIALIZE_TO_IPC_FN in val
      ) {
        return val[SERIALIZE_TO_IPC_FN]()
      } else {
        return val
      }
    })
// ...

  const bytes = new Uint8Array([1, 2, 3]);
  const cases = [
    ['{a:1}', () => ({ a: 1 })],
    ["'hi'", () => 'hi'],
    ['null', () => null],
    ['undefined', () => undefined],
    ['Uint8Array[1,2,3]', () => bytes],
    ['ArrayBuffer[1,2,3]', () => bytes.buffer],
    ['Float32Array[1.5]', () => new Float32Array([1.5])],
    ['[1,2,3]', () => [1, 2, 3]],
    ['{bytes:Uint8Array[1,2]}', () => ({ bytes: new Uint8Array([1, 2]) })],
    ['{m:Map{k:1}}', () => ({ m: new Map([['k', 1]]) })],
  ];

REPORT {
 "fetch": [
  "{a:1} -> sent application/json {\"a\":1} | rust application/json Json({\"a\":1})",
  "'hi' -> sent application/json \"hi\" | rust application/json Json(\"hi\")",
  "null -> sent application/json null | rust application/json Json(null)",
  "undefined -> sent application/json {} | rust application/json Json({})",
  "Uint8Array[1,2,3] -> sent application/octet-stream Uint8Array | rust application/octet-stream Raw(3 bytes, head [1, 2, 3])",
  "ArrayBuffer[1,2,3] -> sent application/octet-stream ArrayBuffer | rust application/octet-stream Raw(3 bytes, head [1, 2, 3])",
  "Float32Array[1.5] -> sent application/octet-stream Float32Array | rust application/octet-stream Raw(4 bytes, head [0, 0, 192, 63])",
  "[1,2,3] -> sent application/octet-stream Array | rust application/octet-stream Raw(5 bytes, head [49, 44, 50, 44, 51])",
  "{bytes:Uint8Array[1,2]} -> sent application/json {\"bytes\":[1,2]} | rust application/json Json({\"bytes\":[1,2]})",
  "{m:Map{k:1}} -> sent application/json {\"m\":{\"k\":1}} | rust application/json Json({\"m\":{\"k\":1}})"
 ],
 "postMessage": [
  "{a:1} -> rust null Json({\"a\":1})",
  "'hi' -> rust null Json(\"hi\")",
  "null -> rust null Json(null)",
  "undefined -> rust null Json({})",
  "Uint8Array[1,2,3] -> rust null Json([1,2,3])",
  "ArrayBuffer[1,2,3] -> rust null Json([1,2,3])",
  "Float32Array[1.5] -> rust null Json({\"0\":1.5})",
  "[1,2,3] -> rust null Json([1,2,3])",
  "{bytes:Uint8Array[1,2]} -> rust null Json({\"bytes\":[1,2]})",
  "{m:Map{k:1}} -> rust null Json({\"m\":{\"k\":1}})"
 ],
...
}

 "fetchHeaders": {
  "body": "Json({})",
  "contentType": "application/json",
  "origin": "tauri://localhost",
  "xDemo": "yes"
 },
...
 "pmHeaders": {
  "body": "Json({})",
  "contentType": null,
  "origin": null,
  "xDemo": "yes"
 },

      fetch(window.__TAURI_INTERNALS__.convertFileSrc(cmd, 'ipc'), {
        method: 'POST',
        body: data,
        headers
      })
        .then((response) => {
          const callbackId =
            response.headers.get('Tauri-Response') === 'ok' ? callback : error
          // we need to split here because on Android the content-type gets duplicated
          switch ((response.headers.get('content-type') || '').split(',')[0]) {
            case 'application/json':
              return response.json().then((r) => [callbackId, r])
            case 'text/plain':
              return response.text().then((r) => [callbackId, r])
            default:
              return response.arrayBuffer().then((r) => [callbackId, r])
          }
        })
        .then(
          ([callbackId, data]) => {
            window.__TAURI_INTERNALS__.runCallback(callbackId, data)
          },
          (e) => {
            console.warn(
              'IPC custom protocol failed, Tauri will now use the postMessage interface instead',
              e
            )
            // failed to use the custom protocol IPC (either the webview blocked a custom protocol or it was a CSP error)
            // so we need to fallback to the postMessage interface
            customProtocolIpcFailed = true
            sendIpcMessage(message)
          }
        )

#[tauri::command]
fn not_json() -> Response {
  let n = NOT_JSON_CALLS.fetch_add(1, Ordering::SeqCst) + 1;
  println!("RUST not_json called, count = {n}");
  Response::new("hello".to_string())
}

RUST not_json called, count = 1
RUST not_json called, count = 2
REPORT {
 "callbacksBefore": 0,
 "notJsonRejected": "JSON error: expected value at line 1 column 1",
 "fetchesSoFar": [
  "ipc://localhost/not_json"
 ],
 "greet": "hello, after",
 "greetUsedFetch": false,
 "callbacksAfter": 0,
 "warns": [
  "IPC custom protocol failed, Tauri will now use the postMessage interface instead SyntaxError: The string did not match the expected pattern."
 ]
}

  const h = location.hash;
  if (h === '') {
    inv('slow', { ms: 300 });
    location.hash = '#2';
    location.reload();
  } else if (h === '#2') {
    await wait(800);
    const phase2 = { afterFetchReload: warns.slice(), callbacks: ti.callbacks.size };
    await forcePostMessage();
    inv('slow', { ms: 300 });
    location.hash = '#3:' + encodeURIComponent(JSON.stringify(phase2));
    location.reload();
  } else {
    await wait(800);
    const phase2 = JSON.parse(decodeURIComponent(h.slice(3)));
    ti.runCallback(12345, 'late');
    await done({ phase2, afterPostMessageReload: warns.slice(), callbacks: ti.callbacks.size });
  }

      const { data } = processIpcMessage({
        cmd,
        callback,
        error,
        options: {
          ...options,
          customProtocolIpcBlocked: customProtocolIpcFailed
        },
        payload,
        __TAURI_INVOKE_KEY__
      })
      // `window.ipc.postMessage` came from `tauri-runtime-wry` > `wry` [`with_ipc_handler`](https://github.com/tauri-apps/wry/blob/a0403b9e2f1ff9d73be7dce1184f058afcaa1d82/src/lib.rs#L1130)
      window.ipc.postMessage(data)

{\"cmd\":\"slow\",\"callback\":57647707,\"error\":704807906,\"options\":{\"customProtocolIpcBlocked\":true},\"payload\"...

RUST slow(300) start
RUST slow(300) start
RUST slow(300) responding
RUST slow(300) responding
RUST slow(300) start
RUST slow(300) responding
REPORT {
 "phase2": {
  "afterFetchReload": [
   "[TAURI] Couldn't find callback id 2053258919. This might happen when the app is reloaded while Rust is running an asynchronous operation."
  ],
  "callbacks": 0
 },
 "afterPostMessageReload": [
  "[TAURI] Couldn't find callback id 2554231366. This might happen when the app is reloaded while Rust is running an asynchronous operation.",
  "[TAURI] Couldn't find callback id 12345. This might happen when the app is reloaded while Rust is running an asynchronous operation."
 ],
 "callbacks": 0
}