Channel

  constructor(onmessage?: (response: T) => void) {
    this.#onmessage = onmessage || (() => {})

    this.id = transformCallback<
      // Normal message
      | { message: T; index: number }
      // Message when the channel gets dropped in the rust side
      | { end: true; index: number }
    >((rawMessage) => {
      // ...
    })
  }
  // ...
  [SERIALIZE_TO_IPC_FN]() {
    return `__CHANNEL__:${this.id}`
  }

  toJSON(): string {
    // eslint-disable-next-line security/detect-object-injection
    return this[SERIALIZE_TO_IPC_FN]()
  }

#[tauri::command]
fn chan_id(ch: Channel<serde_json::Value>) -> u32 {
  let rust_made = Channel::<serde_json::Value>::new(|_| Ok(()));
  println!("RUST js channel id = {}, Channel::new id = {}", ch.id(), rust_made.id());
  ch.id()
}

  const a = new C(), b = new C();
  out.jsIds = [a.id, b.id];
  out.serialized = JSON.stringify({ ch: a });
  out.rustSees = await inv('chan_id', { ch: a });

RUST js channel id = 51725631, Channel::new id = 0
REPORT {
 "mode": "chan",
 "data": {
  "jsIds": [
   51725631,
   3354913994
  ],
  "serialized": "{\"ch\":\"__CHANNEL__:51725631\"}",
  "rustSees": 51725631,

      Box::new(move |body| {
        let current_index = counter.fetch_add(1, Ordering::Relaxed);

        if let Some(interceptor) = &webview.manager.channel_interceptor {
          if interceptor(&webview, callback_fn, current_index, &body) {
            return Ok(());
          }
        }

        match body {
          // Don't go through the fetch process if the payload is small
          InvokeResponseBody::Json(json_string)
            if json_string.len() < MAX_JSON_DIRECT_EXECUTE_THRESHOLD =>
          {
            webview.eval(format_raw_js(
              callback_id,
              format!("{{ message: {json_string}, index: {current_index} }}"),
            ))?;
          }
          InvokeResponseBody::Raw(bytes) if bytes.len() < MAX_RAW_DIRECT_EXECUTE_THRESHOLD => {
            let bytes_as_json_array = serde_json::to_string(&bytes)?;
            webview.eval(format_raw_js(callback_id, format!("{{ message: new Uint8Array({bytes_as_json_array}).buffer, index: {current_index} }}")))?;
          }
          // use the fetch API to speed up larger response payloads
          _ => {
            // the webview was closed (or replaced by a new one with the same label),
            // so nothing would ever fetch this data
            let Some(data_id) =
              webview
                .state::<ChannelDataIpcQueue>()
                .insert_if(webview.label(), body, || webview.is_registered())
            else {
              return Ok(());
            };

            webview.eval(format!(
              "window.__TAURI_INTERNALS__.invoke('{FETCH_CHANNEL_DATA_COMMAND}', null, {{ headers: {{ '{CHANNEL_ID_HEADER_NAME}': '{data_id}' }} }}).then((response) => window.__TAURI_INTERNALS__.runCallback({callback_id}, {{ message: response, index: {current_index} }})).catch(console.error)",
            ))?;
          }
        }

        Ok(())
      }),

/// Maximum size a JSON we should send directly without going through the fetch process
// 8192 byte JSON payload runs roughly 2x faster through eval than through fetch on WebView2 v135
const MAX_JSON_DIRECT_EXECUTE_THRESHOLD: usize = 8192;
// 1024 byte payload runs  roughly 30% faster through eval than through fetch on macOS
const MAX_RAW_DIRECT_EXECUTE_THRESHOLD: usize = 1024;

#[tauri::command]
fn chan_send(ch: Channel<InvokeResponseBody>, raw: bool, len: usize) -> tauri::Result<()> {
  if raw {
    ch.send(InvokeResponseBody::Raw(vec![1u8; len]))
  } else {
    let s = json_of_len("m", len);
    assert_eq!(s.len(), len);
    ch.send(InvokeResponseBody::Json(s))
  }
}

  "threshold": [
   {
    "raw": false,
    "len": 8191,
    "received": "string 8191",
    "fetches": 0
   },
   {
    "raw": false,
    "len": 8192,
    "received": "string 8192",
    "fetches": 1
   },
   {
    "raw": true,
    "len": 1023,
    "received": "ArrayBuffer 1023",
    "fetches": 0
   },
   {
    "raw": true,
    "len": 1024,
    "received": "ArrayBuffer 1024",
    "fetches": 1
   }
  ],

      const message = rawMessage.message
      // Process the message if we're at the right order
      if (index == this.#nextMessageIndex) {
        this.#deliver(message)
        this.#nextMessageIndex += 1

        // process pending messages
        while (this.#nextMessageIndex in this.#pendingMessages) {
          const message = this.#pendingMessages[this.#nextMessageIndex]
          this.#deliver(message)
          // eslint-disable-next-line @typescript-eslint/no-array-delete
          delete this.#pendingMessages[this.#nextMessageIndex]
          this.#nextMessageIndex += 1
        }

        if (this.#nextMessageIndex === this.#messageEndIndex) {
          this.cleanupCallback()
        }
      }
      // Queue the message if we're not
      else {
        // eslint-disable-next-line security/detect-object-injection
        this.#pendingMessages[index] = message
      }

#[tauri::command]
fn chan_order(ch: Channel<InvokeResponseBody>, sizes: Vec<usize>) -> tauri::Result<()> {
  for (i, len) in sizes.into_iter().enumerate() {
    ch.send(InvokeResponseBody::Json(json_of_len(&i.to_string(), len)))?;
  }
  Ok(())
}

  const sizes = [20000, 10, 10, 20000, 10, 10, 10];
  const rawLog = [];
  // ...
  const rawId = ti.transformCallback((m) => {
    rawLog.push('end' in m ? `end@${m.index}` : `${m.index}`);
    if ('end' in m) rawDone();
  });
  await inv('chan_order', { ch: `__CHANNEL__:${rawId}`, sizes });
  // ...
  const ch2 = new C((m) => { ordered.push(m.split(':')[0]); if (ordered.length === sizes.length) orderedDone(); });
  await inv('chan_order', { ch: ch2, sizes });

#[tauri::command]
fn big_raw(n: usize) -> Response {
  Response::new(vec![1u8; n])
}

#[tauri::command]
fn chan_big(ch: Channel<InvokeResponseBody>, n: usize, chunk: usize, raw: bool) -> tauri::Result<()> {
  let mut left = n;
  while left > 0 {
    let k = left.min(chunk);
    if raw {
      ch.send(InvokeResponseBody::Raw(vec![1u8; k]))?;
    } else {
      ch.send(InvokeResponseBody::Json(serde_json::to_string(&"a".repeat(k))?))?;
    }
    left -= k;
  }
  Ok(())
}

#[tauri::command]
fn emit_big(app: AppHandle, n: usize, chunk: usize) -> tauri::Result<()> {
  let mut left = n;
  while left > 0 {
    let k = left.min(chunk);
    app.emit("big", "a".repeat(k))?;
    left -= k;
  }
  Ok(())
}

#[tauri::command]
fn rec_return() -> Vec<Rec> {
  records().clone()
}

#[tauri::command]
fn rec_channel(ch: Channel<Vec<Rec>>, chunk: usize) -> tauri::Result<()> {
  for c in records().chunks(chunk) {
    ch.send(c.to_vec())?;
  }
  Ok(())
}

#[tauri::command]
fn rec_emit(app: AppHandle, chunk: usize) -> tauri::Result<()> {
  for c in records().chunks(chunk) {
    app.emit("recs", c)?;
  }
  Ok(())
}

async function recEmit(total, chunk) {
  let got = 0, msgs = 0, done;
  const p = new Promise(r => { done = r; });
  const un = await window.__TAURI__.event.listen('recs', (e) => {
    got += e.payload.length; msgs++;
    if (got >= total) done(`${got} recs in ${msgs} msgs`);
  });
  await inv('rec_emit', { chunk });
  const r = await p;
  un();
  return r;
}

  "rawArrival": [
   "1",
   "2",
   "4",
   "5",
   "6",
   "end@7",
   "0",
   "3"
  ],
  "channelOnmessage": [
   "0",
   "1",
   "2",
   "3",
   "4",
   "5",
   "6"
  ],