pulse-ui-client 0.1.28 → 0.1.30

package/dist/index.development.js

@@ -0,0 +1,2138 @@
+// src/channel.ts
+class PulseChannelResetError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PulseChannelResetError";
+  }
+}
+function randomId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID().replace(/-/g, "");
+  }
+  return Math.random().toString(16).slice(2) + Math.random().toString(16).slice(2);
+}
+function formatError(error) {
+  if (error instanceof Error)
+    return error.message;
+  if (typeof error === "string")
+    return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+function isServerResponseMessage(message) {
+  return typeof message.responseTo === "string";
+}
+function isServerRequestMessage(message) {
+  return typeof message.event === "string";
+}
+
+class ChannelBridge {
+  client;
+  id;
+  handlers = new Map;
+  pending = new Map;
+  backlog = [];
+  closed = false;
+  constructor(client, id) {
+    this.client = client;
+    this.id = id;
+  }
+  emit(event, payload) {
+    this.ensureOpen();
+    this.client.sendMessage({
+      type: "channel_message",
+      channel: this.id,
+      event,
+      payload
+    });
+  }
+  request(event, payload) {
+    this.ensureOpen();
+    const requestId = randomId();
+    return new Promise((resolve, reject) => {
+      this.pending.set(requestId, { resolve, reject });
+      this.client.sendMessage({
+        type: "channel_message",
+        channel: this.id,
+        event,
+        payload,
+        requestId
+      });
+    });
+  }
+  on(event, handler) {
+    this.ensureOpen();
+    let bucket = this.handlers.get(event);
+    if (!bucket) {
+      bucket = new Set;
+      this.handlers.set(event, bucket);
+    }
+    bucket.add(handler);
+    this.flushBacklog(event);
+    return () => {
+      const set = this.handlers.get(event);
+      if (!set)
+        return;
+      set.delete(handler);
+      if (set.size === 0) {
+        this.handlers.delete(event);
+      }
+    };
+  }
+  handleServerMessage(message) {
+    if (isServerResponseMessage(message)) {
+      this.resolvePending(message);
+      return this.closed;
+    }
+    if (this.closed) {
+      return true;
+    }
+    if (!isServerRequestMessage(message)) {
+      return this.closed;
+    }
+    if (message.event === "__close__") {
+      this.close(new PulseChannelResetError("Channel closed by server"));
+      return true;
+    }
+    if (message.requestId) {
+      this.dispatchRequest(message);
+    } else {
+      this.dispatchEvent(message);
+    }
+    return this.closed;
+  }
+  handleDisconnect(reason) {
+    this.close(reason);
+  }
+  dispose(reason) {
+    this.close(reason);
+  }
+  ensureOpen() {
+    if (this.closed) {
+      throw new PulseChannelResetError("Channel is closed");
+    }
+  }
+  flushBacklog(event) {
+    if (this.backlog.length === 0)
+      return;
+    const remaining = [];
+    for (const item of this.backlog) {
+      if (item.event === event) {
+        this.dispatchEvent(item);
+      } else {
+        remaining.push(item);
+      }
+    }
+    this.backlog = remaining;
+  }
+  dispatchEvent(message) {
+    const handlers = this.handlers.get(message.event);
+    if (!handlers || handlers.size === 0) {
+      this.backlog.push(message);
+      return;
+    }
+    for (const handler of handlers) {
+      try {
+        const result = handler(message.payload);
+        if (result && typeof result.then === "function") {
+          result.catch((err) => {
+            console.error("Pulse channel handler error", err);
+          });
+        }
+      } catch (err) {
+        console.error("Pulse channel handler error", err);
+      }
+    }
+  }
+  async dispatchRequest(message) {
+    const handlers = this.handlers.get(message.event);
+    let response;
+    let error;
+    if (handlers && handlers.size > 0) {
+      for (const handler of handlers) {
+        try {
+          const result = handler(message.payload);
+          response = await Promise.resolve(result);
+          if (response !== undefined) {
+            break;
+          }
+        } catch (err) {
+          error = err;
+          break;
+        }
+      }
+    }
+    if (error) {
+      this.client.sendMessage({
+        type: "channel_message",
+        channel: this.id,
+        event: undefined,
+        responseTo: message.requestId,
+        error: formatError(error)
+      });
+      return;
+    }
+    this.client.sendMessage({
+      type: "channel_message",
+      channel: this.id,
+      event: undefined,
+      responseTo: message.requestId,
+      payload: response
+    });
+  }
+  resolvePending(message) {
+    const entry = message.responseTo ? this.pending.get(message.responseTo) : undefined;
+    if (!entry) {
+      return;
+    }
+    this.pending.delete(message.responseTo);
+    if (message.error !== undefined && message.error !== null) {
+      entry.reject(new PulseChannelResetError(String(message.error)));
+    } else {
+      entry.resolve(message.payload);
+    }
+  }
+  close(reason) {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    for (const request of this.pending.values()) {
+      request.reject(reason);
+    }
+    this.pending.clear();
+    this.handlers.clear();
+    this.backlog = [];
+  }
+}
+function createChannelBridge(client, id) {
+  return new ChannelBridge(client, id);
+}
+// src/form.tsx
+import { forwardRef, useCallback } from "react";
+import { jsxDEV } from "react/jsx-dev-runtime";
+var PulseForm = forwardRef(function PulseForm2({ onSubmit, action, ...rest }, ref) {
+  return /* @__PURE__ */ jsxDEV("form", {
+    ...rest,
+    action,
+    ref,
+    onSubmit: useCallback((event) => submitForm({ event, action, onSubmit }), [action, onSubmit])
+  }, undefined, false, undefined, this);
+});
+async function submitForm({ event, action, onSubmit, formData, force }) {
+  onSubmit?.(event);
+  if (!force && event.defaultPrevented) {
+    return;
+  }
+  const form = event.currentTarget;
+  event.preventDefault();
+  const nativeEvent = event.nativeEvent;
+  if (!formData) {
+    formData = new FormData(form, nativeEvent.submitter);
+  }
+  const url = new URL(action, window.location.href);
+  try {
+    await fetch(url, {
+      method: "POST",
+      credentials: "include",
+      body: formData
+    });
+  } catch (err) {
+    if (true) {
+      console.error("[Pulse] Form submission failed", err);
+    } else {}
+  }
+}
+// src/helpers.ts
+function extractServerRouteInfo({ params, request }) {
+  const { "*": catchall = "", ...pathParams } = params;
+  const parsedUrl = new URL(request.url);
+  return {
+    hash: parsedUrl.hash,
+    pathname: parsedUrl.pathname,
+    query: parsedUrl.search,
+    queryParams: Object.fromEntries(parsedUrl.searchParams.entries()),
+    pathParams,
+    catchall: catchall.length > 1 ? catchall.split("/") : []
+  };
+}
+// src/pulse.tsx
+import { createContext, useContext, useEffect, useMemo, useState } from "react";
+import { useLocation, useNavigate, useParams } from "react-router";
+
+// src/client.tsx
+import { io } from "socket.io-client";
+
+// src/serialize/extractor.ts
+function createExtractor() {
+  function _createExtractor(keys, computed) {
+    return (src) => {
+      const out = {};
+      for (const key of keys) {
+        out[key] = src[key];
+      }
+      if (computed) {
+        for (const key in computed) {
+          const fn = computed[key];
+          out[key] = fn(src);
+        }
+      }
+      return out;
+    };
+  }
+  return _createExtractor;
+}
+
+// src/serialize/elements.ts
+var lowerTagName = (e) => e.tagName.toLowerCase();
+var ELEMENT_KEYS = [
+  "id",
+  "className",
+  "tagName",
+  "localName",
+  "clientHeight",
+  "clientLeft",
+  "clientTop",
+  "clientWidth",
+  "scrollHeight",
+  "scrollLeft",
+  "scrollTop",
+  "scrollWidth",
+  "slot"
+];
+var HTML_OR_SVG_KEYS = [
+  "autofocus",
+  "tabIndex",
+  "nonce"
+];
+var HTML_ELEMENT_BASE_KEYS = [
+  "accessKey",
+  "accessKeyLabel",
+  "autocapitalize",
+  "dir",
+  "draggable",
+  "hidden",
+  "inert",
+  "lang",
+  "offsetHeight",
+  "offsetLeft",
+  "offsetTop",
+  "offsetWidth",
+  "popover",
+  "spellcheck",
+  "title",
+  "translate",
+  "writingSuggestions",
+  "contentEditable",
+  "enterKeyHint",
+  "isContentEditable",
+  "inputMode"
+];
+var extractElement = createExtractor()(ELEMENT_KEYS, {
+  tagName: lowerTagName
+});
+var extractHTMLOrSVGElement = createExtractor()(HTML_OR_SVG_KEYS);
+var extractHTMLElementBaseOnly = createExtractor()(HTML_ELEMENT_BASE_KEYS);
+function extractHTMLElementBase(elt) {
+  return {
+    ...extractElement(elt),
+    ...extractHTMLOrSVGElement(elt),
+    ...extractHTMLElementBaseOnly(elt)
+  };
+}
+function withBase(keys, computed) {
+  const only = createExtractor()(keys, computed);
+  return (elt) => ({ ...extractHTMLElementBase(elt), ...only(elt) });
+}
+var HTML_ANCHOR_KEYS = [
+  "hash",
+  "host",
+  "hostname",
+  "href",
+  "origin",
+  "password",
+  "pathname",
+  "port",
+  "protocol",
+  "search",
+  "target",
+  "download",
+  "rel",
+  "hreflang",
+  "type",
+  "username",
+  "ping",
+  "referrerPolicy",
+  "text"
+];
+var anchorExtractor = withBase(HTML_ANCHOR_KEYS);
+var HTML_AREA_KEYS = [
+  "alt",
+  "coords",
+  "download",
+  "hash",
+  "host",
+  "hostname",
+  "href",
+  "origin",
+  "password",
+  "pathname",
+  "port",
+  "protocol",
+  "rel",
+  "search",
+  "shape",
+  "target",
+  "username",
+  "ping",
+  "referrerPolicy"
+];
+var areaExtractor = withBase(HTML_AREA_KEYS);
+var HTML_MEDIA_KEYS = [
+  "autoplay",
+  "controls",
+  "crossOrigin",
+  "currentSrc",
+  "currentTime",
+  "defaultMuted",
+  "defaultPlaybackRate",
+  "duration",
+  "ended",
+  "loop",
+  "muted",
+  "networkState",
+  "paused",
+  "playbackRate",
+  "preload",
+  "readyState",
+  "seeking",
+  "src",
+  "volume",
+  "preservesPitch"
+];
+var mediaExtractor = withBase(HTML_MEDIA_KEYS);
+var audioExtractor = (elt) => mediaExtractor(elt);
+var HTML_BUTTON_KEYS = [
+  "disabled",
+  "name",
+  "type",
+  "value",
+  "formAction",
+  "formEnctype",
+  "formMethod",
+  "formNoValidate",
+  "formTarget",
+  "popoverTargetAction"
+];
+var buttonExtractor = withBase(HTML_BUTTON_KEYS);
+var HTML_DATA_KEYS = ["value"];
+var dataExtractor = withBase(HTML_DATA_KEYS);
+var HTML_EMBED_KEYS = [
+  "height",
+  "src",
+  "type",
+  "width",
+  "align",
+  "name"
+];
+var embedExtractor = withBase(HTML_EMBED_KEYS);
+var HTML_FIELDSET_KEYS = [
+  "disabled",
+  "name",
+  "type",
+  "validationMessage",
+  "willValidate"
+];
+var fieldsetExtractor = withBase(HTML_FIELDSET_KEYS);
+var HTML_FORM_KEYS = [
+  "acceptCharset",
+  "action",
+  "autocomplete",
+  "encoding",
+  "enctype",
+  "length",
+  "method",
+  "name",
+  "noValidate",
+  "target",
+  "rel"
+];
+var formExtractor = withBase(HTML_FORM_KEYS);
+var HTML_IFRAME_KEYS = [
+  "allow",
+  "allowFullscreen",
+  "height",
+  "name",
+  "referrerPolicy",
+  "src",
+  "srcdoc",
+  "width",
+  "align",
+  "frameBorder",
+  "longDesc",
+  "marginHeight",
+  "marginWidth",
+  "scrolling",
+  "sandbox"
+];
+var iframeExtractor = withBase(HTML_IFRAME_KEYS);
+var HTML_IMAGE_KEYS = [
+  "alt",
+  "crossOrigin",
+  "decoding",
+  "height",
+  "isMap",
+  "loading",
+  "naturalHeight",
+  "naturalWidth",
+  "referrerPolicy",
+  "sizes",
+  "src",
+  "srcset",
+  "useMap",
+  "width",
+  "align",
+  "border",
+  "complete",
+  "hspace",
+  "longDesc",
+  "lowsrc",
+  "name",
+  "vspace",
+  "x",
+  "y",
+  "fetchPriority"
+];
+var imageExtractor = withBase(HTML_IMAGE_KEYS);
+var HTML_INPUT_KEYS = [
+  "accept",
+  "alt",
+  "autocomplete",
+  "checked",
+  "defaultChecked",
+  "defaultValue",
+  "dirName",
+  "disabled",
+  "height",
+  "indeterminate",
+  "max",
+  "maxLength",
+  "min",
+  "minLength",
+  "multiple",
+  "name",
+  "pattern",
+  "placeholder",
+  "readOnly",
+  "required",
+  "selectionDirection",
+  "selectionEnd",
+  "selectionStart",
+  "size",
+  "src",
+  "step",
+  "type",
+  "value",
+  "valueAsNumber",
+  "width",
+  "align",
+  "capture",
+  "formAction",
+  "formEnctype",
+  "formMethod",
+  "formNoValidate",
+  "formTarget",
+  "useMap",
+  "validationMessage",
+  "willValidate",
+  "popoverTargetAction"
+];
+var inputExtractor = withBase(HTML_INPUT_KEYS);
+var HTML_LABEL_KEYS = ["htmlFor"];
+var labelExtractor = withBase(HTML_LABEL_KEYS);
+var HTML_LI_KEYS = ["value", "type"];
+var liExtractor = withBase(HTML_LI_KEYS);
+var HTML_LINK_KEYS = [
+  "as",
+  "crossOrigin",
+  "disabled",
+  "fetchPriority",
+  "href",
+  "hreflang",
+  "imageSizes",
+  "imageSrcset",
+  "integrity",
+  "media",
+  "referrerPolicy",
+  "rel",
+  "type",
+  "charset",
+  "rev",
+  "target",
+  "sizes"
+];
+var linkExtractor = withBase(HTML_LINK_KEYS);
+var HTML_MAP_KEYS = ["name"];
+var mapExtractor = withBase(HTML_MAP_KEYS);
+var HTML_METER_KEYS = [
+  "high",
+  "low",
+  "max",
+  "min",
+  "optimum",
+  "value"
+];
+var meterExtractor = withBase(HTML_METER_KEYS);
+var HTML_MOD_KEYS = ["cite", "dateTime"];
+var modExtractor = withBase(HTML_MOD_KEYS);
+var HTML_OL_KEYS = [
+  "reversed",
+  "start",
+  "type",
+  "compact"
+];
+var olistExtractor = withBase(HTML_OL_KEYS);
+var HTML_OBJECT_KEYS = [
+  "data",
+  "height",
+  "name",
+  "type",
+  "useMap",
+  "width",
+  "validationMessage",
+  "willValidate",
+  "align",
+  "archive",
+  "border",
+  "code",
+  "codeBase",
+  "codeType",
+  "declare",
+  "hspace",
+  "standby",
+  "vspace"
+];
+var objectExtractor = withBase(HTML_OBJECT_KEYS);
+var HTML_OPTGROUP_KEYS = [
+  "disabled",
+  "label"
+];
+var optgroupExtractor = withBase(HTML_OPTGROUP_KEYS);
+var HTML_OPTION_KEYS = [
+  "defaultSelected",
+  "disabled",
+  "index",
+  "label",
+  "selected",
+  "text",
+  "value"
+];
+var optionExtractor = withBase(HTML_OPTION_KEYS);
+var HTML_OUTPUT_KEYS = [
+  "defaultValue",
+  "name",
+  "type",
+  "value",
+  "htmlFor",
+  "validationMessage",
+  "willValidate"
+];
+var outputExtractor = withBase(HTML_OUTPUT_KEYS);
+var HTML_PROGRESS_KEYS = [
+  "max",
+  "position",
+  "value"
+];
+var progressExtractor = withBase(HTML_PROGRESS_KEYS);
+var HTML_QUOTE_KEYS = ["cite"];
+var quoteExtractor = withBase(HTML_QUOTE_KEYS);
+var citeExtractor = (elt) => extractHTMLElementBase(elt);
+var HTML_SCRIPT_KEYS = [
+  "async",
+  "crossOrigin",
+  "defer",
+  "fetchPriority",
+  "integrity",
+  "noModule",
+  "referrerPolicy",
+  "src",
+  "text",
+  "type",
+  "charset"
+];
+var extractHTMLScriptOnly = createExtractor()(HTML_SCRIPT_KEYS, {
+  event: (s) => s.event,
+  htmlFor: (s) => s.htmlFor
+});
+var scriptExtractor = (elt) => ({
+  ...extractHTMLElementBase(elt),
+  ...extractHTMLScriptOnly(elt)
+});
+var HTML_SELECT_KEYS = [
+  "autocomplete",
+  "disabled",
+  "length",
+  "multiple",
+  "name",
+  "required",
+  "selectedIndex",
+  "size",
+  "type",
+  "value",
+  "validationMessage",
+  "willValidate"
+];
+var selectExtractor = withBase(HTML_SELECT_KEYS);
+var HTML_SLOT_KEYS = ["name"];
+var slotExtractor = withBase(HTML_SLOT_KEYS);
+var HTML_SOURCE_KEYS = [
+  "height",
+  "media",
+  "sizes",
+  "src",
+  "srcset",
+  "type",
+  "width"
+];
+var sourceExtractor = withBase(HTML_SOURCE_KEYS);
+var HTML_TABLE_CAPTION_KEYS = [
+  "align"
+];
+var tableCaptionExtractor = withBase(HTML_TABLE_CAPTION_KEYS);
+var HTML_TABLE_CELL_KEYS = [
+  "abbr",
+  "cellIndex",
+  "colSpan",
+  "headers",
+  "rowSpan",
+  "scope",
+  "align",
+  "axis",
+  "bgColor",
+  "ch",
+  "chOff",
+  "height",
+  "noWrap",
+  "vAlign",
+  "width"
+];
+var tableCellExtractor = withBase(HTML_TABLE_CELL_KEYS);
+var HTML_TABLE_COL_KEYS = [
+  "span",
+  "align",
+  "ch",
+  "chOff",
+  "vAlign",
+  "width"
+];
+var tableColExtractor = withBase(HTML_TABLE_COL_KEYS);
+var HTML_TABLE_KEYS = [
+  "align",
+  "bgColor",
+  "border",
+  "cellPadding",
+  "cellSpacing",
+  "frame",
+  "rules",
+  "summary",
+  "width"
+];
+var tableExtractor = withBase(HTML_TABLE_KEYS);
+var HTML_TR_KEYS = [
+  "rowIndex",
+  "sectionRowIndex",
+  "align",
+  "bgColor",
+  "ch",
+  "chOff",
+  "vAlign"
+];
+var tableRowExtractor = withBase(HTML_TR_KEYS);
+var HTML_TSECTION_KEYS = [
+  "align",
+  "ch",
+  "chOff",
+  "vAlign"
+];
+var tableSectionExtractor = withBase(HTML_TSECTION_KEYS);
+var templateExtractor = (elt) => extractHTMLElementBase(elt);
+var HTML_TEXTAREA_KEYS = [
+  "autocomplete",
+  "cols",
+  "defaultValue",
+  "dirName",
+  "disabled",
+  "maxLength",
+  "minLength",
+  "name",
+  "placeholder",
+  "readOnly",
+  "required",
+  "rows",
+  "selectionDirection",
+  "selectionEnd",
+  "selectionStart",
+  "value",
+  "wrap",
+  "textLength",
+  "validationMessage",
+  "willValidate"
+];
+var textareaExtractor = withBase(HTML_TEXTAREA_KEYS);
+var HTML_TIME_KEYS = ["dateTime"];
+var timeExtractor = withBase(HTML_TIME_KEYS);
+var HTML_TRACK_KEYS = [
+  "default",
+  "kind",
+  "label",
+  "readyState",
+  "src",
+  "srclang"
+];
+var trackExtractor = withBase(HTML_TRACK_KEYS);
+var HTML_VIDEO_KEYS = [
+  "height",
+  "poster",
+  "videoHeight",
+  "videoWidth",
+  "width",
+  "playsInline"
+];
+var extractHTMLVideoOnly = createExtractor()(HTML_VIDEO_KEYS);
+var videoExtractor = (elt) => ({
+  ...mediaExtractor(elt),
+  ...extractHTMLVideoOnly(elt)
+});
+var HTML_BR_KEYS = ["clear"];
+var brExtractor = withBase(HTML_BR_KEYS);
+var HTML_BASE_KEYS = ["href", "target"];
+var baseExtractor = withBase(HTML_BASE_KEYS);
+var HTML_BODY_KEYS = [
+  "aLink",
+  "background",
+  "bgColor",
+  "link",
+  "text",
+  "vLink"
+];
+var bodyExtractor = withBase(HTML_BODY_KEYS);
+var HTML_DLIST_KEYS = ["compact"];
+var dlistExtractor = withBase(HTML_DLIST_KEYS);
+var HTML_DETAILS_KEYS = ["open"];
+var detailsExtractor = withBase(HTML_DETAILS_KEYS);
+var HTML_DIALOG_KEYS = [
+  "open",
+  "returnValue"
+];
+var dialogExtractor = withBase(HTML_DIALOG_KEYS);
+var HTML_DIV_KEYS = ["align"];
+var divExtractor = withBase(HTML_DIV_KEYS);
+var headExtractor = (elt) => extractHTMLElementBase(elt);
+var HTML_HEADING_KEYS = ["align"];
+var headingExtractor = withBase(HTML_HEADING_KEYS);
+var HTML_HR_KEYS = [
+  "align",
+  "color",
+  "noShade",
+  "size",
+  "width"
+];
+var hrExtractor = withBase(HTML_HR_KEYS);
+var HTML_HTML_KEYS = ["version"];
+var htmlExtractor = withBase(HTML_HTML_KEYS);
+var menuExtractor = (elt) => extractHTMLElementBase(elt);
+var HTML_META_KEYS = [
+  "content",
+  "httpEquiv",
+  "name",
+  "scheme"
+];
+var metaExtractor = withBase(HTML_META_KEYS);
+var HTML_P_KEYS = ["align"];
+var paragraphExtractor = withBase(HTML_P_KEYS);
+var pictureExtractor = (elt) => extractHTMLElementBase(elt);
+var HTML_PRE_KEYS = ["width"];
+var preExtractor = withBase(HTML_PRE_KEYS);
+var spanExtractor = (elt) => extractHTMLElementBase(elt);
+var HTML_STYLE_KEYS = [
+  "media",
+  "type",
+  "disabled"
+];
+var styleExtractor = withBase(HTML_STYLE_KEYS);
+var HTML_TITLE_KEYS = ["text"];
+var titleExtractor = withBase(HTML_TITLE_KEYS);
+var HTML_UL_KEYS = ["compact", "type"];
+var ulistExtractor = withBase(HTML_UL_KEYS);
+var elementExtractors = {
+  A: anchorExtractor,
+  AREA: areaExtractor,
+  AUDIO: audioExtractor,
+  BASE: baseExtractor,
+  BLOCKQUOTE: quoteExtractor,
+  Q: quoteExtractor,
+  BODY: bodyExtractor,
+  BR: brExtractor,
+  BUTTON: buttonExtractor,
+  CANVAS: extractHTMLElementBase,
+  CAPTION: tableCaptionExtractor,
+  CITE: citeExtractor,
+  COL: tableColExtractor,
+  COLGROUP: tableColExtractor,
+  DATA: dataExtractor,
+  DETAILS: detailsExtractor,
+  DIALOG: dialogExtractor,
+  DIV: divExtractor,
+  DL: dlistExtractor,
+  EMBED: embedExtractor,
+  FIELDSET: fieldsetExtractor,
+  FORM: formExtractor,
+  H1: headingExtractor,
+  H2: headingExtractor,
+  H3: headingExtractor,
+  H4: headingExtractor,
+  H5: headingExtractor,
+  H6: headingExtractor,
+  HEAD: headExtractor,
+  HR: hrExtractor,
+  HTML: htmlExtractor,
+  IFRAME: iframeExtractor,
+  IMG: imageExtractor,
+  INPUT: inputExtractor,
+  LABEL: labelExtractor,
+  LI: liExtractor,
+  LINK: linkExtractor,
+  MAP: mapExtractor,
+  MENU: menuExtractor,
+  META: metaExtractor,
+  METER: meterExtractor,
+  INS: modExtractor,
+  DEL: modExtractor,
+  OBJECT: objectExtractor,
+  OL: olistExtractor,
+  OPTGROUP: optgroupExtractor,
+  OPTION: optionExtractor,
+  OUTPUT: outputExtractor,
+  P: paragraphExtractor,
+  PICTURE: pictureExtractor,
+  PRE: preExtractor,
+  PROGRESS: progressExtractor,
+  SCRIPT: scriptExtractor,
+  SELECT: selectExtractor,
+  SLOT: slotExtractor,
+  SOURCE: sourceExtractor,
+  SPAN: spanExtractor,
+  STYLE: styleExtractor,
+  TABLE: tableExtractor,
+  TBODY: tableSectionExtractor,
+  THEAD: tableSectionExtractor,
+  TFOOT: tableSectionExtractor,
+  TD: tableCellExtractor,
+  TH: tableCellExtractor,
+  TEMPLATE: templateExtractor,
+  TEXTAREA: textareaExtractor,
+  TIME: timeExtractor,
+  TITLE: titleExtractor,
+  TR: tableRowExtractor,
+  TRACK: trackExtractor,
+  UL: ulistExtractor,
+  VIDEO: videoExtractor
+};
+function extractHTMLElement(elt) {
+  const tagName = elt.tagName.toUpperCase();
+  const extractor = elementExtractors[tagName];
+  if (extractor) {
+    return extractor(elt);
+  }
+  throw new Error(`Unexpected HTML element tag: ${elt.tagName} (update .web/custom/serialize.ts)`);
+}
+
+// src/serialize/events.ts
+var mapTarget = (e) => extractHTMLElement(e.target);
+var mapRelated = (e) => e.relatedTarget ? extractHTMLElement(e.relatedTarget) : null;
+function makeExtractor(keys, computed) {
+  return createExtractor()(keys, {
+    target: mapTarget,
+    ...computed || {}
+  });
+}
+var SYNTHETIC_KEYS = [
+  "target",
+  "bubbles",
+  "cancelable",
+  "defaultPrevented",
+  "eventPhase",
+  "isTrusted",
+  "timeStamp",
+  "type"
+];
+var UI_KEYS = [...SYNTHETIC_KEYS, "detail"];
+var MOUSE_KEYS = [
+  ...UI_KEYS,
+  "altKey",
+  "button",
+  "buttons",
+  "clientX",
+  "clientY",
+  "ctrlKey",
+  "metaKey",
+  "movementX",
+  "movementY",
+  "pageX",
+  "pageY",
+  "screenX",
+  "screenY",
+  "shiftKey"
+];
+var POINTER_KEYS = [
+  ...MOUSE_KEYS,
+  "pointerId",
+  "pressure",
+  "tangentialPressure",
+  "tiltX",
+  "tiltY",
+  "twist",
+  "width",
+  "height",
+  "pointerType",
+  "isPrimary"
+];
+var syntheticExtractor = makeExtractor(SYNTHETIC_KEYS);
+var uiExtractor = makeExtractor(UI_KEYS);
+var mouseExtractor = makeExtractor(MOUSE_KEYS, { relatedTarget: mapRelated });
+var clipboardExtractor = makeExtractor(SYNTHETIC_KEYS, {
+  clipboardData: (e) => extractDataTransfer(e.clipboardData)
+});
+var compositionExtractor = makeExtractor([...SYNTHETIC_KEYS, "data"]);
+var dragExtractor = makeExtractor(MOUSE_KEYS, {
+  relatedTarget: mapRelated,
+  dataTransfer: (e) => extractDataTransfer(e.dataTransfer)
+});
+var pointerExtractor = makeExtractor(POINTER_KEYS, {
+  relatedTarget: mapRelated
+});
+var focusExtractor = makeExtractor(SYNTHETIC_KEYS, {
+  relatedTarget: mapRelated
+});
+var formExtractor2 = makeExtractor(SYNTHETIC_KEYS);
+var invalidExtractor = makeExtractor(SYNTHETIC_KEYS);
+var changeExtractor = makeExtractor(SYNTHETIC_KEYS);
+var keyboardExtractor = makeExtractor([
+  ...UI_KEYS,
+  "altKey",
+  "ctrlKey",
+  "code",
+  "key",
+  "locale",
+  "location",
+  "metaKey",
+  "repeat",
+  "shiftKey"
+]);
+var touchExtractor = makeExtractor([
+  ...UI_KEYS,
+  "altKey",
+  "ctrlKey",
+  "metaKey",
+  "shiftKey",
+  "changedTouches",
+  "targetTouches",
+  "touches"
+], {
+  changedTouches: (e) => mapTouchList(e.changedTouches),
+  targetTouches: (e) => mapTouchList(e.targetTouches),
+  touches: (e) => mapTouchList(e.touches)
+});
+var wheelExtractor = makeExtractor([...MOUSE_KEYS, "deltaMode", "deltaX", "deltaY", "deltaZ"], {
+  relatedTarget: mapRelated
+});
+var animationExtractor = makeExtractor([
+  ...SYNTHETIC_KEYS,
+  "animationName",
+  "elapsedTime",
+  "pseudoElement"
+]);
+var toggleExtractor = makeExtractor([...SYNTHETIC_KEYS, "oldState", "newState"]);
+var transitionExtractor = makeExtractor([
+  ...SYNTHETIC_KEYS,
+  "elapsedTime",
+  "propertyName",
+  "pseudoElement"
+]);
+function mapTouchList(list) {
+  return Array.from(list).map((touch) => ({
+    target: extractHTMLElement(touch.target),
+    identifier: touch.identifier,
+    screenX: touch.screenX,
+    screenY: touch.screenY,
+    clientX: touch.clientX,
+    clientY: touch.clientY,
+    pageX: touch.pageX,
+    pageY: touch.pageY
+  }));
+}
+function extractDataTransfer(dt) {
+  if (!dt) {
+    return null;
+  }
+  const items = [];
+  if (dt.items) {
+    for (let i = 0;i < dt.items.length; i++) {
+      const item = dt.items[i];
+      items.push({
+        kind: item.kind,
+        type: item.type
+      });
+    }
+  }
+  return {
+    drop_effect: dt.dropEffect,
+    effect_allowed: dt.effectAllowed,
+    items,
+    types: Array.from(dt.types || [])
+  };
+}
+var eventExtractorMap = {};
+function add(map, names, fn) {
+  for (const n of names)
+    map[n] = fn;
+}
+add(eventExtractorMap, [
+  "pointerdown",
+  "pointermove",
+  "pointerup",
+  "pointercancel",
+  "gotpointercapture",
+  "lostpointercapture",
+  "pointerenter",
+  "pointerleave",
+  "pointerover",
+  "pointerout"
+], pointerExtractor);
+add(eventExtractorMap, [
+  "click",
+  "contextmenu",
+  "dblclick",
+  "mousedown",
+  "mouseenter",
+  "mouseleave",
+  "mousemove",
+  "mouseout",
+  "mouseover",
+  "mouseup"
+], mouseExtractor);
+add(eventExtractorMap, ["drag", "dragend", "dragenter", "dragexit", "dragleave", "dragover", "dragstart", "drop"], dragExtractor);
+add(eventExtractorMap, ["keydown", "keypress", "keyup"], keyboardExtractor);
+add(eventExtractorMap, ["focus", "blur"], focusExtractor);
+add(eventExtractorMap, ["change", "input"], changeExtractor);
+add(eventExtractorMap, ["invalid"], invalidExtractor);
+add(eventExtractorMap, ["reset", "submit"], formExtractor2);
+add(eventExtractorMap, ["copy", "cut", "paste"], clipboardExtractor);
+add(eventExtractorMap, ["compositionend", "compositionstart", "compositionupdate"], compositionExtractor);
+add(eventExtractorMap, ["touchcancel", "touchend", "touchmove", "touchstart"], touchExtractor);
+add(eventExtractorMap, ["scroll"], uiExtractor);
+add(eventExtractorMap, ["wheel"], wheelExtractor);
+add(eventExtractorMap, ["animationstart", "animationend", "animationiteration"], animationExtractor);
+add(eventExtractorMap, ["transitionend"], transitionExtractor);
+add(eventExtractorMap, ["toggle"], toggleExtractor);
+function extractEvent(value) {
+  if (value && typeof value === "object" && "nativeEvent" in value && typeof value.isDefaultPrevented === "function") {
+    const evt = value;
+    if (typeof evt.type !== "string") {
+      return value;
+    }
+    const extractor = eventExtractorMap[evt.type.toLowerCase()];
+    if (extractor) {
+      return extractor(evt);
+    }
+    return syntheticExtractor(evt);
+  }
+  return value;
+}
+
+// src/serialize/serializer.ts
+function serialize(data) {
+  const seen = new Map;
+  const refs = [];
+  const dates = [];
+  const sets = [];
+  const maps = [];
+  let globalIndex = 0;
+  function process(value) {
+    if (value == null || typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+      return value;
+    }
+    const idx = globalIndex++;
+    const prevRef = seen.get(value);
+    if (prevRef !== undefined) {
+      refs.push(idx);
+      return prevRef;
+    }
+    seen.set(value, idx);
+    if (value instanceof Date) {
+      dates.push(idx);
+      return value.getTime();
+    }
+    if (Array.isArray(value)) {
+      const length = value.length;
+      const result = new Array(length);
+      for (let i = 0;i < length; i++) {
+        result[i] = process(value[i]);
+      }
+      return result;
+    }
+    if (value instanceof Map) {
+      maps.push(idx);
+      const rec = {};
+      for (const [key, entry] of value.entries()) {
+        rec[String(key)] = process(entry);
+      }
+      return rec;
+    }
+    if (value instanceof Set) {
+      sets.push(idx);
+      const size = value.size;
+      const result = new Array(size);
+      let i = 0;
+      for (const entry of value) {
+        result[i] = process(entry);
+        i += 1;
+      }
+      return result;
+    }
+    if (typeof value === "object") {
+      const rec = {};
+      const keys = Object.keys(value);
+      for (let i = 0;i < keys.length; i++) {
+        const key = keys[i];
+        rec[key] = process(value[key]);
+      }
+      return rec;
+    }
+    throw new Error(`Unsupported value in serialization: ${value}`);
+  }
+  const payload = process(data);
+  return [[refs, dates, sets, maps], payload];
+}
+function deserialize(payload, options) {
+  const [[refsA, datesA, setsA, mapsA], data] = payload;
+  const refs = new Set(refsA);
+  const dates = new Set(datesA);
+  const sets = new Set(setsA);
+  const maps = new Set(mapsA);
+  const objects = [];
+  function reconstruct(value) {
+    const idx = objects.length;
+    if (refs.has(idx)) {
+      objects.push(null);
+      return objects[value];
+    }
+    if (dates.has(idx)) {
+      const dt = new Date(value);
+      objects.push(dt);
+      return dt;
+    }
+    if (value == null || typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+      if (options?.coerceNullsToUndefined) {
+        return value ?? undefined;
+      }
+      return value;
+    }
+    if (Array.isArray(value)) {
+      if (sets.has(idx)) {
+        const result = new Set;
+        objects.push(result);
+        for (let i = 0;i < value.length; i++) {
+          result.add(reconstruct(value[i]));
+        }
+        return result;
+      }
+      const length = value.length;
+      const arr = new Array(length);
+      objects.push(arr);
+      for (let i = 0;i < length; i++) {
+        arr[i] = reconstruct(value[i]);
+      }
+      return arr;
+    }
+    if (typeof value === "object") {
+      if (maps.has(idx)) {
+        const result2 = new Map;
+        objects.push(result2);
+        const keys2 = Object.keys(value);
+        for (let i = 0;i < keys2.length; i++) {
+          const key = keys2[i];
+          result2.set(key, reconstruct(value[key]));
+        }
+        return result2;
+      }
+      const result = {};
+      objects.push(result);
+      const keys = Object.keys(value);
+      for (let i = 0;i < keys.length; i++) {
+        const key = keys[i];
+        result[key] = reconstruct(value[key]);
+      }
+      return result;
+    }
+    throw new Error(`Unsupported value in deserialization: ${value}`);
+  }
+  return reconstruct(data);
+}
+
+// src/client.tsx
+class PulseSocketIOClient {
+  #activeViews;
+  #socket = null;
+  #messageQueue;
+  #connectionListeners = new Set;
+  #serverErrors = new Map;
+  #serverErrorListeners = new Set;
+  #channels = new Map;
+  #url;
+  #renderId;
+  #frameworkNavigate;
+  constructor(url, renderId, frameworkNavigate) {
+    this.#url = url;
+    this.#renderId = renderId;
+    this.#frameworkNavigate = frameworkNavigate;
+    this.#socket = null;
+    this.#activeViews = new Map;
+    this.#messageQueue = [];
+  }
+  isConnected() {
+    return this.#socket?.connected ?? false;
+  }
+  async connect() {
+    if (this.#socket) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const socket = io(this.#url, {
+        transports: ["websocket", "webtransport"],
+        auth: { renderId: this.#renderId }
+      });
+      this.#socket = socket;
+      socket.on("connect", () => {
+        console.log("[SocketIOTransport] Connected:", this.#socket?.id);
+        for (const [path, route] of this.#activeViews) {
+          socket.emit("message", serialize({
+            type: "mount",
+            path,
+            routeInfo: route.routeInfo
+          }));
+        }
+        for (const payload of this.#messageQueue) {
+          if (payload.type === "mount" && this.#activeViews.has(payload.path)) {
+            continue;
+          }
+          if (payload.type === "navigate") {
+            continue;
+          }
+          socket.emit("message", serialize(payload));
+        }
+        this.#messageQueue = [];
+        this.notifyConnectionListeners(true);
+        resolve();
+      });
+      socket.on("connect_error", (err) => {
+        console.error("[SocketIOTransport] Connection failed:", err);
+        this.notifyConnectionListeners(false);
+        reject(err);
+      });
+      socket.on("disconnect", () => {
+        console.log("[SocketIOTransport] Disconnected");
+        this.#handleTransportDisconnect();
+        this.notifyConnectionListeners(false);
+      });
+      socket.on("message", (data) => this.#handleServerMessage(deserialize(data, { coerceNullsToUndefined: true })));
+    });
+  }
+  onConnectionChange(listener) {
+    this.#connectionListeners.add(listener);
+    listener(this.isConnected());
+    return () => {
+      this.#connectionListeners.delete(listener);
+    };
+  }
+  notifyConnectionListeners(connected) {
+    for (const listener of this.#connectionListeners) {
+      listener(connected);
+    }
+  }
+  onServerError(listener) {
+    this.#serverErrorListeners.add(listener);
+    for (const [path, err] of this.#serverErrors)
+      listener(path, err);
+    return () => {
+      this.#serverErrorListeners.delete(listener);
+    };
+  }
+  notifyServerError(path, error) {
+    for (const listener of this.#serverErrorListeners)
+      listener(path, error);
+  }
+  sendMessage(payload) {
+    if (this.isConnected()) {
+      this.#socket.emit("message", serialize(payload));
+    } else {
+      this.#messageQueue.push(payload);
+    }
+  }
+  mountView(path, view) {
+    if (this.#activeViews.has(path)) {
+      throw new Error(`Path ${path} is already mounted`);
+    }
+    this.#activeViews.set(path, view);
+    this.sendMessage({
+      type: "mount",
+      path,
+      routeInfo: view.routeInfo
+    });
+  }
+  async navigate(path, routeInfo) {
+    await this.sendMessage({
+      type: "navigate",
+      path,
+      routeInfo
+    });
+  }
+  unmount(path) {
+    this.sendMessage({ type: "unmount", path });
+    this.#activeViews.delete(path);
+  }
+  disconnect() {
+    this.#socket?.disconnect();
+    this.#socket = null;
+    this.#messageQueue = [];
+    this.#connectionListeners.clear();
+    this.#activeViews.clear();
+    this.#serverErrors.clear();
+    this.#serverErrorListeners.clear();
+    for (const { bridge } of this.#channels.values()) {
+      bridge.dispose(new PulseChannelResetError("Client disconnected"));
+    }
+    this.#channels.clear();
+  }
+  #handleServerMessage(message) {
+    switch (message.type) {
+      case "vdom_init": {
+        const route = this.#activeViews.get(message.path);
+        if (!route)
+          return;
+        if (route) {
+          route.onInit(message.vdom, message.callbacks, message.render_props, message.css_refs);
+        }
+        if (this.#serverErrors.has(message.path)) {
+          this.#serverErrors.delete(message.path);
+          this.notifyServerError(message.path, null);
+        }
+        break;
+      }
+      case "vdom_update": {
+        const route = this.#activeViews.get(message.path);
+        if (!route)
+          return;
+        route.onUpdate(message.ops);
+        if (this.#serverErrors.has(message.path)) {
+          this.#serverErrors.delete(message.path);
+          this.notifyServerError(message.path, null);
+        }
+        break;
+      }
+      case "server_error": {
+        if (!this.#activeViews.has(message.path))
+          return;
+        this.#serverErrors.set(message.path, message.error);
+        this.notifyServerError(message.path, message.error);
+        break;
+      }
+      case "api_call": {
+        this.#performApiCall(message);
+        break;
+      }
+      case "navigate_to": {
+        const replace = !!message.replace;
+        let dest = message.path || "";
+        if (dest.startsWith("//"))
+          dest = `${window.location.protocol}${dest}`;
+        const hasScheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(dest);
+        if (hasScheme) {
+          if (dest.startsWith("http://") || dest.startsWith("https://")) {
+            try {
+              const url = new URL(dest);
+              if (url.origin === window.location.origin) {
+                const internal = `${url.pathname}${url.search}${url.hash}`;
+                this.#frameworkNavigate(internal, { replace });
+              } else {
+                if (replace)
+                  window.location.replace(dest);
+                else
+                  window.location.assign(dest);
+              }
+            } catch {
+              if (replace)
+                window.location.replace(dest);
+              else
+                window.location.assign(dest);
+            }
+          } else {
+            if (replace)
+              window.location.replace(dest);
+            else
+              window.location.assign(dest);
+          }
+        } else {
+          this.#frameworkNavigate(dest, { replace });
+        }
+        break;
+      }
+      case "channel_message": {
+        this.#routeChannelMessage(message);
+        break;
+      }
+      default: {
+        console.error("Unexpected message:", message);
+      }
+    }
+  }
+  async#performApiCall(msg) {
+    try {
+      const res = await fetch(msg.url, {
+        method: msg.method || "GET",
+        headers: {
+          ...msg.headers || {},
+          ...msg.body != null && !("content-type" in (msg.headers || {})) ? { "content-type": "application/json" } : {}
+        },
+        body: msg.body != null ? typeof msg.body === "string" ? msg.body : JSON.stringify(msg.body) : undefined,
+        credentials: msg.credentials || "include"
+      });
+      const headersObj = {};
+      res.headers.forEach((v, k) => {
+        headersObj[k] = v;
+      });
+      let body = null;
+      const ct = res.headers.get("content-type") || "";
+      if (ct.includes("application/json")) {
+        body = await res.json().catch(() => null);
+      } else {
+        body = await res.text().catch(() => null);
+      }
+      const reply = {
+        type: "api_result",
+        id: msg.id,
+        ok: res.ok,
+        status: res.status,
+        headers: headersObj,
+        body
+      };
+      this.sendMessage(reply);
+    } catch (err) {
+      const reply = {
+        type: "api_result",
+        id: msg.id,
+        ok: false,
+        status: 0,
+        headers: {},
+        body: { error: String(err) }
+      };
+      this.sendMessage(reply);
+    }
+  }
+  invokeCallback(path, callback, args) {
+    this.sendMessage({
+      type: "callback",
+      path,
+      callback,
+      args: args.map(extractEvent)
+    });
+  }
+  acquireChannel(id) {
+    const entry = this.#ensureChannelEntry(id);
+    entry.refCount += 1;
+    return entry.bridge;
+  }
+  releaseChannel(id) {
+    const entry = this.#channels.get(id);
+    if (!entry) {
+      return;
+    }
+    entry.refCount = Math.max(0, entry.refCount - 1);
+    if (entry.refCount === 0) {
+      entry.bridge.dispose(new PulseChannelResetError("Channel released"));
+      this.#channels.delete(id);
+    }
+  }
+  #ensureChannelEntry(id) {
+    let entry = this.#channels.get(id);
+    if (!entry) {
+      entry = {
+        bridge: createChannelBridge(this, id),
+        refCount: 0
+      };
+      this.#channels.set(id, entry);
+    }
+    return entry;
+  }
+  #routeChannelMessage(message) {
+    const entry = this.#ensureChannelEntry(message.channel);
+    const closed = entry.bridge.handleServerMessage(message);
+    if (closed && entry.refCount === 0) {
+      this.#channels.delete(message.channel);
+    }
+  }
+  #handleTransportDisconnect() {
+    for (const entry of this.#channels.values()) {
+      entry.bridge.handleDisconnect(new PulseChannelResetError("Connection lost"));
+    }
+  }
+}
+
+// src/renderer.tsx
+import {
+  cloneElement,
+  createElement,
+  Fragment,
+  isValidElement,
+  lazy,
+  Suspense
+} from "react";
+
+// src/vdom.ts
+var FRAGMENT_TAG = "$$fragment";
+var MOUNT_POINT_PREFIX = "$$";
+function isElementNode(node) {
+  return typeof node === "object" && node !== null;
+}
+function isMountPointNode(node) {
+  return typeof node === "object" && node !== null && node.tag.startsWith(MOUNT_POINT_PREFIX) && node.tag !== FRAGMENT_TAG;
+}
+
+// src/renderer.tsx
+import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
+
+class VDOMRenderer {
+  #callbacks;
+  #callbackCache;
+  #renderPropKeys;
+  #cssProps;
+  #callbackList;
+  #client;
+  #path;
+  #components;
+  #cssModules;
+  constructor(client, path, components, cssModules, initialCallbacks = [], initialRenderProps = [], initialCssRefs = []) {
+    this.#client = client;
+    this.#path = path;
+    this.#components = components;
+    this.#cssModules = cssModules;
+    this.#callbacks = new Set(initialCallbacks);
+    this.#callbackCache = new Map;
+    this.#renderPropKeys = new Set(initialRenderProps);
+    this.#cssProps = new Set(initialCssRefs);
+    this.#callbackList = [...this.#callbacks].sort();
+  }
+  hasCallbackPath(path) {
+    return this.#callbacks.has(path);
+  }
+  hasRenderPropPath(path) {
+    return this.#renderPropKeys.has(path);
+  }
+  hasAnyCallbackUnder(prefix) {
+    if (prefix === "")
+      return this.#callbackList.length > 0;
+    const i = this.#lowerBound(this.#callbackList, prefix);
+    return i < this.#callbackList.length && this.#callbackList[i].startsWith(prefix);
+  }
+  applyCallbackDelta(delta) {
+    if (delta.remove) {
+      for (const key of delta.remove) {
+        this.#callbacks.delete(key);
+        this.#callbackCache.delete(key);
+      }
+    }
+    if (delta.add) {
+      for (const key of delta.add) {
+        this.#callbacks.add(key);
+      }
+    }
+    this.#callbackList = [...this.#callbacks].sort();
+  }
+  applyRenderPropsDelta(delta) {
+    if (delta.remove) {
+      for (const key of delta.remove) {
+        this.#renderPropKeys.delete(key);
+      }
+    }
+    if (delta.add) {
+      for (const key of delta.add) {
+        this.#renderPropKeys.add(key);
+      }
+    }
+  }
+  applyCssRefsDelta(delta) {
+    if (delta.remove) {
+      for (const prop of delta.remove) {
+        this.#cssProps.delete(prop);
+      }
+    }
+    if (delta.add) {
+      for (const prop of delta.add) {
+        this.#cssProps.add(prop);
+      }
+    }
+  }
+  getCallback(path, prop) {
+    const key = this.#propPath(path, prop);
+    let fn = this.#callbackCache.get(key);
+    if (!fn) {
+      fn = (...args) => this.#client.invokeCallback(this.#path, key, args);
+      this.#callbackCache.set(key, fn);
+    }
+    return fn;
+  }
+  renderNode(node, currentPath = "") {
+    if (node == null || typeof node === "boolean" || typeof node === "number" || typeof node === "string") {
+      return node;
+    }
+    if (isElementNode(node)) {
+      const { tag, props = {}, children = [] } = node;
+      const newProps = {};
+      for (const [propName, propValue] of Object.entries(props)) {
+        newProps[propName] = this.transformValue(currentPath, propName, propValue);
+      }
+      if (node.key) {
+        newProps.key = node.key;
+      }
+      const renderedChildren = [];
+      for (let index = 0;index < children.length; index += 1) {
+        const child = children[index];
+        const childPath = currentPath ? `${currentPath}.${index}` : String(index);
+        renderedChildren.push(this.renderNode(child, childPath));
+      }
+      if (isMountPointNode(node)) {
+        const componentKey = node.tag.slice(MOUNT_POINT_PREFIX.length);
+        const Component = this.#components[componentKey];
+        if (!Component) {
+          throw new Error(`Could not find component ${componentKey}. This is a Pulse internal error.`);
+        }
+        return createElement(Component, newProps, ...renderedChildren);
+      }
+      return createElement(tag === FRAGMENT_TAG ? Fragment : tag, newProps, ...renderedChildren);
+    }
+    if (true) {
+      console.error("Unknown VDOM node type:", node);
+    }
+    return null;
+  }
+  #propPath(path, prop) {
+    return path ? `${path}.${prop}` : prop;
+  }
+  transformValue(path, key, value) {
+    const propPath = this.#propPath(path, key);
+    if (this.#callbacks.has(propPath)) {
+      return this.getCallback(path, key);
+    }
+    if (this.#renderPropKeys.has(propPath)) {
+      return this.renderNode(value, propPath);
+    }
+    if (this.#cssProps.has(propPath)) {
+      return this.#resolveCssToken(value);
+    }
+    return value;
+  }
+  #resolveCssToken(token) {
+    const idx = token.indexOf(":");
+    if (idx === -1) {
+      return token;
+    }
+    const moduleId = token.slice(0, idx);
+    const className = token.slice(idx + 1);
+    if (!moduleId || !className) {
+      return token;
+    }
+    const mod = this.#cssModules[moduleId];
+    if (!mod) {
+      throw new Error(`Received CSS reference for unknown module '${moduleId}'`);
+    }
+    const resolved = mod[className];
+    if (typeof resolved !== "string") {
+      throw new Error(`Received CSS reference for missing class '${className}' in module '${moduleId}'`);
+    }
+    return resolved;
+  }
+  init(vdom, callbacks, renderProps, cssRefs) {
+    this.#callbacks = new Set(callbacks);
+    for (const k of Array.from(this.#callbackCache.keys())) {
+      if (!this.#callbacks.has(k))
+        this.#callbackCache.delete(k);
+    }
+    this.#callbackList = [...this.#callbacks].sort();
+    this.#renderPropKeys = new Set(renderProps);
+    this.#cssProps = new Set(cssRefs);
+    return this.renderNode(vdom);
+  }
+  #ensureChildrenArray(el) {
+    const children = el.props?.children;
+    if (children == null)
+      return [];
+    return Array.isArray(children) ? children.slice() : [children];
+  }
+  applyUpdates(initialTree, updates) {
+    let newTree = initialTree;
+    for (const update of updates) {
+      if (update.type === "update_callbacks") {
+        this.applyCallbackDelta(update.data);
+        continue;
+      }
+      if (update.type === "update_css_refs") {
+        this.applyCssRefsDelta(update.data);
+        continue;
+      }
+      if (update.type === "update_render_props") {
+        this.applyRenderPropsDelta(update.data);
+        continue;
+      }
+      const parts = update.path.split(".").filter((s) => s.length > 0);
+      const descend = (node, depth, path) => {
+        if (depth < parts.length) {
+          this.#assertIsElement(node, parts, depth);
+          const element = node;
+          const childKey = parts[depth];
+          const childIdx = +childKey;
+          const childPath = path ? `${path}.${childKey}` : childKey;
+          if (!Number.isNaN(childIdx)) {
+            const childrenArr = this.#ensureChildrenArray(element);
+            const child = childrenArr[childIdx];
+            childrenArr[childIdx] = descend(child, depth + 1, childPath);
+            return cloneElement(element, undefined, ...childrenArr);
+          } else {
+            const baseProps = element.props ?? {};
+            const child = baseProps[childKey];
+            const props = {
+              ...baseProps,
+              [childKey]: descend(child, depth + 1, childPath)
+            };
+            return cloneElement(element, props);
+          }
+        }
+        switch (update.type) {
+          case "replace": {
+            return this.renderNode(update.data, update.path);
+          }
+          case "update_props": {
+            this.#assertIsElement(node, parts, depth);
+            const element = node;
+            const currentProps = element.props ?? {};
+            const nextProps = { ...currentProps };
+            const delta = update.data;
+            if (delta.remove && delta.remove.length > 0) {
+              for (const key of delta.remove) {
+                if (key in nextProps) {
+                  delete nextProps[key];
+                }
+              }
+            }
+            if (delta.set) {
+              for (const [k, v] of Object.entries(delta.set)) {
+                nextProps[k] = this.transformValue(path, k, v);
+              }
+            }
+            const removedSomething = (delta.remove?.length ?? 0) > 0;
+            if (removedSomething) {
+              nextProps.key = element.key;
+              nextProps.ref = element.ref;
+              return createElement(element.type, nextProps, ...this.#ensureChildrenArray(element));
+            } else {
+              return cloneElement(element, nextProps);
+            }
+          }
+          case "reconciliation": {
+            this.#assertIsElement(node, parts, depth);
+            const element = node;
+            const prevChildren = this.#ensureChildrenArray(element);
+            const nextChildren = [];
+            const [newIndices, newContents] = update.new;
+            const [reuseIndices, reuseSources] = update.reuse;
+            let nextNew = -1, nextReuse = -1, newIdx = -1, reuseIdx = -1;
+            if (newIndices.length > 0) {
+              nextNew = newIndices[0];
+              newIdx = 0;
+            }
+            if (reuseIndices.length > 0) {
+              nextReuse = reuseIndices[0];
+              reuseIdx = 0;
+            }
+            for (let i = 0;i < update.N; ++i) {
+              if (i === nextNew) {
+                const contents = newContents[newIdx];
+                const childPath = path ? `${path}.${i}` : String(i);
+                nextChildren.push(this.renderNode(contents, childPath));
+                nextNew = newIdx < newIndices.length - 1 ? newIndices[++newIdx] : -1;
+              } else if (i === nextReuse) {
+                const srcIdx = reuseSources[reuseIdx];
+                let src = prevChildren[srcIdx];
+                const childPath = path ? `${path}.${i}` : String(i);
+                if (this.hasAnyCallbackUnder(childPath)) {
+                  src = this.#rebindCallbacksInSubtree(src, childPath);
+                }
+                nextChildren.push(src);
+                nextReuse = reuseIdx < reuseIndices.length - 1 ? reuseIndices[++reuseIdx] : -1;
+              } else {
+                nextChildren.push(prevChildren[i]);
+              }
+            }
+            return cloneElement(element, null, ...nextChildren);
+          }
+          default:
+            throw new Error(`[Pulse renderer] Unknown update type: ${update?.type}`);
+        }
+      };
+      newTree = descend(newTree, 0, "");
+    }
+    return newTree;
+  }
+  #assertIsElement(node, parts, depth) {
+    if (!isValidElement(node)) {
+      console.error("Invalid node:", node);
+      throw new Error(`Invalid node at path ${parts.slice(0, depth).join(".")}`);
+    }
+    return true;
+  }
+  #rebindCallbacksInSubtree(node, path) {
+    if (!isValidElement(node))
+      return node;
+    const element = node;
+    const baseProps = element.props ?? {};
+    const nextProps = { ...baseProps };
+    for (const key of Object.keys(baseProps)) {
+      const propPath = path ? `${path}.${key}` : key;
+      if (this.hasCallbackPath(propPath)) {
+        nextProps[key] = this.getCallback(path, key);
+      }
+      if (this.hasRenderPropPath(propPath) && this.hasAnyCallbackUnder(propPath)) {
+        nextProps[key] = this.#rebindCallbacksInSubtree(baseProps[key], propPath);
+      }
+    }
+    const children = this.#ensureChildrenArray(element).map((child, idx) => {
+      const childPath = path ? `${path}.${idx}` : String(idx);
+      if (this.hasAnyCallbackUnder(childPath)) {
+        return this.#rebindCallbacksInSubtree(child, childPath);
+      } else {
+        return child;
+      }
+    });
+    return cloneElement(element, nextProps, ...children);
+  }
+  #lowerBound(arr, target) {
+    let lo = 0;
+    let hi = arr.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (arr[mid] < target) {
+        lo = mid + 1;
+      } else {
+        hi = mid;
+      }
+    }
+    return lo;
+  }
+}
+function RenderLazy(component, fallback) {
+  const Component = lazy(component);
+  return ({ children, ...props }) => {
+    return /* @__PURE__ */ jsxDEV2(Suspense, {
+      fallback,
+      children: /* @__PURE__ */ jsxDEV2(Component, {
+        ...props,
+        children
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  };
+}
+
+// src/pulse.tsx
+import { jsxDEV as jsxDEV3 } from "react/jsx-dev-runtime";
+var PulseClientContext = createContext(null);
+var PulsePrerenderContext = createContext(null);
+var usePulseClient = () => {
+  const client = useContext(PulseClientContext);
+  if (!client) {
+    throw new Error("usePulseClient must be used within a PulseProvider");
+  }
+  return client;
+};
+var usePulsePrerender = (path) => {
+  const ctx = useContext(PulsePrerenderContext);
+  if (!ctx) {
+    throw new Error("usePulsePrerender must be used within a PulseProvider");
+  }
+  const view = ctx.views[path];
+  if (!view) {
+    throw new Error(`No prerender found for '${path}'`);
+  }
+  return view;
+};
+var inBrowser = typeof window !== "undefined";
+function PulseProvider({ children, config, prerender }) {
+  const [connected, setConnected] = useState(true);
+  const rrNavigate = useNavigate();
+  const { renderId } = prerender;
+  const client = useMemo(() => new PulseSocketIOClient(config.serverAddress, renderId, rrNavigate), [config.serverAddress, rrNavigate, renderId]);
+  useEffect(() => client.onConnectionChange(setConnected), [client]);
+  useEffect(() => {
+    if (inBrowser) {
+      client.connect();
+      return () => client.disconnect();
+    }
+  }, [client]);
+  return /* @__PURE__ */ jsxDEV3(PulseClientContext.Provider, {
+    value: client,
+    children: /* @__PURE__ */ jsxDEV3(PulsePrerenderContext.Provider, {
+      value: prerender,
+      children: [
+        !connected && /* @__PURE__ */ jsxDEV3("div", {
+          style: {
+            position: "fixed",
+            bottom: "20px",
+            right: "20px",
+            backgroundColor: "red",
+            color: "white",
+            padding: "10px",
+            borderRadius: "5px",
+            zIndex: 1000
+          },
+          children: "Failed to connect to the server."
+        }, undefined, false, undefined, this),
+        children
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function PulseView({ externalComponents, path, cssModules }) {
+  const client = usePulseClient();
+  const initialView = usePulsePrerender(path);
+  const initialVDOM = initialView.vdom;
+  const renderer = useMemo(() => new VDOMRenderer(client, path, externalComponents, cssModules, initialView.callbacks, initialView.render_props, initialView.css_refs), [client, path, externalComponents, cssModules, initialView]);
+  const [tree, setTree] = useState(() => renderer.init(initialVDOM, initialView.callbacks, initialView.render_props, initialView.css_refs));
+  const [serverError, setServerError] = useState(null);
+  const location = useLocation();
+  const params = useParams();
+  const routeInfo = useMemo(() => {
+    const { "*": catchall = "", ...pathParams } = params;
+    const queryParams = new URLSearchParams(location.search);
+    return {
+      hash: location.hash,
+      pathname: location.pathname,
+      query: location.search,
+      queryParams: Object.fromEntries(queryParams.entries()),
+      pathParams,
+      catchall: catchall.length > 0 ? catchall.split("/") : []
+    };
+  }, [location.hash, location.pathname, location.search, JSON.stringify(params)]);
+  useEffect(() => {
+    if (inBrowser) {
+      client.mountView(path, {
+        routeInfo,
+        onInit: (vdom, callbacks, renderProps, cssRefs) => {
+          setTree(renderer.init(vdom, callbacks, renderProps, cssRefs));
+        },
+        onUpdate: (ops) => {
+          setTree((prev) => prev == null ? prev : renderer.applyUpdates(prev, ops));
+        }
+      });
+      const offErr = client.onServerError((p, err) => {
+        if (p === path)
+          setServerError(err);
+      });
+      return () => {
+        offErr();
+        client.unmount(path);
+      };
+    }
+  }, [client, renderer, path, routeInfo]);
+  useEffect(() => {
+    if (inBrowser) {
+      client.navigate(path, routeInfo);
+    }
+  }, [client, path, routeInfo]);
+  if (serverError) {
+    return /* @__PURE__ */ jsxDEV3(ServerError, {
+      error: serverError
+    }, undefined, false, undefined, this);
+  }
+  return tree;
+}
+function ServerError({ error }) {
+  return /* @__PURE__ */ jsxDEV3("div", {
+    style: {
+      padding: 16,
+      border: "1px solid #e00",
+      background: "#fff5f5",
+      color: "#900",
+      fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace',
+      whiteSpace: "pre-wrap"
+    },
+    children: [
+      /* @__PURE__ */ jsxDEV3("div", {
+        style: { fontWeight: 700, marginBottom: 8 },
+        children: [
+          "Server Error during ",
+          error.phase
+        ]
+      }, undefined, true, undefined, this),
+      error.message && /* @__PURE__ */ jsxDEV3("div", {
+        children: error.message
+      }, undefined, false, undefined, this),
+      error.stack && /* @__PURE__ */ jsxDEV3("details", {
+        open: true,
+        style: { marginTop: 8 },
+        children: [
+          /* @__PURE__ */ jsxDEV3("summary", {
+            children: "Stack trace"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV3("pre", {
+            style: { margin: 0 },
+            children: error.stack
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/usePulseChannel.ts
+import { useEffect as useEffect2, useMemo as useMemo2 } from "react";
+function usePulseChannel(channelId) {
+  const client = usePulseClient();
+  const bridge = useMemo2(() => {
+    if (!channelId) {
+      throw new Error("usePulseChannel requires a non-empty channelId");
+    }
+    return client.acquireChannel(channelId);
+  }, [client, channelId]);
+  useEffect2(() => {
+    return () => {
+      client.releaseChannel(channelId);
+    };
+  }, [client, channelId]);
+  return bridge;
+}
+export {
+  usePulseClient,
+  usePulseChannel,
+  submitForm,
+  serialize,
+  extractServerRouteInfo,
+  deserialize,
+  RenderLazy,
+  PulseView,
+  PulseProvider,
+  PulseForm,
+  PulseChannelResetError
+};
+
+//# debugId=E3FD7CD6C93459F364756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/channel.ts", "../src/form.tsx", "../src/helpers.ts", "../src/pulse.tsx", "../src/client.tsx", "../src/serialize/extractor.ts", "../src/serialize/elements.ts", "../src/serialize/events.ts", "../src/serialize/serializer.ts", "../src/renderer.tsx", "../src/vdom.ts", "../src/usePulseChannel.ts"],
  "sourcesContent": [
    "import type { PulseSocketIOClient } from \"./client\";\nimport type {\n\tServerChannelMessage,\n\tServerChannelRequestMessage,\n\tServerChannelResponseMessage,\n} from \"./messages\";\n\nexport class PulseChannelResetError extends Error {\n\tconstructor(message: string) {\n\t\tsuper(message);\n\t\tthis.name = \"PulseChannelResetError\";\n\t}\n}\n\nexport type ChannelEventHandler = (payload: any) => any | Promise<any>;\n\ninterface PendingRequest {\n\tresolve: (value: any) => void;\n\treject: (error: any) => void;\n}\n\nfunction randomId(): string {\n\tif (typeof crypto !== \"undefined\" && typeof crypto.randomUUID === \"function\") {\n\t\treturn crypto.randomUUID().replace(/-/g, \"\");\n\t}\n\treturn Math.random().toString(16).slice(2) + Math.random().toString(16).slice(2);\n}\n\nfunction formatError(error: unknown): string {\n\tif (error instanceof Error) return error.message;\n\tif (typeof error === \"string\") return error;\n\ttry {\n\t\treturn JSON.stringify(error);\n\t} catch {\n\t\treturn String(error);\n\t}\n}\n\nfunction isServerResponseMessage(\n\tmessage: ServerChannelMessage,\n): message is ServerChannelResponseMessage {\n\treturn typeof (message as ServerChannelResponseMessage).responseTo === \"string\";\n}\n\nfunction isServerRequestMessage(\n\tmessage: ServerChannelMessage,\n): message is ServerChannelRequestMessage {\n\treturn typeof (message as ServerChannelRequestMessage).event === \"string\";\n}\n\nexport class ChannelBridge {\n\tprivate handlers = new Map<string, Set<ChannelEventHandler>>();\n\tprivate pending = new Map<string, PendingRequest>();\n\tprivate backlog: ServerChannelRequestMessage[] = [];\n\tprivate closed = false;\n\n\tconstructor(\n\t\tprivate client: PulseSocketIOClient,\n\t\tpublic readonly id: string,\n\t) {}\n\n\temit(event: string, payload?: any): void {\n\t\tthis.ensureOpen();\n\t\tthis.client.sendMessage({\n\t\t\ttype: \"channel_message\",\n\t\t\tchannel: this.id,\n\t\t\tevent,\n\t\t\tpayload,\n\t\t});\n\t}\n\n\trequest(event: string, payload?: any): Promise<any> {\n\t\tthis.ensureOpen();\n\t\tconst requestId = randomId();\n\t\treturn new Promise((resolve, reject) => {\n\t\t\tthis.pending.set(requestId, { resolve, reject });\n\t\t\tthis.client.sendMessage({\n\t\t\t\ttype: \"channel_message\",\n\t\t\t\tchannel: this.id,\n\t\t\t\tevent,\n\t\t\t\tpayload,\n\t\t\t\trequestId,\n\t\t\t});\n\t\t});\n\t}\n\n\ton(event: string, handler: ChannelEventHandler): () => void {\n\t\tthis.ensureOpen();\n\t\tlet bucket = this.handlers.get(event);\n\t\tif (!bucket) {\n\t\t\tbucket = new Set();\n\t\t\tthis.handlers.set(event, bucket);\n\t\t}\n\t\tbucket.add(handler);\n\t\tthis.flushBacklog(event);\n\t\treturn () => {\n\t\t\tconst set = this.handlers.get(event);\n\t\t\tif (!set) return;\n\t\t\tset.delete(handler);\n\t\t\tif (set.size === 0) {\n\t\t\t\tthis.handlers.delete(event);\n\t\t\t}\n\t\t};\n\t}\n\n\thandleServerMessage(message: ServerChannelMessage): boolean {\n\t\tif (isServerResponseMessage(message)) {\n\t\t\tthis.resolvePending(message);\n\t\t\treturn this.closed;\n\t\t}\n\t\tif (this.closed) {\n\t\t\treturn true;\n\t\t}\n\t\tif (!isServerRequestMessage(message)) {\n\t\t\treturn this.closed;\n\t\t}\n\n\t\tif (message.event === \"__close__\") {\n\t\t\tthis.close(new PulseChannelResetError(\"Channel closed by server\"));\n\t\t\treturn true;\n\t\t}\n\t\tif (message.requestId) {\n\t\t\tvoid this.dispatchRequest(\n\t\t\t\tmessage as ServerChannelRequestMessage & {\n\t\t\t\t\trequestId: string;\n\t\t\t\t},\n\t\t\t);\n\t\t} else {\n\t\t\tthis.dispatchEvent(message);\n\t\t}\n\t\treturn this.closed;\n\t}\n\n\thandleDisconnect(reason: PulseChannelResetError): void {\n\t\tthis.close(reason);\n\t}\n\n\tdispose(reason: PulseChannelResetError): void {\n\t\tthis.close(reason);\n\t}\n\n\tprivate ensureOpen(): void {\n\t\tif (this.closed) {\n\t\t\tthrow new PulseChannelResetError(\"Channel is closed\");\n\t\t}\n\t}\n\n\tprivate flushBacklog(event: string): void {\n\t\tif (this.backlog.length === 0) return;\n\t\tconst remaining: ServerChannelRequestMessage[] = [];\n\t\tfor (const item of this.backlog) {\n\t\t\tif (item.event === event) {\n\t\t\t\tthis.dispatchEvent(item);\n\t\t\t} else {\n\t\t\t\tremaining.push(item);\n\t\t\t}\n\t\t}\n\t\tthis.backlog = remaining;\n\t}\n\n\tprivate dispatchEvent(message: ServerChannelRequestMessage): void {\n\t\tconst handlers = this.handlers.get(message.event);\n\t\tif (!handlers || handlers.size === 0) {\n\t\t\tthis.backlog.push(message);\n\t\t\treturn;\n\t\t}\n\t\tfor (const handler of handlers) {\n\t\t\ttry {\n\t\t\t\tconst result = handler(message.payload);\n\t\t\t\tif (result && typeof (result as Promise<any>).then === \"function\") {\n\t\t\t\t\tvoid (result as Promise<any>).catch((err) => {\n\t\t\t\t\t\tconsole.error(\"Pulse channel handler error\", err);\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t} catch (err) {\n\t\t\t\tconsole.error(\"Pulse channel handler error\", err);\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate async dispatchRequest(\n\t\tmessage: ServerChannelRequestMessage & { requestId: string },\n\t): Promise<void> {\n\t\tconst handlers = this.handlers.get(message.event);\n\t\tlet response: any;\n\t\tlet error: any;\n\t\tif (handlers && handlers.size > 0) {\n\t\t\tfor (const handler of handlers) {\n\t\t\t\ttry {\n\t\t\t\t\tconst result = handler(message.payload);\n\t\t\t\t\tresponse = await Promise.resolve(result);\n\t\t\t\t\tif (response !== undefined) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t} catch (err) {\n\t\t\t\t\terror = err;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (error) {\n\t\t\tthis.client.sendMessage({\n\t\t\t\ttype: \"channel_message\",\n\t\t\t\tchannel: this.id,\n\t\t\t\tevent: undefined,\n\t\t\t\tresponseTo: message.requestId,\n\t\t\t\terror: formatError(error),\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\t\tthis.client.sendMessage({\n\t\t\ttype: \"channel_message\",\n\t\t\tchannel: this.id,\n\t\t\tevent: undefined,\n\t\t\tresponseTo: message.requestId,\n\t\t\tpayload: response,\n\t\t});\n\t}\n\n\tprivate resolvePending(message: ServerChannelResponseMessage): void {\n\t\tconst entry = message.responseTo ? this.pending.get(message.responseTo) : undefined;\n\t\tif (!entry) {\n\t\t\treturn;\n\t\t}\n\t\tthis.pending.delete(message.responseTo!);\n\t\tif (message.error !== undefined && message.error !== null) {\n\t\t\tentry.reject(new PulseChannelResetError(String(message.error)));\n\t\t} else {\n\t\t\tentry.resolve(message.payload);\n\t\t}\n\t}\n\n\tprivate close(reason: PulseChannelResetError): void {\n\t\tif (this.closed) {\n\t\t\treturn;\n\t\t}\n\t\tthis.closed = true;\n\t\tfor (const request of this.pending.values()) {\n\t\t\trequest.reject(reason);\n\t\t}\n\t\tthis.pending.clear();\n\t\tthis.handlers.clear();\n\t\tthis.backlog = [];\n\t\t// No-op: owning client manages registry lifecycle.\n\t}\n}\n\nexport function createChannelBridge(client: PulseSocketIOClient, id: string): ChannelBridge {\n\treturn new ChannelBridge(client, id);\n}\n",
    "import React, { type FormEvent, forwardRef, useCallback } from \"react\";\n\nexport type PulseFormProps = React.ComponentPropsWithoutRef<\"form\"> & {\n\taction: string;\n};\n\n/**\n * PulseForm intercepts native form submissions and sends them through fetch so the\n * surrounding Pulse view stays mounted. Server-side handlers are still invoked via\n * the form action endpoint and reactive updates propagate over the socket.\n */\nexport const PulseForm = forwardRef<HTMLFormElement, PulseFormProps>(function PulseForm(\n\t{ onSubmit, action, ...rest },\n\tref,\n) {\n\treturn (\n\t\t<form\n\t\t\t{...rest}\n\t\t\taction={action}\n\t\t\tref={ref}\n\t\t\tonSubmit={useCallback(\n\t\t\t\t(event: FormEvent<HTMLFormElement>) => submitForm({ event, action, onSubmit }),\n\t\t\t\t[action, onSubmit],\n\t\t\t)}\n\t\t/>\n\t);\n});\n\ninterface SubmitForm {\n\tevent: React.FormEvent<HTMLFormElement>;\n\taction: string;\n\tonSubmit?: PulseFormProps[\"onSubmit\"];\n\tformData?: FormData;\n\tforce?: boolean;\n}\n\nexport async function submitForm({ event, action, onSubmit, formData, force }: SubmitForm) {\n\tonSubmit?.(event);\n\tif (!force && event.defaultPrevented) {\n\t\treturn;\n\t}\n\tconst form = event.currentTarget;\n\tevent.preventDefault();\n\tconst nativeEvent = event.nativeEvent as SubmitEvent;\n\tif (!formData) {\n\t\tformData = new FormData(form, nativeEvent.submitter);\n\t}\n\tconst url = new URL(action, window.location.href);\n\ttry {\n\t\tawait fetch(url, {\n\t\t\tmethod: \"POST\",\n\t\t\t// Required for our hosting scenarios of same host + different ports or 2 subdomains\n\t\t\tcredentials: \"include\",\n\t\t\tbody: formData,\n\t\t});\n\t} catch (err) {\n\t\tif (process.env.NODE_ENV !== \"production\") {\n\t\t\tconsole.error(\"[Pulse] Form submission failed\", err);\n\t\t} else {\n\t\t\tthrow err;\n\t\t}\n\t}\n}\n",
    "import type { LoaderFunctionArgs } from \"react-router\";\n\nexport interface RouteInfo {\n\tpathname: string;\n\thash: string;\n\tquery: string;\n\tqueryParams: Record<string, string>;\n\tpathParams: Record<string, string | undefined>;\n\tcatchall: string[];\n}\n\nexport function extractServerRouteInfo({ params, request }: LoaderFunctionArgs) {\n\tconst { \"*\": catchall = \"\", ...pathParams } = params;\n\tconst parsedUrl = new URL(request.url);\n\n\treturn {\n\t\thash: parsedUrl.hash,\n\t\tpathname: parsedUrl.pathname,\n\t\tquery: parsedUrl.search,\n\t\tqueryParams: Object.fromEntries(parsedUrl.searchParams.entries()),\n\t\tpathParams,\n\t\tcatchall: catchall.length > 1 ? catchall.split(\"/\") : [],\n\t} satisfies RouteInfo;\n}\n",
    "import { createContext, type ReactNode, useContext, useEffect, useMemo, useState } from \"react\";\nimport { useLocation, useNavigate, useParams } from \"react-router\";\nimport { PulseSocketIOClient } from \"./client\";\nimport type { RouteInfo } from \"./helpers\";\nimport type { ServerErrorInfo } from \"./messages\";\nimport { VDOMRenderer } from \"./renderer\";\nimport type { ComponentRegistry, VDOM } from \"./vdom\";\n\n// =================================================================\n// Types\n// =================================================================\n\nexport interface PulseConfig {\n\tserverAddress: string;\n}\n\nexport type PulsePrerenderView = {\n\tvdom: VDOM;\n\tcallbacks: string[];\n\trender_props: string[];\n\tcss_refs: string[];\n};\n\nexport type PulsePrerender = {\n\trenderId: string;\n\tviews: Record<string, PulsePrerenderView>;\n};\n// =================================================================\n// Context and Hooks\n// =================================================================\n\n// Context for the client, provided by PulseProvider\nconst PulseClientContext = createContext<PulseSocketIOClient | null>(null);\nconst PulsePrerenderContext = createContext<PulsePrerender | null>(null);\n\nexport const usePulseClient = () => {\n\tconst client = useContext(PulseClientContext);\n\tif (!client) {\n\t\tthrow new Error(\"usePulseClient must be used within a PulseProvider\");\n\t}\n\treturn client;\n};\n\nexport const usePulsePrerender = (path: string) => {\n\tconst ctx = useContext(PulsePrerenderContext);\n\tif (!ctx) {\n\t\tthrow new Error(\"usePulsePrerender must be used within a PulseProvider\");\n\t}\n\tconst view = ctx.views[path];\n\tif (!view) {\n\t\tthrow new Error(`No prerender found for '${path}'`);\n\t}\n\treturn view;\n};\n\n// =================================================================\n// Provider\n// =================================================================\n\nexport interface PulseProviderProps {\n\tchildren: ReactNode;\n\tconfig: PulseConfig;\n\tprerender: PulsePrerender;\n}\n\nconst inBrowser = typeof window !== \"undefined\";\n\nexport function PulseProvider({ children, config, prerender }: PulseProviderProps) {\n\tconst [connected, setConnected] = useState(true);\n\tconst rrNavigate = useNavigate();\n\tconst { renderId } = prerender;\n\n\tconst client = useMemo(\n\t\t() => new PulseSocketIOClient(config.serverAddress, renderId, rrNavigate),\n\t\t[config.serverAddress, rrNavigate, renderId],\n\t);\n\n\tuseEffect(() => client.onConnectionChange(setConnected), [client]);\n\n\tuseEffect(() => {\n\t\tif (inBrowser) {\n\t\t\tclient.connect();\n\t\t\treturn () => client.disconnect();\n\t\t}\n\t}, [client]);\n\n\treturn (\n\t\t<PulseClientContext.Provider value={client}>\n\t\t\t<PulsePrerenderContext.Provider value={prerender}>\n\t\t\t\t{!connected && (\n\t\t\t\t\t<div\n\t\t\t\t\t\tstyle={{\n\t\t\t\t\t\t\tposition: \"fixed\",\n\t\t\t\t\t\t\tbottom: \"20px\",\n\t\t\t\t\t\t\tright: \"20px\",\n\t\t\t\t\t\t\tbackgroundColor: \"red\",\n\t\t\t\t\t\t\tcolor: \"white\",\n\t\t\t\t\t\t\tpadding: \"10px\",\n\t\t\t\t\t\t\tborderRadius: \"5px\",\n\t\t\t\t\t\t\tzIndex: 1000,\n\t\t\t\t\t\t}}\n\t\t\t\t\t>\n\t\t\t\t\t\tFailed to connect to the server.\n\t\t\t\t\t</div>\n\t\t\t\t)}\n\t\t\t\t{children}\n\t\t\t</PulsePrerenderContext.Provider>\n\t\t</PulseClientContext.Provider>\n\t);\n}\n\n// =================================================================\n// View\n// =================================================================\n\nexport interface PulseViewProps {\n\texternalComponents: ComponentRegistry;\n\tpath: string;\n\tcssModules: Record<string, Record<string, string>>;\n}\n\nexport function PulseView({ externalComponents, path, cssModules }: PulseViewProps) {\n\tconst client = usePulseClient();\n\tconst initialView = usePulsePrerender(path);\n\tconst initialVDOM = initialView.vdom;\n\tconst renderer = useMemo(\n\t\t() =>\n\t\t\tnew VDOMRenderer(\n\t\t\t\tclient,\n\t\t\t\tpath,\n\t\t\t\texternalComponents,\n\t\t\t\tcssModules,\n\t\t\t\tinitialView.callbacks,\n\t\t\t\tinitialView.render_props,\n\t\t\t\tinitialView.css_refs,\n\t\t\t),\n\t\t[client, path, externalComponents, cssModules, initialView],\n\t);\n\tconst [tree, setTree] = useState<ReactNode>(() =>\n\t\trenderer.init(\n\t\t\tinitialVDOM,\n\t\t\tinitialView.callbacks,\n\t\t\tinitialView.render_props,\n\t\t\tinitialView.css_refs,\n\t\t),\n\t);\n\tconst [serverError, setServerError] = useState<ServerErrorInfo | null>(null);\n\n\tconst location = useLocation();\n\tconst params = useParams();\n\n\t// biome-ignore lint/correctness/useExhaustiveDependencies: using hacky deep equality for params\n\tconst routeInfo = useMemo(() => {\n\t\tconst { \"*\": catchall = \"\", ...pathParams } = params;\n\t\tconst queryParams = new URLSearchParams(location.search);\n\t\treturn {\n\t\t\thash: location.hash,\n\t\t\tpathname: location.pathname,\n\t\t\tquery: location.search,\n\t\t\tqueryParams: Object.fromEntries(queryParams.entries()),\n\t\t\tpathParams,\n\t\t\tcatchall: catchall.length > 0 ? catchall.split(\"/\") : [],\n\t\t} satisfies RouteInfo;\n\t}, [location.hash, location.pathname, location.search, JSON.stringify(params)]);\n\n\tuseEffect(() => {\n\t\tif (inBrowser) {\n\t\t\tclient.mountView(path, {\n\t\t\t\trouteInfo,\n\t\t\t\tonInit: (vdom, callbacks, renderProps, cssRefs) => {\n\t\t\t\t\tsetTree(renderer.init(vdom, callbacks, renderProps, cssRefs));\n\t\t\t\t},\n\t\t\t\tonUpdate: (ops) => {\n\t\t\t\t\tsetTree((prev) => (prev == null ? prev : renderer.applyUpdates(prev, ops)));\n\t\t\t\t},\n\t\t\t});\n\t\t\tconst offErr = client.onServerError((p, err) => {\n\t\t\t\tif (p === path) setServerError(err);\n\t\t\t});\n\t\t\treturn () => {\n\t\t\t\toffErr();\n\t\t\t\tclient.unmount(path);\n\t\t\t};\n\t\t}\n\t\t// routeInfo is NOT included here on purpose\n\t}, [client, renderer, path, routeInfo]);\n\n\tuseEffect(() => {\n\t\tif (inBrowser) {\n\t\t\tclient.navigate(path, routeInfo);\n\t\t}\n\t}, [client, path, routeInfo]);\n\n\tif (serverError) {\n\t\treturn <ServerError error={serverError} />;\n\t}\n\n\treturn tree;\n}\n\nfunction ServerError({ error }: { error: ServerErrorInfo }) {\n\treturn (\n\t\t<div\n\t\t\tstyle={{\n\t\t\t\tpadding: 16,\n\t\t\t\tborder: \"1px solid #e00\",\n\t\t\t\tbackground: \"#fff5f5\",\n\t\t\t\tcolor: \"#900\",\n\t\t\t\tfontFamily:\n\t\t\t\t\t'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, \"Liberation Mono\", \"Courier New\", monospace',\n\t\t\t\twhiteSpace: \"pre-wrap\",\n\t\t\t}}\n\t\t>\n\t\t\t<div style={{ fontWeight: 700, marginBottom: 8 }}>Server Error during {error.phase}</div>\n\t\t\t{error.message && <div>{error.message}</div>}\n\t\t\t{error.stack && (\n\t\t\t\t<details open style={{ marginTop: 8 }}>\n\t\t\t\t\t<summary>Stack trace</summary>\n\t\t\t\t\t<pre style={{ margin: 0 }}>{error.stack}</pre>\n\t\t\t\t</details>\n\t\t\t)}\n\t\t</div>\n\t);\n}\n",
    "import type { NavigateFunction } from \"react-router\";\nimport { io, type Socket } from \"socket.io-client\";\nimport type { ChannelBridge } from \"./channel\";\nimport { createChannelBridge, PulseChannelResetError } from \"./channel\";\nimport type { RouteInfo } from \"./helpers\";\nimport type {\n\tClientApiResultMessage,\n\tClientMessage,\n\tServerApiCallMessage,\n\tServerChannelMessage,\n\tServerErrorInfo,\n\tServerMessage,\n} from \"./messages\";\nimport { extractEvent } from \"./serialize/events\";\nimport { deserialize, serialize } from \"./serialize/serializer\";\nimport type { VDOM, VDOMUpdate } from \"./vdom\";\n\nexport interface MountedView {\n\trouteInfo: RouteInfo;\n\tonInit: (vdom: VDOM, callbacks: string[], renderProps: string[], cssRefs: string[]) => void;\n\tonUpdate: (ops: VDOMUpdate[]) => void;\n}\nexport type ConnectionStatusListener = (connected: boolean) => void;\nexport type ServerErrorListener = (path: string, error: ServerErrorInfo | null) => void;\n\nexport interface PulseClient {\n\t// Connection management\n\tconnect(): Promise<void>;\n\tdisconnect(): void;\n\tisConnected(): boolean;\n\tonConnectionChange(listener: ConnectionStatusListener): () => void;\n\t// Messages\n\tnavigate(path: string, routeInfo: RouteInfo): Promise<void>;\n\tleave(path: string): Promise<void>;\n\tinvokeCallback(path: string, callback: string, args: any[]): Promise<void>;\n\t// VDOM subscription\n\tmountView(path: string, view: MountedView): () => void;\n}\n\nexport class PulseSocketIOClient {\n\t#activeViews: Map<string, MountedView>;\n\t#socket: Socket | null = null;\n\t#messageQueue: ClientMessage[];\n\t#connectionListeners: Set<ConnectionStatusListener> = new Set();\n\t#serverErrors: Map<string, ServerErrorInfo> = new Map();\n\t#serverErrorListeners: Set<ServerErrorListener> = new Set();\n\t#channels: Map<string, { bridge: ChannelBridge; refCount: number }> = new Map();\n\t#url: string;\n\t#renderId: string;\n\t#frameworkNavigate: NavigateFunction;\n\n\tconstructor(url: string, renderId: string, frameworkNavigate: NavigateFunction) {\n\t\tthis.#url = url;\n\t\tthis.#renderId = renderId;\n\t\tthis.#frameworkNavigate = frameworkNavigate;\n\t\tthis.#socket = null;\n\t\tthis.#activeViews = new Map();\n\t\tthis.#messageQueue = [];\n\t}\n\tpublic isConnected(): boolean {\n\t\treturn this.#socket?.connected ?? false;\n\t}\n\n\tpublic async connect(): Promise<void> {\n\t\tif (this.#socket) {\n\t\t\treturn;\n\t\t}\n\t\treturn new Promise((resolve, reject) => {\n\t\t\tconst socket = io(this.#url, {\n\t\t\t\ttransports: [\"websocket\", \"webtransport\"],\n\t\t\t\tauth: { renderId: this.#renderId },\n\t\t\t});\n\t\t\tthis.#socket = socket;\n\n\t\t\tsocket.on(\"connect\", () => {\n\t\t\t\tconsole.log(\"[SocketIOTransport] Connected:\", this.#socket?.id);\n\t\t\t\t// Make sure to send a navigate payload for all the routes\n\t\t\t\tfor (const [path, route] of this.#activeViews) {\n\t\t\t\t\tsocket.emit(\n\t\t\t\t\t\t\"message\",\n\t\t\t\t\t\tserialize({\n\t\t\t\t\t\t\ttype: \"mount\",\n\t\t\t\t\t\t\tpath: path,\n\t\t\t\t\t\t\trouteInfo: route.routeInfo,\n\t\t\t\t\t\t}),\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\tfor (const payload of this.#messageQueue) {\n\t\t\t\t\t// Already sent above\n\t\t\t\t\tif (payload.type === \"mount\" && this.#activeViews.has(payload.path)) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\t// We're remounting all the routes, so no need to navigate\n\t\t\t\t\tif (payload.type === \"navigate\") {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tsocket.emit(\"message\", serialize(payload));\n\t\t\t\t}\n\t\t\t\tthis.#messageQueue = [];\n\n\t\t\t\tthis.notifyConnectionListeners(true);\n\t\t\t\tresolve();\n\t\t\t});\n\n\t\t\tsocket.on(\"connect_error\", (err) => {\n\t\t\t\tconsole.error(\"[SocketIOTransport] Connection failed:\", err);\n\t\t\t\tthis.notifyConnectionListeners(false);\n\t\t\t\treject(err);\n\t\t\t});\n\n\t\t\tsocket.on(\"disconnect\", () => {\n\t\t\t\tconsole.log(\"[SocketIOTransport] Disconnected\");\n\t\t\t\tthis.#handleTransportDisconnect();\n\t\t\t\tthis.notifyConnectionListeners(false);\n\t\t\t});\n\n\t\t\t// Wrap in an arrow function to avoid losing the `this` reference\n\t\t\tsocket.on(\"message\", (data) =>\n\t\t\t\tthis.#handleServerMessage(deserialize(data, { coerceNullsToUndefined: true })),\n\t\t\t);\n\t\t});\n\t}\n\n\tonConnectionChange(listener: ConnectionStatusListener): () => void {\n\t\tthis.#connectionListeners.add(listener);\n\t\tlistener(this.isConnected());\n\t\treturn () => {\n\t\t\tthis.#connectionListeners.delete(listener);\n\t\t};\n\t}\n\n\tprivate notifyConnectionListeners(connected: boolean): void {\n\t\tfor (const listener of this.#connectionListeners) {\n\t\t\tlistener(connected);\n\t\t}\n\t}\n\n\tpublic onServerError(listener: ServerErrorListener): () => void {\n\t\tthis.#serverErrorListeners.add(listener);\n\t\t// Emit current errors to new listener\n\t\tfor (const [path, err] of this.#serverErrors) listener(path, err);\n\t\treturn () => {\n\t\t\tthis.#serverErrorListeners.delete(listener);\n\t\t};\n\t}\n\n\tprivate notifyServerError(path: string, error: ServerErrorInfo | null) {\n\t\tfor (const listener of this.#serverErrorListeners) listener(path, error);\n\t}\n\n\tpublic sendMessage(payload: ClientMessage) {\n\t\tif (this.isConnected()) {\n\t\t\t// console.log(\"[SocketIOTransport] Sending:\", payload);\n\t\t\tthis.#socket!.emit(\"message\", serialize(payload as any));\n\t\t} else {\n\t\t\t// console.log(\"[SocketIOTransport] Queuing message:\", payload);\n\t\t\tthis.#messageQueue.push(payload);\n\t\t}\n\t}\n\n\tpublic mountView(path: string, view: MountedView) {\n\t\tif (this.#activeViews.has(path)) {\n\t\t\tthrow new Error(`Path ${path} is already mounted`);\n\t\t}\n\t\tthis.#activeViews.set(path, view);\n\t\tvoid this.sendMessage({\n\t\t\ttype: \"mount\",\n\t\t\tpath,\n\t\t\trouteInfo: view.routeInfo,\n\t\t});\n\t}\n\n\tpublic async navigate(path: string, routeInfo: RouteInfo) {\n\t\tawait this.sendMessage({\n\t\t\ttype: \"navigate\",\n\t\t\tpath,\n\t\t\trouteInfo,\n\t\t});\n\t}\n\n\tpublic unmount(path: string) {\n\t\tvoid this.sendMessage({ type: \"unmount\", path });\n\t\tthis.#activeViews.delete(path);\n\t}\n\n\tpublic disconnect() {\n\t\tthis.#socket?.disconnect();\n\t\tthis.#socket = null;\n\t\tthis.#messageQueue = [];\n\t\tthis.#connectionListeners.clear();\n\t\tthis.#activeViews.clear();\n\t\tthis.#serverErrors.clear();\n\t\tthis.#serverErrorListeners.clear();\n\t\tfor (const { bridge } of this.#channels.values()) {\n\t\t\tbridge.dispose(new PulseChannelResetError(\"Client disconnected\"));\n\t\t}\n\t\tthis.#channels.clear();\n\t}\n\n\t#handleServerMessage(message: ServerMessage) {\n\t\t// console.log(\"[PulseClient] Received message:\", message);\n\t\tswitch (message.type) {\n\t\t\tcase \"vdom_init\": {\n\t\t\t\tconst route = this.#activeViews.get(message.path);\n\t\t\t\t// Ignore messages for paths that are not mounted\n\t\t\t\tif (!route) return;\n\t\t\t\tif (route) {\n\t\t\t\t\troute.onInit(message.vdom, message.callbacks, message.render_props, message.css_refs);\n\t\t\t\t}\n\t\t\t\t// Clear any prior error for this path on successful init\n\t\t\t\tif (this.#serverErrors.has(message.path)) {\n\t\t\t\t\tthis.#serverErrors.delete(message.path);\n\t\t\t\t\tthis.notifyServerError(message.path, null);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase \"vdom_update\": {\n\t\t\t\tconst route = this.#activeViews.get(message.path);\n\t\t\t\tif (!route) return; // Not an active path; discard\n\t\t\t\troute.onUpdate(message.ops);\n\t\t\t\t// Clear any prior error for this path on successful update\n\t\t\t\tif (this.#serverErrors.has(message.path)) {\n\t\t\t\t\tthis.#serverErrors.delete(message.path);\n\t\t\t\t\tthis.notifyServerError(message.path, null);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase \"server_error\": {\n\t\t\t\tif (!this.#activeViews.has(message.path)) return; // discard for inactive paths\n\t\t\t\tthis.#serverErrors.set(message.path, message.error);\n\t\t\t\tthis.notifyServerError(message.path, message.error);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase \"api_call\": {\n\t\t\t\tvoid this.#performApiCall(message);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase \"navigate_to\": {\n\t\t\t\t// `navigate_to` is navigational; allow regardless of activeViews membership\n\t\t\t\tconst replace = !!message.replace;\n\t\t\t\tlet dest = message.path || \"\";\n\t\t\t\t// Normalize protocol-relative URLs to absolute\n\t\t\t\tif (dest.startsWith(\"//\")) dest = `${window.location.protocol}${dest}`;\n\t\t\t\tconst hasScheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(dest);\n\t\t\t\tif (hasScheme) {\n\t\t\t\t\tif (dest.startsWith(\"http://\") || dest.startsWith(\"https://\")) {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst url = new URL(dest);\n\t\t\t\t\t\t\tif (url.origin === window.location.origin) {\n\t\t\t\t\t\t\t\tconst internal = `${url.pathname}${url.search}${url.hash}`;\n\t\t\t\t\t\t\t\tthis.#frameworkNavigate(internal, { replace });\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tif (replace) window.location.replace(dest);\n\t\t\t\t\t\t\t\telse window.location.assign(dest);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\tif (replace) window.location.replace(dest);\n\t\t\t\t\t\t\telse window.location.assign(dest);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// mailto:, tel:, data:, etc.\n\t\t\t\t\t\tif (replace) window.location.replace(dest);\n\t\t\t\t\t\telse window.location.assign(dest);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t// Relative or root-relative path → SPA navigate\n\t\t\t\t\tthis.#frameworkNavigate(dest, { replace });\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase \"channel_message\": {\n\t\t\t\tthis.#routeChannelMessage(message);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tdefault: {\n\t\t\t\tconsole.error(\"Unexpected message:\", message);\n\t\t\t}\n\t\t}\n\t}\n\n\tasync #performApiCall(msg: ServerApiCallMessage) {\n\t\ttry {\n\t\t\tconst res = await fetch(msg.url, {\n\t\t\t\tmethod: msg.method || \"GET\",\n\t\t\t\theaders: {\n\t\t\t\t\t...(msg.headers || {}),\n\t\t\t\t\t...(msg.body != null && !(\"content-type\" in (msg.headers || {}))\n\t\t\t\t\t\t? { \"content-type\": \"application/json\" }\n\t\t\t\t\t\t: {}),\n\t\t\t\t},\n\t\t\t\tbody:\n\t\t\t\t\tmsg.body != null\n\t\t\t\t\t\t? typeof msg.body === \"string\"\n\t\t\t\t\t\t\t? msg.body\n\t\t\t\t\t\t\t: JSON.stringify(msg.body)\n\t\t\t\t\t\t: undefined,\n\t\t\t\tcredentials: msg.credentials || \"include\",\n\t\t\t});\n\t\t\tconst headersObj: Record<string, string> = {};\n\t\t\tres.headers.forEach((v, k) => {\n\t\t\t\theadersObj[k] = v;\n\t\t\t});\n\t\t\tlet body: any = null;\n\t\t\tconst ct = res.headers.get(\"content-type\") || \"\";\n\t\t\tif (ct.includes(\"application/json\")) {\n\t\t\t\tbody = await res.json().catch(() => null);\n\t\t\t} else {\n\t\t\t\tbody = await res.text().catch(() => null);\n\t\t\t}\n\t\t\tconst reply: ClientApiResultMessage = {\n\t\t\t\ttype: \"api_result\",\n\t\t\t\tid: msg.id,\n\t\t\t\tok: res.ok,\n\t\t\t\tstatus: res.status,\n\t\t\t\theaders: headersObj,\n\t\t\t\tbody,\n\t\t\t};\n\t\t\tthis.sendMessage(reply);\n\t\t} catch (err) {\n\t\t\tconst reply: ClientApiResultMessage = {\n\t\t\t\ttype: \"api_result\",\n\t\t\t\tid: msg.id,\n\t\t\t\tok: false,\n\t\t\t\tstatus: 0,\n\t\t\t\theaders: {},\n\t\t\t\tbody: { error: String(err) },\n\t\t\t};\n\t\t\tthis.sendMessage(reply);\n\t\t}\n\t}\n\n\tpublic invokeCallback(path: string, callback: string, args: any[]) {\n\t\tthis.sendMessage({\n\t\t\ttype: \"callback\",\n\t\t\tpath,\n\t\t\tcallback,\n\t\t\targs: args.map(extractEvent),\n\t\t});\n\t}\n\n\tpublic acquireChannel(id: string): ChannelBridge {\n\t\tconst entry = this.#ensureChannelEntry(id);\n\t\tentry.refCount += 1;\n\t\treturn entry.bridge;\n\t}\n\n\tpublic releaseChannel(id: string): void {\n\t\tconst entry = this.#channels.get(id);\n\t\tif (!entry) {\n\t\t\treturn;\n\t\t}\n\t\tentry.refCount = Math.max(0, entry.refCount - 1);\n\t\tif (entry.refCount === 0) {\n\t\t\tentry.bridge.dispose(new PulseChannelResetError(\"Channel released\"));\n\t\t\tthis.#channels.delete(id);\n\t\t}\n\t}\n\n\t#ensureChannelEntry(id: string): {\n\t\tbridge: ChannelBridge;\n\t\trefCount: number;\n\t} {\n\t\tlet entry = this.#channels.get(id);\n\t\tif (!entry) {\n\t\t\tentry = {\n\t\t\t\tbridge: createChannelBridge(this, id),\n\t\t\t\trefCount: 0,\n\t\t\t};\n\t\t\tthis.#channels.set(id, entry);\n\t\t}\n\t\treturn entry;\n\t}\n\n\t#routeChannelMessage(message: ServerChannelMessage): void {\n\t\tconst entry = this.#ensureChannelEntry(message.channel);\n\t\tconst closed = entry.bridge.handleServerMessage(message);\n\t\tif (closed && entry.refCount === 0) {\n\t\t\tthis.#channels.delete(message.channel);\n\t\t}\n\t}\n\n\t#handleTransportDisconnect(): void {\n\t\tfor (const entry of this.#channels.values()) {\n\t\t\tentry.bridge.handleDisconnect(new PulseChannelResetError(\"Connection lost\"));\n\t\t}\n\t}\n}\n",
    "type Simplify<T> = { [K in keyof T]: T[K] } & {};\n\nexport function createExtractor<T extends object>() {\n\tfunction _createExtractor<\n\t\tconst K extends readonly (keyof T)[],\n\t\tC extends Partial<Record<K[number] | string, (src: T) => any>>,\n\t>(keys: K, computed?: C) {\n\t\treturn (\n\t\t\tsrc: T,\n\t\t): Simplify<\n\t\t\tPick<T, K[number]> & {\n\t\t\t\t[P in keyof C]-?: C[P] extends (...args: any) => infer R ? R : never;\n\t\t\t}\n\t\t> => {\n\t\t\tconst out: any = {};\n\t\t\tfor (const key of keys) {\n\t\t\t\tout[key as string] = (src as any)[key as string];\n\t\t\t}\n\t\t\tif (computed) {\n\t\t\t\tfor (const key in computed) {\n\t\t\t\t\tconst fn = computed[key]!;\n\t\t\t\t\tout[key] = fn(src);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn out;\n\t\t};\n\t}\n\treturn _createExtractor;\n}\n",
    "import { createExtractor } from \"./extractor\";\n\n// Base extractors (camelCase) similar to events.ts style\nconst lowerTagName = (e: Element) => e.tagName.toLowerCase();\n\nconst ELEMENT_KEYS = [\n\t\"id\",\n\t\"className\",\n\t\"tagName\",\n\t\"localName\",\n\t\"clientHeight\",\n\t\"clientLeft\",\n\t\"clientTop\",\n\t\"clientWidth\",\n\t\"scrollHeight\",\n\t\"scrollLeft\",\n\t\"scrollTop\",\n\t\"scrollWidth\",\n\t\"slot\",\n] as const satisfies readonly (keyof Element)[];\n\nconst HTML_OR_SVG_KEYS = [\n\t\"autofocus\",\n\t\"tabIndex\",\n\t\"nonce\",\n] as const satisfies readonly (keyof HTMLOrSVGElement)[];\n\nconst HTML_ELEMENT_BASE_KEYS = [\n\t\"accessKey\",\n\t\"accessKeyLabel\",\n\t\"autocapitalize\",\n\t\"dir\",\n\t\"draggable\",\n\t\"hidden\",\n\t\"inert\",\n\t\"lang\",\n\t\"offsetHeight\",\n\t\"offsetLeft\",\n\t\"offsetTop\",\n\t\"offsetWidth\",\n\t\"popover\",\n\t\"spellcheck\",\n\t\"title\",\n\t\"translate\",\n\t\"writingSuggestions\",\n\t\"contentEditable\",\n\t\"enterKeyHint\",\n\t\"isContentEditable\",\n\t\"inputMode\",\n] as const satisfies readonly (keyof HTMLElement)[];\n\nconst extractElement = createExtractor<Element>()(ELEMENT_KEYS, {\n\ttagName: lowerTagName,\n});\n\nconst extractHTMLOrSVGElement = createExtractor<HTMLOrSVGElement>()(HTML_OR_SVG_KEYS);\n\nconst extractHTMLElementBaseOnly = createExtractor<HTMLElement>()(HTML_ELEMENT_BASE_KEYS);\n\nfunction extractHTMLElementBase(elt: HTMLElement) {\n\treturn {\n\t\t...extractElement(elt),\n\t\t...extractHTMLOrSVGElement(elt as HTMLOrSVGElement),\n\t\t...extractHTMLElementBaseOnly(elt),\n\t};\n}\n\n// Helper to compose per-element extractors with the shared base\nfunction withBase<T extends HTMLElement>(\n\tkeys: readonly (keyof T)[],\n\tcomputed?: Partial<Record<string, (src: T) => any>>,\n) {\n\tconst only = createExtractor<T>()(keys, computed as any);\n\treturn (elt: T) => ({ ...extractHTMLElementBase(elt), ...only(elt) });\n}\n\nconst HTML_ANCHOR_KEYS = [\n\t\"hash\",\n\t\"host\",\n\t\"hostname\",\n\t\"href\",\n\t\"origin\",\n\t\"password\",\n\t\"pathname\",\n\t\"port\",\n\t\"protocol\",\n\t\"search\",\n\t\"target\",\n\t\"download\",\n\t\"rel\",\n\t\"hreflang\",\n\t\"type\",\n\t\"username\",\n\t\"ping\",\n\t\"referrerPolicy\",\n\t\"text\",\n] as const satisfies readonly (keyof HTMLAnchorElement)[];\nconst anchorExtractor = withBase<HTMLAnchorElement>(HTML_ANCHOR_KEYS);\n\nconst HTML_AREA_KEYS = [\n\t\"alt\",\n\t\"coords\",\n\t\"download\",\n\t\"hash\",\n\t\"host\",\n\t\"hostname\",\n\t\"href\",\n\t\"origin\",\n\t\"password\",\n\t\"pathname\",\n\t\"port\",\n\t\"protocol\",\n\t\"rel\",\n\t\"search\",\n\t\"shape\",\n\t\"target\",\n\t\"username\",\n\t\"ping\",\n\t\"referrerPolicy\",\n] as const satisfies readonly (keyof HTMLAreaElement)[];\nconst areaExtractor = withBase<HTMLAreaElement>(HTML_AREA_KEYS);\n\nconst HTML_MEDIA_KEYS = [\n\t\"autoplay\",\n\t\"controls\",\n\t\"crossOrigin\",\n\t\"currentSrc\",\n\t\"currentTime\",\n\t\"defaultMuted\",\n\t\"defaultPlaybackRate\",\n\t\"duration\",\n\t\"ended\",\n\t\"loop\",\n\t\"muted\",\n\t\"networkState\",\n\t\"paused\",\n\t\"playbackRate\",\n\t\"preload\",\n\t\"readyState\",\n\t\"seeking\",\n\t\"src\",\n\t\"volume\",\n\t\"preservesPitch\",\n] as const satisfies readonly (keyof HTMLMediaElement)[];\nconst mediaExtractor = withBase<HTMLMediaElement>(HTML_MEDIA_KEYS);\n\nconst audioExtractor = (elt: HTMLAudioElement) => mediaExtractor(elt);\n\nconst HTML_BUTTON_KEYS = [\n\t\"disabled\",\n\t\"name\",\n\t\"type\",\n\t\"value\",\n\t\"formAction\",\n\t\"formEnctype\",\n\t\"formMethod\",\n\t\"formNoValidate\",\n\t\"formTarget\",\n\t\"popoverTargetAction\",\n] as const satisfies readonly (keyof HTMLButtonElement)[];\nconst buttonExtractor = withBase<HTMLButtonElement>(HTML_BUTTON_KEYS);\n\nconst HTML_DATA_KEYS = [\"value\"] as const satisfies readonly (keyof HTMLDataElement)[];\nconst dataExtractor = withBase<HTMLDataElement>(HTML_DATA_KEYS);\n\nconst HTML_EMBED_KEYS = [\n\t\"height\",\n\t\"src\",\n\t\"type\",\n\t\"width\",\n\t\"align\",\n\t\"name\",\n] as const satisfies readonly (keyof HTMLEmbedElement)[];\nconst embedExtractor = withBase<HTMLEmbedElement>(HTML_EMBED_KEYS);\n\nconst HTML_FIELDSET_KEYS = [\n\t\"disabled\",\n\t\"name\",\n\t\"type\",\n\t\"validationMessage\",\n\t\"willValidate\",\n] as const satisfies readonly (keyof HTMLFieldSetElement)[];\nconst fieldsetExtractor = withBase<HTMLFieldSetElement>(HTML_FIELDSET_KEYS);\n\nconst HTML_FORM_KEYS = [\n\t\"acceptCharset\",\n\t\"action\",\n\t\"autocomplete\",\n\t\"encoding\",\n\t\"enctype\",\n\t\"length\",\n\t\"method\",\n\t\"name\",\n\t\"noValidate\",\n\t\"target\",\n\t\"rel\",\n] as const satisfies readonly (keyof HTMLFormElement)[];\nconst formExtractor = withBase<HTMLFormElement>(HTML_FORM_KEYS);\n\nconst HTML_IFRAME_KEYS = [\n\t\"allow\",\n\t\"allowFullscreen\",\n\t\"height\",\n\t\"name\",\n\t\"referrerPolicy\",\n\t\"src\",\n\t\"srcdoc\",\n\t\"width\",\n\t\"align\",\n\t\"frameBorder\",\n\t\"longDesc\",\n\t\"marginHeight\",\n\t\"marginWidth\",\n\t\"scrolling\",\n\t\"sandbox\",\n] as const satisfies readonly (keyof HTMLIFrameElement)[];\nconst iframeExtractor = withBase<HTMLIFrameElement>(HTML_IFRAME_KEYS);\n\nconst HTML_IMAGE_KEYS = [\n\t\"alt\",\n\t\"crossOrigin\",\n\t\"decoding\",\n\t\"height\",\n\t\"isMap\",\n\t\"loading\",\n\t\"naturalHeight\",\n\t\"naturalWidth\",\n\t\"referrerPolicy\",\n\t\"sizes\",\n\t\"src\",\n\t\"srcset\",\n\t\"useMap\",\n\t\"width\",\n\t\"align\",\n\t\"border\",\n\t\"complete\",\n\t\"hspace\",\n\t\"longDesc\",\n\t\"lowsrc\",\n\t\"name\",\n\t\"vspace\",\n\t\"x\",\n\t\"y\",\n\t\"fetchPriority\",\n] as const satisfies readonly (keyof HTMLImageElement)[];\nconst imageExtractor = withBase<HTMLImageElement>(HTML_IMAGE_KEYS);\n\nconst HTML_INPUT_KEYS = [\n\t\"accept\",\n\t\"alt\",\n\t\"autocomplete\",\n\t\"checked\",\n\t\"defaultChecked\",\n\t\"defaultValue\",\n\t\"dirName\",\n\t\"disabled\",\n\t\"height\",\n\t\"indeterminate\",\n\t\"max\",\n\t\"maxLength\",\n\t\"min\",\n\t\"minLength\",\n\t\"multiple\",\n\t\"name\",\n\t\"pattern\",\n\t\"placeholder\",\n\t\"readOnly\",\n\t\"required\",\n\t\"selectionDirection\",\n\t\"selectionEnd\",\n\t\"selectionStart\",\n\t\"size\",\n\t\"src\",\n\t\"step\",\n\t\"type\",\n\t\"value\",\n\t\"valueAsNumber\",\n\t\"width\",\n\t\"align\",\n\t\"capture\",\n\t\"formAction\",\n\t\"formEnctype\",\n\t\"formMethod\",\n\t\"formNoValidate\",\n\t\"formTarget\",\n\t\"useMap\",\n\t\"validationMessage\",\n\t\"willValidate\",\n\t\"popoverTargetAction\",\n] as const satisfies readonly (keyof HTMLInputElement)[];\nconst inputExtractor = withBase<HTMLInputElement>(HTML_INPUT_KEYS);\n\nconst HTML_LABEL_KEYS = [\"htmlFor\"] as const satisfies readonly (keyof HTMLLabelElement)[];\nconst labelExtractor = withBase<HTMLLabelElement>(HTML_LABEL_KEYS);\n\nconst HTML_LI_KEYS = [\"value\", \"type\"] as const satisfies readonly (keyof HTMLLIElement)[];\nconst liExtractor = withBase<HTMLLIElement>(HTML_LI_KEYS);\n\nconst HTML_LINK_KEYS = [\n\t\"as\",\n\t\"crossOrigin\",\n\t\"disabled\",\n\t\"fetchPriority\",\n\t\"href\",\n\t\"hreflang\",\n\t\"imageSizes\",\n\t\"imageSrcset\",\n\t\"integrity\",\n\t\"media\",\n\t\"referrerPolicy\",\n\t\"rel\",\n\t\"type\",\n\t\"charset\",\n\t\"rev\",\n\t\"target\",\n\t\"sizes\",\n] as const satisfies readonly (keyof HTMLLinkElement)[];\nconst linkExtractor = withBase<HTMLLinkElement>(HTML_LINK_KEYS);\n\nconst HTML_MAP_KEYS = [\"name\"] as const satisfies readonly (keyof HTMLMapElement)[];\nconst mapExtractor = withBase<HTMLMapElement>(HTML_MAP_KEYS);\n\nconst HTML_METER_KEYS = [\n\t\"high\",\n\t\"low\",\n\t\"max\",\n\t\"min\",\n\t\"optimum\",\n\t\"value\",\n] as const satisfies readonly (keyof HTMLMeterElement)[];\nconst meterExtractor = withBase<HTMLMeterElement>(HTML_METER_KEYS);\n\nconst HTML_MOD_KEYS = [\"cite\", \"dateTime\"] as const satisfies readonly (keyof HTMLModElement)[];\nconst modExtractor = withBase<HTMLModElement>(HTML_MOD_KEYS);\n\nconst HTML_OL_KEYS = [\n\t\"reversed\",\n\t\"start\",\n\t\"type\",\n\t\"compact\",\n] as const satisfies readonly (keyof HTMLOListElement)[];\nconst olistExtractor = withBase<HTMLOListElement>(HTML_OL_KEYS);\n\nconst HTML_OBJECT_KEYS = [\n\t\"data\",\n\t\"height\",\n\t\"name\",\n\t\"type\",\n\t\"useMap\",\n\t\"width\",\n\t\"validationMessage\",\n\t\"willValidate\",\n\t\"align\",\n\t\"archive\",\n\t\"border\",\n\t\"code\",\n\t\"codeBase\",\n\t\"codeType\",\n\t\"declare\",\n\t\"hspace\",\n\t\"standby\",\n\t\"vspace\",\n] as const satisfies readonly (keyof HTMLObjectElement)[];\nconst objectExtractor = withBase<HTMLObjectElement>(HTML_OBJECT_KEYS);\n\nconst HTML_OPTGROUP_KEYS = [\n\t\"disabled\",\n\t\"label\",\n] as const satisfies readonly (keyof HTMLOptGroupElement)[];\nconst optgroupExtractor = withBase<HTMLOptGroupElement>(HTML_OPTGROUP_KEYS);\n\nconst HTML_OPTION_KEYS = [\n\t\"defaultSelected\",\n\t\"disabled\",\n\t\"index\",\n\t\"label\",\n\t\"selected\",\n\t\"text\",\n\t\"value\",\n] as const satisfies readonly (keyof HTMLOptionElement)[];\nconst optionExtractor = withBase<HTMLOptionElement>(HTML_OPTION_KEYS);\n\nconst HTML_OUTPUT_KEYS = [\n\t\"defaultValue\",\n\t\"name\",\n\t\"type\",\n\t\"value\",\n\t\"htmlFor\",\n\t\"validationMessage\",\n\t\"willValidate\",\n] as const satisfies readonly (keyof HTMLOutputElement)[];\nconst outputExtractor = withBase<HTMLOutputElement>(HTML_OUTPUT_KEYS);\n\nconst HTML_PROGRESS_KEYS = [\n\t\"max\",\n\t\"position\",\n\t\"value\",\n] as const satisfies readonly (keyof HTMLProgressElement)[];\nconst progressExtractor = withBase<HTMLProgressElement>(HTML_PROGRESS_KEYS);\n\nconst HTML_QUOTE_KEYS = [\"cite\"] as const satisfies readonly (keyof HTMLQuoteElement)[];\nconst quoteExtractor = withBase<HTMLQuoteElement>(HTML_QUOTE_KEYS);\n\nconst citeExtractor = (elt: HTMLElement) => extractHTMLElementBase(elt);\n\nconst HTML_SCRIPT_KEYS = [\n\t\"async\",\n\t\"crossOrigin\",\n\t\"defer\",\n\t\"fetchPriority\",\n\t\"integrity\",\n\t\"noModule\",\n\t\"referrerPolicy\",\n\t\"src\",\n\t\"text\",\n\t\"type\",\n\t\"charset\",\n] as const satisfies readonly (keyof HTMLScriptElement)[];\nconst extractHTMLScriptOnly = createExtractor<HTMLScriptElement>()(HTML_SCRIPT_KEYS, {\n\tevent: (s) => (s as any).event,\n\thtmlFor: (s) => (s as any).htmlFor,\n});\nconst scriptExtractor = (elt: HTMLScriptElement) => ({\n\t...extractHTMLElementBase(elt),\n\t...extractHTMLScriptOnly(elt),\n});\n\nconst HTML_SELECT_KEYS = [\n\t\"autocomplete\",\n\t\"disabled\",\n\t\"length\",\n\t\"multiple\",\n\t\"name\",\n\t\"required\",\n\t\"selectedIndex\",\n\t\"size\",\n\t\"type\",\n\t\"value\",\n\t\"validationMessage\",\n\t\"willValidate\",\n] as const satisfies readonly (keyof HTMLSelectElement)[];\nconst selectExtractor = withBase<HTMLSelectElement>(HTML_SELECT_KEYS);\n\nconst HTML_SLOT_KEYS = [\"name\"] as const satisfies readonly (keyof HTMLSlotElement)[];\nconst slotExtractor = withBase<HTMLSlotElement>(HTML_SLOT_KEYS);\n\nconst HTML_SOURCE_KEYS = [\n\t\"height\",\n\t\"media\",\n\t\"sizes\",\n\t\"src\",\n\t\"srcset\",\n\t\"type\",\n\t\"width\",\n] as const satisfies readonly (keyof HTMLSourceElement)[];\nconst sourceExtractor = withBase<HTMLSourceElement>(HTML_SOURCE_KEYS);\n\nconst HTML_TABLE_CAPTION_KEYS = [\n\t\"align\",\n] as const satisfies readonly (keyof HTMLTableCaptionElement)[];\nconst tableCaptionExtractor = withBase<HTMLTableCaptionElement>(HTML_TABLE_CAPTION_KEYS);\n\nconst HTML_TABLE_CELL_KEYS = [\n\t\"abbr\",\n\t\"cellIndex\",\n\t\"colSpan\",\n\t\"headers\",\n\t\"rowSpan\",\n\t\"scope\",\n\t\"align\",\n\t\"axis\",\n\t\"bgColor\",\n\t\"ch\",\n\t\"chOff\",\n\t\"height\",\n\t\"noWrap\",\n\t\"vAlign\",\n\t\"width\",\n] as const satisfies readonly (keyof HTMLTableCellElement)[];\nconst tableCellExtractor = withBase<HTMLTableCellElement>(HTML_TABLE_CELL_KEYS);\n\nconst HTML_TABLE_COL_KEYS = [\n\t\"span\",\n\t\"align\",\n\t\"ch\",\n\t\"chOff\",\n\t\"vAlign\",\n\t\"width\",\n] as const satisfies readonly (keyof HTMLTableColElement)[];\nconst tableColExtractor = withBase<HTMLTableColElement>(HTML_TABLE_COL_KEYS);\n\nconst HTML_TABLE_KEYS = [\n\t\"align\",\n\t\"bgColor\",\n\t\"border\",\n\t\"cellPadding\",\n\t\"cellSpacing\",\n\t\"frame\",\n\t\"rules\",\n\t\"summary\",\n\t\"width\",\n] as const satisfies readonly (keyof HTMLTableElement)[];\nconst tableExtractor = withBase<HTMLTableElement>(HTML_TABLE_KEYS);\n\nconst HTML_TR_KEYS = [\n\t\"rowIndex\",\n\t\"sectionRowIndex\",\n\t\"align\",\n\t\"bgColor\",\n\t\"ch\",\n\t\"chOff\",\n\t\"vAlign\",\n] as const satisfies readonly (keyof HTMLTableRowElement)[];\nconst tableRowExtractor = withBase<HTMLTableRowElement>(HTML_TR_KEYS);\n\nconst HTML_TSECTION_KEYS = [\n\t\"align\",\n\t\"ch\",\n\t\"chOff\",\n\t\"vAlign\",\n] as const satisfies readonly (keyof HTMLTableSectionElement)[];\nconst tableSectionExtractor = withBase<HTMLTableSectionElement>(HTML_TSECTION_KEYS);\n\nconst templateExtractor = (elt: HTMLTemplateElement) => extractHTMLElementBase(elt);\n\nconst HTML_TEXTAREA_KEYS = [\n\t\"autocomplete\",\n\t\"cols\",\n\t\"defaultValue\",\n\t\"dirName\",\n\t\"disabled\",\n\t\"maxLength\",\n\t\"minLength\",\n\t\"name\",\n\t\"placeholder\",\n\t\"readOnly\",\n\t\"required\",\n\t\"rows\",\n\t\"selectionDirection\",\n\t\"selectionEnd\",\n\t\"selectionStart\",\n\t\"value\",\n\t\"wrap\",\n\t\"textLength\",\n\t\"validationMessage\",\n\t\"willValidate\",\n] as const satisfies readonly (keyof HTMLTextAreaElement)[];\nconst textareaExtractor = withBase<HTMLTextAreaElement>(HTML_TEXTAREA_KEYS);\n\nconst HTML_TIME_KEYS = [\"dateTime\"] as const satisfies readonly (keyof HTMLTimeElement)[];\nconst timeExtractor = withBase<HTMLTimeElement>(HTML_TIME_KEYS);\n\nconst HTML_TRACK_KEYS = [\n\t\"default\",\n\t\"kind\",\n\t\"label\",\n\t\"readyState\",\n\t\"src\",\n\t\"srclang\",\n] as const satisfies readonly (keyof HTMLTrackElement)[];\nconst trackExtractor = withBase<HTMLTrackElement>(HTML_TRACK_KEYS);\n\nconst HTML_VIDEO_KEYS = [\n\t\"height\",\n\t\"poster\",\n\t\"videoHeight\",\n\t\"videoWidth\",\n\t\"width\",\n\t\"playsInline\",\n] as const satisfies readonly (keyof HTMLVideoElement)[];\nconst extractHTMLVideoOnly = createExtractor<HTMLVideoElement>()(HTML_VIDEO_KEYS);\nconst videoExtractor = (elt: HTMLVideoElement) => ({\n\t...mediaExtractor(elt),\n\t...extractHTMLVideoOnly(elt),\n});\n\nconst HTML_BR_KEYS = [\"clear\"] as const satisfies readonly (keyof HTMLBRElement)[];\nconst brExtractor = withBase<HTMLBRElement>(HTML_BR_KEYS);\n\nconst HTML_BASE_KEYS = [\"href\", \"target\"] as const satisfies readonly (keyof HTMLBaseElement)[];\nconst baseExtractor = withBase<HTMLBaseElement>(HTML_BASE_KEYS);\n\nconst HTML_BODY_KEYS = [\n\t\"aLink\",\n\t\"background\",\n\t\"bgColor\",\n\t\"link\",\n\t\"text\",\n\t\"vLink\",\n] as const satisfies readonly (keyof HTMLBodyElement)[];\nconst bodyExtractor = withBase<HTMLBodyElement>(HTML_BODY_KEYS);\n\nconst HTML_DLIST_KEYS = [\"compact\"] as const satisfies readonly (keyof HTMLDListElement)[];\nconst dlistExtractor = withBase<HTMLDListElement>(HTML_DLIST_KEYS);\n\nconst HTML_DETAILS_KEYS = [\"open\"] as const satisfies readonly (keyof HTMLDetailsElement)[];\nconst detailsExtractor = withBase<HTMLDetailsElement>(HTML_DETAILS_KEYS);\n\nconst HTML_DIALOG_KEYS = [\n\t\"open\",\n\t\"returnValue\",\n] as const satisfies readonly (keyof HTMLDialogElement)[];\nconst dialogExtractor = withBase<HTMLDialogElement>(HTML_DIALOG_KEYS);\n\nconst HTML_DIV_KEYS = [\"align\"] as const satisfies readonly (keyof HTMLDivElement)[];\nconst divExtractor = withBase<HTMLDivElement>(HTML_DIV_KEYS);\n\nconst headExtractor = (elt: HTMLHeadElement) => extractHTMLElementBase(elt);\n\nconst HTML_HEADING_KEYS = [\"align\"] as const satisfies readonly (keyof HTMLHeadingElement)[];\nconst headingExtractor = withBase<HTMLHeadingElement>(HTML_HEADING_KEYS);\n\nconst HTML_HR_KEYS = [\n\t\"align\",\n\t\"color\",\n\t\"noShade\",\n\t\"size\",\n\t\"width\",\n] as const satisfies readonly (keyof HTMLHRElement)[];\nconst hrExtractor = withBase<HTMLHRElement>(HTML_HR_KEYS);\n\nconst HTML_HTML_KEYS = [\"version\"] as const satisfies readonly (keyof HTMLHtmlElement)[];\nconst htmlExtractor = withBase<HTMLHtmlElement>(HTML_HTML_KEYS);\n\nconst menuExtractor = (elt: HTMLMenuElement) => extractHTMLElementBase(elt);\n\nconst HTML_META_KEYS = [\n\t\"content\",\n\t\"httpEquiv\",\n\t\"name\",\n\t\"scheme\",\n] as const satisfies readonly (keyof HTMLMetaElement)[];\nconst metaExtractor = withBase<HTMLMetaElement>(HTML_META_KEYS);\n\nconst HTML_P_KEYS = [\"align\"] as const satisfies readonly (keyof HTMLParagraphElement)[];\nconst paragraphExtractor = withBase<HTMLParagraphElement>(HTML_P_KEYS);\n\nconst pictureExtractor = (elt: HTMLPictureElement) => extractHTMLElementBase(elt);\n\nconst HTML_PRE_KEYS = [\"width\"] as const satisfies readonly (keyof HTMLPreElement)[];\nconst preExtractor = withBase<HTMLPreElement>(HTML_PRE_KEYS);\n\nconst spanExtractor = (elt: HTMLSpanElement) => extractHTMLElementBase(elt);\n\nconst HTML_STYLE_KEYS = [\n\t\"media\",\n\t\"type\",\n\t\"disabled\",\n] as const satisfies readonly (keyof HTMLStyleElement)[];\nconst styleExtractor = withBase<HTMLStyleElement>(HTML_STYLE_KEYS);\n\nconst HTML_TITLE_KEYS = [\"text\"] as const satisfies readonly (keyof HTMLTitleElement)[];\nconst titleExtractor = withBase<HTMLTitleElement>(HTML_TITLE_KEYS);\n\nconst HTML_UL_KEYS = [\"compact\", \"type\"] as const satisfies readonly (keyof HTMLUListElement)[];\nconst ulistExtractor = withBase<HTMLUListElement>(HTML_UL_KEYS);\n\n// Map of tagName -> extractor (concise, like events.ts)\nconst elementExtractors: Record<string, (elt: any) => object> = {\n\tA: anchorExtractor,\n\tAREA: areaExtractor,\n\tAUDIO: audioExtractor,\n\tBASE: baseExtractor,\n\tBLOCKQUOTE: quoteExtractor,\n\tQ: quoteExtractor,\n\tBODY: bodyExtractor,\n\tBR: brExtractor,\n\tBUTTON: buttonExtractor,\n\tCANVAS: extractHTMLElementBase,\n\tCAPTION: tableCaptionExtractor,\n\tCITE: citeExtractor,\n\tCOL: tableColExtractor,\n\tCOLGROUP: tableColExtractor,\n\tDATA: dataExtractor,\n\tDETAILS: detailsExtractor,\n\tDIALOG: dialogExtractor,\n\tDIV: divExtractor,\n\tDL: dlistExtractor,\n\tEMBED: embedExtractor,\n\tFIELDSET: fieldsetExtractor,\n\tFORM: formExtractor,\n\tH1: headingExtractor,\n\tH2: headingExtractor,\n\tH3: headingExtractor,\n\tH4: headingExtractor,\n\tH5: headingExtractor,\n\tH6: headingExtractor,\n\tHEAD: headExtractor,\n\tHR: hrExtractor,\n\tHTML: htmlExtractor,\n\tIFRAME: iframeExtractor,\n\tIMG: imageExtractor,\n\tINPUT: inputExtractor,\n\tLABEL: labelExtractor,\n\tLI: liExtractor,\n\tLINK: linkExtractor,\n\tMAP: mapExtractor,\n\tMENU: menuExtractor,\n\tMETA: metaExtractor,\n\tMETER: meterExtractor,\n\tINS: modExtractor,\n\tDEL: modExtractor,\n\tOBJECT: objectExtractor,\n\tOL: olistExtractor,\n\tOPTGROUP: optgroupExtractor,\n\tOPTION: optionExtractor,\n\tOUTPUT: outputExtractor,\n\tP: paragraphExtractor,\n\tPICTURE: pictureExtractor,\n\tPRE: preExtractor,\n\tPROGRESS: progressExtractor,\n\tSCRIPT: scriptExtractor,\n\tSELECT: selectExtractor,\n\tSLOT: slotExtractor,\n\tSOURCE: sourceExtractor,\n\tSPAN: spanExtractor,\n\tSTYLE: styleExtractor,\n\tTABLE: tableExtractor,\n\tTBODY: tableSectionExtractor,\n\tTHEAD: tableSectionExtractor,\n\tTFOOT: tableSectionExtractor,\n\tTD: tableCellExtractor,\n\tTH: tableCellExtractor,\n\tTEMPLATE: templateExtractor,\n\tTEXTAREA: textareaExtractor,\n\tTIME: timeExtractor,\n\tTITLE: titleExtractor,\n\tTR: tableRowExtractor,\n\tTRACK: trackExtractor,\n\tUL: ulistExtractor,\n\tVIDEO: videoExtractor,\n};\n\nexport function extractHTMLElement(elt: HTMLElement): object {\n\tconst tagName = elt.tagName.toUpperCase();\n\n\tconst extractor = elementExtractors[tagName];\n\tif (extractor) {\n\t\treturn extractor(elt);\n\t}\n\tthrow new Error(`Unexpected HTML element tag: ${elt.tagName} (update .web/custom/serialize.ts)`);\n}\n",
    "/* === IMPORTANT === */\n\nimport { extractHTMLElement } from \"./elements\";\nimport { createExtractor } from \"./extractor\";\n\n// Reusable computed mappers (helps bundlers/minifiers share references)\nconst mapTarget = (e: { target: EventTarget | null }) =>\n\textractHTMLElement(e.target as HTMLElement);\nconst mapRelated = (e: { relatedTarget: EventTarget | null }) =>\n\te.relatedTarget ? extractHTMLElement(e.relatedTarget as HTMLElement) : null;\n\nfunction makeExtractor<K extends readonly any[]>(\n\tkeys: K,\n\tcomputed?: Record<string, (evt: any) => any>,\n) {\n\treturn createExtractor<any>()(\n\t\tkeys as any,\n\t\t{\n\t\t\ttarget: mapTarget,\n\t\t\t...(computed || {}),\n\t\t} as any,\n\t);\n}\n\nconst SYNTHETIC_KEYS = [\n\t\"target\",\n\t\"bubbles\",\n\t\"cancelable\",\n\t\"defaultPrevented\",\n\t\"eventPhase\",\n\t\"isTrusted\",\n\t\"timeStamp\",\n\t\"type\",\n] as const satisfies readonly (keyof React.SyntheticEvent)[];\n\nconst UI_KEYS = [...SYNTHETIC_KEYS, \"detail\"] as const satisfies readonly (keyof React.UIEvent)[];\n\nconst MOUSE_KEYS = [\n\t...UI_KEYS,\n\t\"altKey\",\n\t\"button\",\n\t\"buttons\",\n\t\"clientX\",\n\t\"clientY\",\n\t\"ctrlKey\",\n\t\"metaKey\",\n\t\"movementX\",\n\t\"movementY\",\n\t\"pageX\",\n\t\"pageY\",\n\t\"screenX\",\n\t\"screenY\",\n\t\"shiftKey\",\n] as const satisfies readonly (keyof React.MouseEvent)[];\n\nconst POINTER_KEYS = [\n\t...MOUSE_KEYS,\n\t\"pointerId\",\n\t\"pressure\",\n\t\"tangentialPressure\",\n\t\"tiltX\",\n\t\"tiltY\",\n\t\"twist\",\n\t\"width\",\n\t\"height\",\n\t\"pointerType\",\n\t\"isPrimary\",\n] as const satisfies readonly (keyof React.PointerEvent)[];\n\nconst syntheticExtractor = makeExtractor(SYNTHETIC_KEYS);\n\nconst uiExtractor = makeExtractor(UI_KEYS);\n\nconst mouseExtractor = makeExtractor(MOUSE_KEYS, { relatedTarget: mapRelated });\n\nconst clipboardExtractor = makeExtractor(SYNTHETIC_KEYS, {\n\tclipboardData: (e) => extractDataTransfer(e.clipboardData),\n});\n\nconst compositionExtractor = makeExtractor([...SYNTHETIC_KEYS, \"data\"] as const);\n\nconst dragExtractor = makeExtractor(MOUSE_KEYS, {\n\trelatedTarget: mapRelated,\n\tdataTransfer: (e) => extractDataTransfer(e.dataTransfer),\n});\n\nconst pointerExtractor = makeExtractor(POINTER_KEYS, {\n\trelatedTarget: mapRelated,\n});\n\nconst focusExtractor = makeExtractor(SYNTHETIC_KEYS, {\n\trelatedTarget: mapRelated,\n});\n\nconst formExtractor = makeExtractor(SYNTHETIC_KEYS);\n\nconst invalidExtractor = makeExtractor(SYNTHETIC_KEYS);\n\nconst changeExtractor = makeExtractor(SYNTHETIC_KEYS);\n\nconst keyboardExtractor = makeExtractor([\n\t...UI_KEYS,\n\t\"altKey\",\n\t\"ctrlKey\",\n\t\"code\",\n\t\"key\",\n\t\"locale\",\n\t\"location\",\n\t\"metaKey\",\n\t\"repeat\",\n\t\"shiftKey\",\n] as const);\n\nconst touchExtractor = makeExtractor(\n\t[\n\t\t...UI_KEYS,\n\t\t\"altKey\",\n\t\t\"ctrlKey\",\n\t\t\"metaKey\",\n\t\t\"shiftKey\",\n\t\t\"changedTouches\",\n\t\t\"targetTouches\",\n\t\t\"touches\",\n\t] as const,\n\t{\n\t\tchangedTouches: (e) => mapTouchList(e.changedTouches),\n\t\ttargetTouches: (e) => mapTouchList(e.targetTouches),\n\t\ttouches: (e) => mapTouchList(e.touches),\n\t},\n);\n\nconst wheelExtractor = makeExtractor(\n\t[...MOUSE_KEYS, \"deltaMode\", \"deltaX\", \"deltaY\", \"deltaZ\"] as const,\n\t{\n\t\trelatedTarget: mapRelated,\n\t},\n);\n\nconst animationExtractor = makeExtractor([\n\t...SYNTHETIC_KEYS,\n\t\"animationName\",\n\t\"elapsedTime\",\n\t\"pseudoElement\",\n] as const);\n\nconst toggleExtractor = makeExtractor([...SYNTHETIC_KEYS, \"oldState\", \"newState\"] as const);\n\nconst transitionExtractor = makeExtractor([\n\t...SYNTHETIC_KEYS,\n\t\"elapsedTime\",\n\t\"propertyName\",\n\t\"pseudoElement\",\n] as const);\n\nfunction mapTouchList(list: any): any[] {\n\treturn Array.from(list as ArrayLike<any>).map((touch: any) => ({\n\t\ttarget: extractHTMLElement(touch.target as HTMLElement),\n\t\tidentifier: touch.identifier,\n\t\tscreenX: touch.screenX,\n\t\tscreenY: touch.screenY,\n\t\tclientX: touch.clientX,\n\t\tclientY: touch.clientY,\n\t\tpageX: touch.pageX,\n\t\tpageY: touch.pageY,\n\t}));\n}\n\n// Helper function to extract DataTransfer properties\nfunction extractDataTransfer(dt: DataTransfer | null): object | null {\n\tif (!dt) {\n\t\treturn null;\n\t}\n\tconst items = [];\n\tif (dt.items) {\n\t\tfor (let i = 0; i < dt.items.length; i++) {\n\t\t\tconst item = dt.items[i]!;\n\t\t\titems.push({\n\t\t\t\tkind: item.kind,\n\t\t\t\ttype: item.type,\n\t\t\t});\n\t\t}\n\t}\n\treturn {\n\t\tdrop_effect: dt.dropEffect,\n\t\teffect_allowed: dt.effectAllowed,\n\t\titems: items,\n\t\ttypes: Array.from(dt.types || []),\n\t};\n}\n\nconst eventExtractorMap: { [key: string]: (evt: any) => object } = {};\n\nfunction add(map: Record<string, any>, names: readonly string[], fn: any) {\n\tfor (const n of names) map[n] = fn;\n}\n\nadd(\n\teventExtractorMap,\n\t[\n\t\t\"pointerdown\",\n\t\t\"pointermove\",\n\t\t\"pointerup\",\n\t\t\"pointercancel\",\n\t\t\"gotpointercapture\",\n\t\t\"lostpointercapture\",\n\t\t\"pointerenter\",\n\t\t\"pointerleave\",\n\t\t\"pointerover\",\n\t\t\"pointerout\",\n\t],\n\tpointerExtractor,\n);\n\nadd(\n\teventExtractorMap,\n\t[\n\t\t\"click\",\n\t\t\"contextmenu\",\n\t\t\"dblclick\",\n\t\t\"mousedown\",\n\t\t\"mouseenter\",\n\t\t\"mouseleave\",\n\t\t\"mousemove\",\n\t\t\"mouseout\",\n\t\t\"mouseover\",\n\t\t\"mouseup\",\n\t],\n\tmouseExtractor,\n);\n\nadd(\n\teventExtractorMap,\n\t[\"drag\", \"dragend\", \"dragenter\", \"dragexit\", \"dragleave\", \"dragover\", \"dragstart\", \"drop\"],\n\tdragExtractor,\n);\n\nadd(eventExtractorMap, [\"keydown\", \"keypress\", \"keyup\"], keyboardExtractor);\nadd(eventExtractorMap, [\"focus\", \"blur\"], focusExtractor);\nadd(eventExtractorMap, [\"change\", \"input\"], changeExtractor);\nadd(eventExtractorMap, [\"invalid\"], invalidExtractor);\nadd(eventExtractorMap, [\"reset\", \"submit\"], formExtractor);\nadd(eventExtractorMap, [\"copy\", \"cut\", \"paste\"], clipboardExtractor);\nadd(\n\teventExtractorMap,\n\t[\"compositionend\", \"compositionstart\", \"compositionupdate\"],\n\tcompositionExtractor,\n);\nadd(eventExtractorMap, [\"touchcancel\", \"touchend\", \"touchmove\", \"touchstart\"], touchExtractor);\nadd(eventExtractorMap, [\"scroll\"], uiExtractor);\nadd(eventExtractorMap, [\"wheel\"], wheelExtractor);\nadd(\n\teventExtractorMap,\n\t[\"animationstart\", \"animationend\", \"animationiteration\"],\n\tanimationExtractor,\n);\nadd(eventExtractorMap, [\"transitionend\"], transitionExtractor);\nadd(eventExtractorMap, [\"toggle\"], toggleExtractor);\n\nexport function extractEvent(value: any): any {\n\t// Duck-typing for React's SyntheticEvent.\n\t// We check for properties that are unique to synthetic events.\n\tif (\n\t\tvalue &&\n\t\ttypeof value === \"object\" &&\n\t\t\"nativeEvent\" in value &&\n\t\ttypeof value.isDefaultPrevented === \"function\"\n\t) {\n\t\tconst evt = value as React.SyntheticEvent;\n\t\t// The `type` property is crucial for the lookup.\n\t\tif (typeof evt.type !== \"string\") {\n\t\t\treturn value;\n\t\t}\n\n\t\tconst extractor = eventExtractorMap[evt.type.toLowerCase()];\n\t\tif (extractor) {\n\t\t\treturn extractor(evt);\n\t\t}\n\n\t\t// Fallback for unknown event types: minimal synthetic extractor\n\t\treturn syntheticExtractor(evt);\n\t}\n\n\t// If it's not a duck-typed event, return it as is.\n\treturn value;\n}\n",
    "export type Primitive = number | string | boolean | null | undefined;\nexport type JSON<T> = T | Array<JSON<T>> | { [K: string]: JSON<T> };\nexport type PlainJSON = JSON<Primitive>;\nexport type Serializable = any;\n\nexport type Serialized = [[number[], number[], number[], number[]], PlainJSON];\n\nexport function serialize(data: Serializable): Serialized {\n\tconst seen = new Map<any, number>();\n\tconst refs: number[] = [];\n\tconst dates: number[] = [];\n\tconst sets: number[] = [];\n\tconst maps: number[] = [];\n\n\t// Single global counter - increments once per node visit\n\tlet globalIndex = 0;\n\n\tfunction process(value: Serializable): PlainJSON {\n\t\tif (\n\t\t\tvalue == null ||\n\t\t\ttypeof value === \"number\" ||\n\t\t\ttypeof value === \"string\" ||\n\t\t\ttypeof value === \"boolean\"\n\t\t) {\n\t\t\treturn value;\n\t\t}\n\n\t\tconst idx = globalIndex++;\n\t\tconst prevRef = seen.get(value);\n\t\tif (prevRef !== undefined) {\n\t\t\t// Make sure to push the current index, but use the ref's index as the value!\n\t\t\trefs.push(idx);\n\t\t\treturn prevRef;\n\t\t}\n\n\t\tseen.set(value, idx);\n\n\t\tif (value instanceof Date) {\n\t\t\tdates.push(idx);\n\t\t\treturn value.getTime();\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\tconst length = value.length;\n\t\t\tconst result = new Array(length);\n\t\t\tfor (let i = 0; i < length; i++) {\n\t\t\t\tresult[i] = process(value[i]);\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\n\t\tif (value instanceof Map) {\n\t\t\tmaps.push(idx);\n\t\t\tconst rec: Record<string, any> = {};\n\t\t\tfor (const [key, entry] of value.entries()) {\n\t\t\t\trec[String(key)] = process(entry);\n\t\t\t}\n\t\t\treturn rec;\n\t\t}\n\n\t\tif (value instanceof Set) {\n\t\t\tsets.push(idx);\n\t\t\tconst size = value.size;\n\t\t\tconst result = new Array(size);\n\t\t\tlet i = 0;\n\t\t\tfor (const entry of value) {\n\t\t\t\tresult[i] = process(entry);\n\t\t\t\ti += 1;\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\n\t\tif (typeof value === \"object\") {\n\t\t\tconst rec: Record<string, any> = {};\n\t\t\tconst keys = Object.keys(value);\n\t\t\tfor (let i = 0; i < keys.length; i++) {\n\t\t\t\tconst key = keys[i];\n\t\t\t\trec[key] = process(value[key]);\n\t\t\t}\n\t\t\treturn rec;\n\t\t}\n\n\t\tthrow new Error(`Unsupported value in serialization: ${value}`);\n\t}\n\n\tconst payload = process(data);\n\treturn [[refs, dates, sets, maps], payload];\n}\n\nexport interface DeserializationOptions {\n\tcoerceNullsToUndefined?: boolean;\n}\n\nexport function deserialize<Data extends Serializable = Serializable>(\n\tpayload: Serialized,\n\toptions?: DeserializationOptions,\n): Data {\n\tconst [[refsA, datesA, setsA, mapsA], data] = payload;\n\n\tconst refs = new Set(refsA);\n\tconst dates = new Set(datesA);\n\tconst sets = new Set(setsA);\n\tconst maps = new Set(mapsA);\n\n\tconst objects: Array<any> = [];\n\n\tfunction reconstruct(value: PlainJSON): any {\n\t\tconst idx = objects.length;\n\t\tif (refs.has(idx)) {\n\t\t\t// We increment the counter on refs during serialization. We're never\n\t\t\t// going to use this entry, so we can just push null.\n\t\t\tobjects.push(null);\n\t\t\treturn objects[value as number];\n\t\t}\n\n\t\tif (dates.has(idx)) {\n\t\t\tconst dt = new Date(value as number);\n\t\t\tobjects.push(dt);\n\t\t\treturn dt;\n\t\t}\n\n\t\tif (\n\t\t\tvalue == null ||\n\t\t\ttypeof value === \"number\" ||\n\t\t\ttypeof value === \"string\" ||\n\t\t\ttypeof value === \"boolean\"\n\t\t) {\n\t\t\tif (options?.coerceNullsToUndefined) {\n\t\t\t\treturn value ?? undefined;\n\t\t\t}\n\t\t\treturn value;\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\tif (sets.has(idx)) {\n\t\t\t\tconst result = new Set();\n\t\t\t\tobjects.push(result);\n\t\t\t\tfor (let i = 0; i < value.length; i++) {\n\t\t\t\t\tresult.add(reconstruct(value[i]));\n\t\t\t\t}\n\t\t\t\treturn result;\n\t\t\t}\n\n\t\t\tconst length = value.length;\n\t\t\tconst arr = new Array(length);\n\t\t\tobjects.push(arr);\n\t\t\tfor (let i = 0; i < length; i++) {\n\t\t\t\tarr[i] = reconstruct(value[i]);\n\t\t\t}\n\t\t\treturn arr;\n\t\t}\n\n\t\tif (typeof value === \"object\") {\n\t\t\tif (maps.has(idx)) {\n\t\t\t\tconst result = new Map<string, any>();\n\t\t\t\tobjects.push(result);\n\t\t\t\tconst keys = Object.keys(value);\n\t\t\t\tfor (let i = 0; i < keys.length; i++) {\n\t\t\t\t\tconst key = keys[i];\n\t\t\t\t\tresult.set(key, reconstruct(value[key]));\n\t\t\t\t}\n\t\t\t\treturn result;\n\t\t\t}\n\n\t\t\tconst result: Record<string, any> = {};\n\t\t\tobjects.push(result);\n\t\t\tconst keys = Object.keys(value);\n\t\t\tfor (let i = 0; i < keys.length; i++) {\n\t\t\t\tconst key = keys[i];\n\t\t\t\tresult[key] = reconstruct(value[key]);\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\n\t\tthrow new Error(`Unsupported value in deserialization: ${value}`);\n\t}\n\n\treturn reconstruct(data);\n}\n",
    "import {\n\ttype ComponentType,\n\tcloneElement,\n\tcreateElement,\n\ttype FC,\n\tFragment,\n\tisValidElement,\n\tlazy,\n\ttype PropsWithChildren,\n\ttype ReactElement,\n\ttype ReactNode,\n\tSuspense,\n} from \"react\";\nimport type { PulseSocketIOClient } from \"./client\";\nimport type { ComponentRegistry, PathDelta, VDOM, VDOMNode, VDOMUpdate } from \"./vdom\";\nimport { FRAGMENT_TAG, isElementNode, isMountPointNode, MOUNT_POINT_PREFIX } from \"./vdom\";\n\nexport class VDOMRenderer {\n\t#callbacks: Set<string>;\n\t#callbackCache: Map<string, (...args: any) => void>;\n\t#renderPropKeys: Set<string>;\n\t#cssProps: Set<string>;\n\t#callbackList: string[];\n\t#client: PulseSocketIOClient;\n\t#path: string;\n\t#components: ComponentRegistry;\n\t#cssModules: Record<string, Record<string, string>>;\n\n\tconstructor(\n\t\tclient: PulseSocketIOClient,\n\t\tpath: string,\n\t\tcomponents: ComponentRegistry,\n\t\tcssModules: Record<string, Record<string, string>>,\n\t\tinitialCallbacks: string[] = [],\n\t\tinitialRenderProps: string[] = [],\n\t\tinitialCssRefs: string[] = [],\n\t) {\n\t\tthis.#client = client;\n\t\tthis.#path = path;\n\t\tthis.#components = components;\n\t\tthis.#cssModules = cssModules;\n\t\tthis.#callbacks = new Set(initialCallbacks);\n\t\tthis.#callbackCache = new Map();\n\t\tthis.#renderPropKeys = new Set(initialRenderProps);\n\t\tthis.#cssProps = new Set(initialCssRefs);\n\t\tthis.#callbackList = [...this.#callbacks].sort();\n\t}\n\n\t// Accessors used by update logic to determine which props need rebinding\n\thasCallbackPath(path: string) {\n\t\treturn this.#callbacks.has(path);\n\t}\n\n\thasRenderPropPath(path: string) {\n\t\treturn this.#renderPropKeys.has(path);\n\t}\n\n\thasAnyCallbackUnder(prefix: string): boolean {\n\t\tif (prefix === \"\") return this.#callbackList.length > 0;\n\t\tconst i = this.#lowerBound(this.#callbackList, prefix);\n\t\treturn i < this.#callbackList.length && this.#callbackList[i]!.startsWith(prefix);\n\t}\n\n\tapplyCallbackDelta(delta: PathDelta) {\n\t\t// Only update the internal callback path registry and cache. We rely on\n\t\t// accompanying update_props operations that contain the \"$cb\" placeholder\n\t\t// to trigger prop updates; transformValue will resolve to functions.\n\t\tif (delta.remove) {\n\t\t\tfor (const key of delta.remove) {\n\t\t\t\tthis.#callbacks.delete(key);\n\t\t\t\tthis.#callbackCache.delete(key);\n\t\t\t}\n\t\t}\n\t\tif (delta.add) {\n\t\t\tfor (const key of delta.add) {\n\t\t\t\tthis.#callbacks.add(key);\n\t\t\t}\n\t\t}\n\t\tthis.#callbackList = [...this.#callbacks].sort();\n\t}\n\n\tapplyRenderPropsDelta(delta: PathDelta) {\n\t\tif (delta.remove) {\n\t\t\tfor (const key of delta.remove) {\n\t\t\t\tthis.#renderPropKeys.delete(key);\n\t\t\t}\n\t\t}\n\t\tif (delta.add) {\n\t\t\tfor (const key of delta.add) {\n\t\t\t\tthis.#renderPropKeys.add(key);\n\t\t\t}\n\t\t}\n\t}\n\n\tapplyCssRefsDelta(delta: PathDelta) {\n\t\tif (delta.remove) {\n\t\t\tfor (const prop of delta.remove) {\n\t\t\t\tthis.#cssProps.delete(prop);\n\t\t\t}\n\t\t}\n\t\tif (delta.add) {\n\t\t\tfor (const prop of delta.add) {\n\t\t\t\tthis.#cssProps.add(prop);\n\t\t\t}\n\t\t}\n\t}\n\n\tgetCallback(path: string, prop: string) {\n\t\tconst key = this.#propPath(path, prop);\n\t\tlet fn = this.#callbackCache.get(key);\n\t\tif (!fn) {\n\t\t\tfn = (...args: any[]) => this.#client.invokeCallback(this.#path, key, args);\n\t\t\tthis.#callbackCache.set(key, fn);\n\t\t}\n\t\treturn fn;\n\t}\n\n\trenderNode(node: VDOMNode, currentPath = \"\"): ReactNode {\n\t\t// Handle primitives early\n\t\tif (\n\t\t\tnode == null || // catches both null and undefined\n\t\t\ttypeof node === \"boolean\" ||\n\t\t\ttypeof node === \"number\" ||\n\t\t\ttypeof node === \"string\"\n\t\t) {\n\t\t\treturn node;\n\t\t}\n\n\t\t// Element nodes\n\t\tif (isElementNode(node)) {\n\t\t\tconst { tag, props = {}, children = [] } = node;\n\n\t\t\tconst newProps: Record<string, any> = {};\n\t\t\tfor (const [propName, propValue] of Object.entries(props)) {\n\t\t\t\tnewProps[propName] = this.transformValue(currentPath, propName, propValue);\n\t\t\t}\n\n\t\t\tif (node.key) {\n\t\t\t\tnewProps.key = node.key;\n\t\t\t}\n\n\t\t\tconst renderedChildren = [];\n\t\t\tfor (let index = 0; index < children.length; index += 1) {\n\t\t\t\tconst child = children[index]!;\n\t\t\t\tconst childPath = currentPath ? `${currentPath}.${index}` : String(index);\n\t\t\t\trenderedChildren.push(this.renderNode(child, childPath));\n\t\t\t}\n\n\t\t\tif (isMountPointNode(node)) {\n\t\t\t\tconst componentKey = node.tag.slice(MOUNT_POINT_PREFIX.length);\n\t\t\t\tconst Component = this.#components[componentKey]!;\n\t\t\t\tif (!Component) {\n\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t`Could not find component ${componentKey}. This is a Pulse internal error.`,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\treturn createElement(Component, newProps, ...renderedChildren);\n\t\t\t}\n\n\t\t\treturn createElement(tag === FRAGMENT_TAG ? Fragment : tag, newProps, ...renderedChildren);\n\t\t}\n\n\t\t// Fallback for unknown node types\n\t\tif (process.env.NODE_ENV !== \"production\") {\n\t\t\tconsole.error(\"Unknown VDOM node type:\", node);\n\t\t}\n\t\treturn null;\n\t}\n\n\t#propPath(path: string, prop: string) {\n\t\treturn path ? `${path}.${prop}` : prop;\n\t}\n\n\ttransformValue(path: string, key: string, value: any) {\n\t\tconst propPath = this.#propPath(path, key);\n\t\tif (this.#callbacks.has(propPath)) {\n\t\t\treturn this.getCallback(path, key);\n\t\t}\n\t\tif (this.#renderPropKeys.has(propPath)) {\n\t\t\treturn this.renderNode(value, propPath);\n\t\t}\n\t\tif (this.#cssProps.has(propPath)) {\n\t\t\treturn this.#resolveCssToken(value);\n\t\t}\n\t\treturn value;\n\t}\n\n\t#resolveCssToken(token: string): string {\n\t\tconst idx = token.indexOf(\":\");\n\t\tif (idx === -1) {\n\t\t\treturn token;\n\t\t}\n\t\tconst moduleId = token.slice(0, idx);\n\t\tconst className = token.slice(idx + 1);\n\t\tif (!moduleId || !className) {\n\t\t\treturn token;\n\t\t}\n\t\tconst mod = this.#cssModules[moduleId];\n\t\tif (!mod) {\n\t\t\tthrow new Error(`Received CSS reference for unknown module '${moduleId}'`);\n\t\t}\n\t\tconst resolved = mod[className];\n\t\tif (typeof resolved !== \"string\") {\n\t\t\tthrow new Error(\n\t\t\t\t`Received CSS reference for missing class '${className}' in module '${moduleId}'`,\n\t\t\t);\n\t\t}\n\t\treturn resolved;\n\t}\n\n\tinit(vdom: VDOM, callbacks: string[], renderProps: string[], cssRefs: string[]): ReactNode {\n\t\t// Set callbacks\n\t\tthis.#callbacks = new Set(callbacks);\n\t\t// prune stale cached callbacks\n\t\tfor (const k of Array.from(this.#callbackCache.keys())) {\n\t\t\tif (!this.#callbacks.has(k)) this.#callbackCache.delete(k);\n\t\t}\n\t\tthis.#callbackList = [...this.#callbacks].sort();\n\n\t\t// Set render props\n\t\tthis.#renderPropKeys = new Set(renderProps);\n\n\t\t// Set CSS refs\n\t\tthis.#cssProps = new Set(cssRefs);\n\n\t\treturn this.renderNode(vdom);\n\t}\n\n\t#ensureChildrenArray(el: ReactElement): ReactNode[] {\n\t\tconst children = (el.props as any)?.children as ReactNode | undefined;\n\t\tif (children == null) return [];\n\t\treturn Array.isArray(children) ? children.slice() : [children];\n\t}\n\n\tapplyUpdates(initialTree: ReactNode, updates: VDOMUpdate[]): ReactNode {\n\t\tlet newTree: ReactNode = initialTree;\n\t\tfor (const update of updates) {\n\t\t\tif (update.type === \"update_callbacks\") {\n\t\t\t\tthis.applyCallbackDelta(update.data);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (update.type === \"update_css_refs\") {\n\t\t\t\tthis.applyCssRefsDelta(update.data);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (update.type === \"update_render_props\") {\n\t\t\t\tthis.applyRenderPropsDelta(update.data);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst parts = update.path.split(\".\").filter((s) => s.length > 0);\n\n\t\t\tconst descend = (node: ReactNode, depth: number, path: string): ReactNode => {\n\t\t\t\tif (depth < parts.length) {\n\t\t\t\t\tthis.#assertIsElement(node, parts, depth);\n\t\t\t\t\tconst element = node as ReactElement<Record<string, any> | null>;\n\t\t\t\t\tconst childKey = parts[depth]!;\n\t\t\t\t\tconst childIdx = +childKey;\n\t\t\t\t\tconst childPath = path ? `${path}.${childKey}` : childKey;\n\t\t\t\t\tif (!Number.isNaN(childIdx)) {\n\t\t\t\t\t\t// Regular child traversal\n\t\t\t\t\t\tconst childrenArr = this.#ensureChildrenArray(element);\n\t\t\t\t\t\tconst child = childrenArr[childIdx];\n\t\t\t\t\t\tchildrenArr[childIdx] = descend(child, depth + 1, childPath) as any;\n\t\t\t\t\t\treturn cloneElement(element, undefined, ...childrenArr);\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// Render prop traversal\n\t\t\t\t\t\tconst baseProps = (element.props ?? {}) as Record<string, any>;\n\t\t\t\t\t\tconst child = baseProps[childKey];\n\t\t\t\t\t\tconst props = {\n\t\t\t\t\t\t\t...baseProps,\n\t\t\t\t\t\t\t[childKey]: descend(child, depth + 1, childPath),\n\t\t\t\t\t\t};\n\t\t\t\t\t\treturn cloneElement(element, props);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tswitch (update.type) {\n\t\t\t\t\tcase \"replace\": {\n\t\t\t\t\t\treturn this.renderNode(update.data, update.path);\n\t\t\t\t\t}\n\t\t\t\t\tcase \"update_props\": {\n\t\t\t\t\t\tthis.#assertIsElement(node, parts, depth);\n\t\t\t\t\t\tconst element = node as ReactElement;\n\t\t\t\t\t\tconst currentProps = (element.props ?? {}) as Record<string, any>;\n\t\t\t\t\t\tconst nextProps: Record<string, any> = { ...currentProps };\n\t\t\t\t\t\tconst delta = update.data;\n\t\t\t\t\t\tif (delta.remove && delta.remove.length > 0) {\n\t\t\t\t\t\t\tfor (const key of delta.remove) {\n\t\t\t\t\t\t\t\tif (key in nextProps) {\n\t\t\t\t\t\t\t\t\tdelete nextProps[key];\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (delta.set) {\n\t\t\t\t\t\t\tfor (const [k, v] of Object.entries(delta.set)) {\n\t\t\t\t\t\t\t\tnextProps[k] = this.transformValue(path, k, v);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// If some props were removed, use `createElement` to fully override\n\t\t\t\t\t\t// the props, as `cloneElement` shallowly merges the new props with\n\t\t\t\t\t\t// the old ones.\n\t\t\t\t\t\tconst removedSomething = (delta.remove?.length ?? 0) > 0;\n\t\t\t\t\t\tif (removedSomething) {\n\t\t\t\t\t\t\t// Preserve key + ref\n\t\t\t\t\t\t\tnextProps.key = element.key;\n\t\t\t\t\t\t\tnextProps.ref = (element as any).ref;\n\t\t\t\t\t\t\treturn createElement(element.type, nextProps, ...this.#ensureChildrenArray(element));\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Don't touch children. Key and ref are transferred by cloneElement.\n\t\t\t\t\t\t\treturn cloneElement(element, nextProps);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tcase \"reconciliation\": {\n\t\t\t\t\t\tthis.#assertIsElement(node, parts, depth);\n\t\t\t\t\t\tconst element = node as ReactElement;\n\t\t\t\t\t\tconst prevChildren = this.#ensureChildrenArray(element);\n\t\t\t\t\t\tconst nextChildren = [];\n\n\t\t\t\t\t\tconst [newIndices, newContents] = update.new;\n\t\t\t\t\t\tconst [reuseIndices, reuseSources] = update.reuse;\n\n\t\t\t\t\t\tlet nextNew = -1,\n\t\t\t\t\t\t\tnextReuse = -1,\n\t\t\t\t\t\t\tnewIdx = -1,\n\t\t\t\t\t\t\treuseIdx = -1;\n\t\t\t\t\t\tif (newIndices.length > 0) {\n\t\t\t\t\t\t\tnextNew = newIndices[0];\n\t\t\t\t\t\t\tnewIdx = 0;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (reuseIndices.length > 0) {\n\t\t\t\t\t\t\tnextReuse = reuseIndices[0];\n\t\t\t\t\t\t\treuseIdx = 0;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tfor (let i = 0; i < update.N; ++i) {\n\t\t\t\t\t\t\tif (i === nextNew) {\n\t\t\t\t\t\t\t\tconst contents = newContents[newIdx];\n\t\t\t\t\t\t\t\tconst childPath = path ? `${path}.${i}` : String(i);\n\t\t\t\t\t\t\t\tnextChildren.push(this.renderNode(contents, childPath));\n\t\t\t\t\t\t\t\tnextNew = newIdx < newIndices.length - 1 ? newIndices[++newIdx] : -1;\n\t\t\t\t\t\t\t} else if (i === nextReuse) {\n\t\t\t\t\t\t\t\tconst srcIdx = reuseSources[reuseIdx];\n\t\t\t\t\t\t\t\tlet src = prevChildren[srcIdx];\n\t\t\t\t\t\t\t\tconst childPath = path ? `${path}.${i}` : String(i);\n\t\t\t\t\t\t\t\t// The node may have callbacks that need to be updated for this new path\n\t\t\t\t\t\t\t\tif (this.hasAnyCallbackUnder(childPath)) {\n\t\t\t\t\t\t\t\t\tsrc = this.#rebindCallbacksInSubtree(src, childPath);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tnextChildren.push(src);\n\t\t\t\t\t\t\t\tnextReuse = reuseIdx < reuseIndices.length - 1 ? reuseIndices[++reuseIdx] : -1;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t// No need to rebind callbacks, the node hasn't moved\n\t\t\t\t\t\t\t\tnextChildren.push(prevChildren[i]);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// Pass null to reuse previous props\n\t\t\t\t\t\treturn cloneElement(element, null!, ...nextChildren);\n\t\t\t\t\t}\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tthrow new Error(`[Pulse renderer] Unknown update type: ${(update as any)?.type}`);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tnewTree = descend(newTree, 0, \"\");\n\t\t}\n\t\treturn newTree;\n\t}\n\n\t#assertIsElement(node: ReactNode, parts: string[], depth: number): node is ReactElement {\n\t\tif (process.env.NODE_ENV !== \"production\" && !isValidElement(node)) {\n\t\t\tconsole.error(\"Invalid node:\", node);\n\t\t\tthrow new Error(`Invalid node at path ${parts.slice(0, depth).join(\".\")}`);\n\t\t}\n\t\treturn true;\n\t}\n\n\t// Rebind callback function props within a subtree after a path-changing move\n\t#rebindCallbacksInSubtree(node: ReactNode, path: string): ReactNode {\n\t\tif (!isValidElement(node)) return node;\n\t\tconst element = node as ReactElement<Record<string, any> | null>;\n\t\tconst baseProps = (element.props ?? {}) as Record<string, any>;\n\t\tconst nextProps: Record<string, any> = { ...baseProps };\n\n\t\t// Rebind only callback props; CSS refs are path-agnostic and render-props\n\t\t// are handled by the server-side renderer via explicit updates\n\t\tfor (const key of Object.keys(baseProps)) {\n\t\t\tconst propPath = path ? `${path}.${key}` : key;\n\t\t\tif (this.hasCallbackPath(propPath)) {\n\t\t\t\tnextProps[key] = this.getCallback(path, key);\n\t\t\t}\n\t\t\tif (this.hasRenderPropPath(propPath) && this.hasAnyCallbackUnder(propPath)) {\n\t\t\t\tnextProps[key] = this.#rebindCallbacksInSubtree(baseProps[key], propPath);\n\t\t\t}\n\t\t}\n\n\t\tconst children = this.#ensureChildrenArray(element).map((child, idx) => {\n\t\t\tconst childPath = path ? `${path}.${idx}` : String(idx);\n\t\t\tif (this.hasAnyCallbackUnder(childPath)) {\n\t\t\t\treturn this.#rebindCallbacksInSubtree(child, childPath);\n\t\t\t} else {\n\t\t\t\treturn child;\n\t\t\t}\n\t\t});\n\n\t\treturn cloneElement(element, nextProps, ...children);\n\t}\n\n\t// Binary-search lower bound for prefix matching on sorted callback paths\n\t#lowerBound(arr: string[], target: string): number {\n\t\tlet lo = 0;\n\t\tlet hi = arr.length;\n\t\twhile (lo < hi) {\n\t\t\tconst mid = (lo + hi) >>> 1;\n\t\t\tif (arr[mid]! < target) {\n\t\t\t\tlo = mid + 1;\n\t\t\t} else {\n\t\t\t\thi = mid;\n\t\t\t}\n\t\t}\n\t\treturn lo;\n\t}\n}\n\n// The `component` prop should be something like `() =>\n// import('~/path/to/component') (we'll need to remap if we're importing a named export and not the default)\nexport function RenderLazy(\n\tcomponent: () => Promise<{ default: ComponentType<any> }>,\n\tfallback?: ReactNode,\n): FC<PropsWithChildren<unknown>> {\n\tconst Component = lazy(component);\n\treturn ({ children, ...props }: PropsWithChildren<unknown>) => {\n\t\treturn (\n\t\t\t<Suspense fallback={fallback}>\n\t\t\t\t<Component {...props}>{children}</Component>\n\t\t\t</Suspense>\n\t\t);\n\t};\n}\n",
    "import type { ComponentType } from \"react\";\n\n// Special prefixes for reserved node types\nexport const FRAGMENT_TAG = \"$$fragment\";\nexport const MOUNT_POINT_PREFIX = \"$$\";\n\n// export type LazyComponent = () => Promise<{ default: ComponentType<any> }>;\nexport type RegistryEntry = ComponentType<any>;\nexport type ComponentRegistry = Record<string, ComponentType<any>>;\n\nexport interface VDOMElement {\n\ttag: string;\n\tprops?: Record<string, any>;\n\tchildren?: VDOMNode[];\n\tkey?: string;\n\tlazy?: boolean;\n}\n\n// Primitive nodes that can be rendered\nexport type PrimitiveNode = string | number | boolean;\n\n// VDOMNode is either a primitive (string, number, boolean) or an element node.\n// Booleans are valid children in React but do not render anything.\n// Mount points are just UIElementNodes with tags starting with $$ComponentKey\nexport type VDOMNode = PrimitiveNode | VDOMElement;\n\nexport type VDOM = VDOMNode;\n\nexport interface VDOMUpdateBase {\n\ttype: string;\n\tpath: string; // Dot-separated path to the node\n}\n\nexport interface ReplaceUpdate extends VDOMUpdateBase {\n\ttype: \"replace\";\n\tdata: VDOMNode; // The new node\n}\n\nexport interface UpdatePropsUpdate extends VDOMUpdateBase {\n\ttype: \"update_props\";\n\tdata: {\n\t\tset?: Record<string, any>;\n\t\tremove?: string[];\n\t};\n}\n\nexport interface ReconciliationUpdate {\n\ttype: \"reconciliation\";\n\tpath: string;\n\tN: number;\n\tnew: [number[], VDOM[]];\n\treuse: [number[], number[]];\n}\n\nexport interface PathDelta {\n\tadd?: string[];\n\tremove?: string[];\n}\n\nexport interface UpdateCallbacksUpdate extends VDOMUpdateBase {\n\ttype: \"update_callbacks\";\n\tdata: PathDelta;\n}\n\nexport interface UpdateRenderPropsUpdate extends VDOMUpdateBase {\n\ttype: \"update_render_props\";\n\tdata: PathDelta;\n}\n\nexport interface UpdateCssRefsUpdate extends VDOMUpdateBase {\n\ttype: \"update_css_refs\";\n\tdata: PathDelta;\n}\n\nexport type VDOMUpdate =\n\t| ReplaceUpdate\n\t| UpdatePropsUpdate\n\t| ReconciliationUpdate\n\t| UpdateCallbacksUpdate\n\t| UpdateRenderPropsUpdate\n\t| UpdateCssRefsUpdate;\n\nexport type UpdateType = VDOMUpdate[\"type\"];\n\n// Utility functions for working with the UI tree structure\nexport function isElementNode(node: VDOMNode): node is VDOMElement {\n\t// Matches all non-text nodes\n\treturn typeof node === \"object\" && node !== null;\n}\n\nexport function isMountPointNode(node: VDOMNode): node is VDOMElement {\n\treturn (\n\t\ttypeof node === \"object\" &&\n\t\tnode !== null &&\n\t\tnode.tag.startsWith(MOUNT_POINT_PREFIX) &&\n\t\tnode.tag !== FRAGMENT_TAG\n\t);\n}\n\nexport function isTextNode(node: VDOMNode): node is string {\n\treturn typeof node === \"string\";\n}\n\nexport function isFragment(node: VDOMNode): boolean {\n\treturn typeof node === \"object\" && node !== null && node.tag === FRAGMENT_TAG;\n}\n",
    "import { useEffect, useMemo } from \"react\";\nimport type { ChannelBridge } from \"./channel\";\nimport { usePulseClient } from \"./pulse\";\n\nexport function usePulseChannel(channelId: string): ChannelBridge {\n\tconst client = usePulseClient();\n\tconst bridge = useMemo(() => {\n\t\tif (!channelId) {\n\t\t\tthrow new Error(\"usePulseChannel requires a non-empty channelId\");\n\t\t}\n\t\treturn client.acquireChannel(channelId);\n\t}, [client, channelId]);\n\n\tuseEffect(() => {\n\t\treturn () => {\n\t\t\tclient.releaseChannel(channelId);\n\t\t};\n\t}, [client, channelId]);\n\n\treturn bridge;\n}\n"
  ],
  "mappings": "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",
  "debugId": "E3FD7CD6C93459F364756E2164756E21",
  "names": []
}