@hozu/runtime-client 0.1.0

package/dist/browser-dev/client.js

@@ -0,0 +1,1604 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/runtime-client/dist/uploads.js
+var uploads_exports = {};
+__export(uploads_exports, {
+  encode: () => encode
+});
+function encode(json, input, uploads2) {
+  const tokens = tokensIn(input, uploads2);
+  if (!tokens.length)
+    return json;
+  const form = new FormData();
+  form.append("request", json);
+  for (const token of tokens)
+    form.append(token, uploads2.get(token));
+  return form;
+}
+var tokensIn;
+var init_uploads = __esm({
+  "packages/runtime-client/dist/uploads.js"() {
+    "use strict";
+    tokensIn = (value, uploads2, out = []) => {
+      if (typeof value === "string") {
+        if (uploads2.has(value))
+          out.push(value);
+      } else if (value && typeof value === "object")
+        for (const v of Object.values(value))
+          tokensIn(v, uploads2, out);
+      return out;
+    };
+  }
+});
+
+// packages/runtime-client/dist/dev.js
+var dev_exports = {};
+__export(dev_exports, {
+  expose: () => expose,
+  restore: () => restore
+});
+function restore(doc) {
+  const store2 = storage(doc);
+  let saved = {};
+  try {
+    saved = JSON.parse(store2?.getItem(KEY) ?? "{}");
+  } catch {
+  }
+  store2?.removeItem(KEY);
+  return (id, machine) => {
+    const entry = saved[id];
+    if (!entry || !machine || entry.machine !== JSON.stringify(machine))
+      return void 0;
+    return machine.states[entry.snapshot.state]?.invoke ? void 0 : entry.snapshot;
+  };
+}
+function expose(doc, apps, machines) {
+  const win = doc.defaultView;
+  if (!win)
+    return;
+  win.__hozu = {
+    save() {
+      const saved = {};
+      for (const [id, app] of apps) {
+        const snapshot = app.snapshot();
+        const machine = machines.get(id);
+        if (snapshot && machine)
+          saved[id] = { machine: JSON.stringify(machine), snapshot };
+      }
+      storage(doc)?.setItem(KEY, JSON.stringify(saved));
+    }
+  };
+}
+var KEY, storage;
+var init_dev = __esm({
+  "packages/runtime-client/dist/dev.js"() {
+    "use strict";
+    KEY = "hozu:snapshots";
+    storage = (doc) => {
+      try {
+        return doc.defaultView?.sessionStorage ?? null;
+      } catch {
+        return null;
+      }
+    };
+  }
+});
+
+// packages/runtime-client/dist/motion.js
+var motion_exports = {};
+__export(motion_exports, {
+  enter: () => enter2,
+  flip: () => flip,
+  leave: () => leave,
+  reduced: () => reduced
+});
+function duration(el) {
+  const cs = el.ownerDocument.defaultView?.getComputedStyle(el);
+  if (!cs)
+    return 0;
+  const longest = (d, delay) => {
+    const a = seconds(d);
+    const b = seconds(delay);
+    return Math.max(0, ...a.map((x, i) => x + (b[i % b.length] ?? 0)));
+  };
+  return Math.max(longest(cs.transitionDuration, cs.transitionDelay), longest(cs.animationDuration, cs.animationDelay));
+}
+function after(el, run) {
+  const ms = duration(el);
+  if (ms === 0)
+    return run();
+  let done = false;
+  const finish = () => {
+    if (done)
+      return;
+    done = true;
+    el.removeEventListener("transitionend", finish);
+    el.removeEventListener("animationend", finish);
+    run();
+  };
+  el.addEventListener("transitionend", finish);
+  el.addEventListener("animationend", finish);
+  setTimeout(finish, ms + 50);
+}
+function phase(el, name, stage, done) {
+  const from = `${name}-${stage}-from`;
+  const active = `${name}-${stage}-active`;
+  const to = `${name}-${stage}-to`;
+  el.classList.add(from, active);
+  frame(el, () => {
+    el.classList.remove(from);
+    el.classList.add(to);
+    after(el, () => {
+      el.classList.remove(active, to);
+      done();
+    });
+  });
+}
+function enter2(nodes, name) {
+  for (const n of nodes)
+    if (n.nodeType === 1)
+      phase(n, name, "enter", () => {
+      });
+}
+function leave(nodes, name) {
+  for (const n of nodes)
+    if (n.nodeType === 1)
+      phase(n, name, "leave", () => n.remove());
+    else
+      n.remove();
+}
+function flip(el, before, name) {
+  const now = el.getBoundingClientRect();
+  const dx = before.left - now.left;
+  const dy = before.top - now.top;
+  if (!dx && !dy)
+    return;
+  const style = el.style;
+  style.transitionDuration = "0s";
+  style.transform = `translate(${dx}px, ${dy}px)`;
+  void el.offsetWidth;
+  el.classList.add(`${name}-move`);
+  style.transitionDuration = "";
+  style.transform = "";
+  after(el, () => el.classList.remove(`${name}-move`));
+}
+var seconds, frame, reduced;
+var init_motion = __esm({
+  "packages/runtime-client/dist/motion.js"() {
+    "use strict";
+    seconds = (list) => list.split(",").map((s) => Number.parseFloat(s) * (s.trim().endsWith("ms") ? 1 : 1e3) || 0);
+    frame = (el, run) => {
+      const win = el.ownerDocument.defaultView;
+      if (!win?.requestAnimationFrame)
+        return run();
+      win.requestAnimationFrame(() => win.requestAnimationFrame(run));
+    };
+    reduced = (doc) => doc.defaultView?.matchMedia?.("(prefers-reduced-motion: reduce)").matches === true;
+  }
+});
+
+// packages/runtime-client/dist/visible.js
+var visible_exports = {};
+__export(visible_exports, {
+  watch: () => watch
+});
+function watch(doc) {
+  const win = doc.defaultView;
+  if (!win?.IntersectionObserver || watched.has(doc))
+    return;
+  watched.add(doc);
+  const seen = new IntersectionObserver((entries) => {
+    for (const e of entries)
+      if (e.isIntersecting)
+        e.target.dispatchEvent(new win.Event("visible"));
+  });
+  const scan = (root) => {
+    if (root instanceof win.Element && root.hasAttribute("data-hozu-visible"))
+      seen.observe(root);
+    for (const el of root.querySelectorAll("[data-hozu-visible]"))
+      seen.observe(el);
+  };
+  scan(doc);
+  new win.MutationObserver((records) => {
+    for (const r of records)
+      for (const n of r.addedNodes)
+        if (n.nodeType === 1)
+          scan(n);
+  }).observe(doc.body, { childList: true, subtree: true });
+}
+var watched;
+var init_visible = __esm({
+  "packages/runtime-client/dist/visible.js"() {
+    "use strict";
+    watched = /* @__PURE__ */ new WeakSet();
+  }
+});
+
+// packages/runtime-client/dist/widget.js
+var widget_exports = {};
+__export(widget_exports, {
+  mountWidget: () => mountWidget
+});
+function mountWidget(h) {
+  const controller = new AbortController();
+  let props = h.props();
+  let instance;
+  const fail = (error) => {
+    instance = void 0;
+    h.doc.defaultView?.console.error(`Widget ${h.name} failed`, error);
+  };
+  const start = () => void h.load(h.ref.url).then((setup) => {
+    if (controller.signal.aborted)
+      return;
+    try {
+      instance = setup({ el: h.el, props, emit: h.emit, signal: controller.signal }) ?? void 0;
+    } catch (error) {
+      fail(error);
+    }
+  }, fail);
+  const win = h.doc.defaultView;
+  if (h.ref.load === "eager" || !win)
+    start();
+  else if (h.ref.load === "idle")
+    (win.requestIdleCallback ?? win.setTimeout)(start);
+  else if (!win.IntersectionObserver)
+    start();
+  else {
+    const io = new win.IntersectionObserver((entries) => {
+      if (!entries.some((e) => e.isIntersecting))
+        return;
+      io.disconnect();
+      start();
+    });
+    io.observe(h.el);
+    controller.signal.addEventListener("abort", () => io.disconnect());
+  }
+  h.watch(() => {
+    const next = h.props();
+    if (h.same(next, props))
+      return;
+    props = next;
+    try {
+      instance?.update?.(next);
+    } catch (error) {
+      fail(error);
+    }
+  });
+  h.own(() => {
+    controller.abort();
+    instance?.destroy?.();
+  });
+}
+var init_widget = __esm({
+  "packages/runtime-client/dist/widget.js"() {
+    "use strict";
+  }
+});
+
+// packages/runtime-client/dist/live.js
+var live_exports = {};
+__export(live_exports, {
+  liveStream: () => liveStream
+});
+var liveStream;
+var init_live = __esm({
+  "packages/runtime-client/dist/live.js"() {
+    "use strict";
+    liveStream = (doc) => (onTags) => {
+      const Source = doc.defaultView?.EventSource;
+      if (!Source)
+        return;
+      new Source(new URL("live", import.meta.url)).addEventListener("message", (e) => onTags(JSON.parse(e.data)));
+    };
+  }
+});
+
+// packages/runtime-client/dist/navigate.js
+var navigate_exports = {};
+__export(navigate_exports, {
+  islandsIn: () => islandsIn,
+  ranges: () => ranges,
+  routeOf: () => routeOf,
+  soft: () => soft,
+  swap: () => swap,
+  track: () => track
+});
+function routeOf(routes, pathname) {
+  let best = null;
+  let fewest = Infinity;
+  for (const [id, path] of Object.entries(routes)) {
+    const { pattern, keys } = patternOf(path);
+    if (keys < fewest && pattern.test(pathname)) {
+      best = id;
+      fewest = keys;
+    }
+  }
+  return best;
+}
+function islandsIn(root) {
+  const found = [];
+  const walker = (root.ownerDocument ?? root).createTreeWalker(root, 128);
+  let view = null;
+  while (walker.nextNode()) {
+    const c = walker.currentNode;
+    if (c.data === "i")
+      found.push({ marker: c, view });
+    else if (c.data.startsWith("v:"))
+      view = c.data.slice(2);
+    else if (c.data === "/v")
+      view = null;
+  }
+  return found;
+}
+function track(state, session, payload, found) {
+  session.islands(payload).forEach((island, i) => {
+    const view = found[i]?.view;
+    if (!view)
+      return;
+    const owners = state.views.get(view) ?? /* @__PURE__ */ new Set();
+    owners.add(island.feature);
+    state.views.set(view, owners);
+  });
+  state.soft = payload.soft ?? {};
+  Object.assign(state.routes, payload.routes);
+}
+function ranges(body) {
+  const out = /* @__PURE__ */ new Map();
+  let current = null;
+  for (const n of [...body.childNodes]) {
+    if (n.nodeType === 8 && n.data.startsWith("v:")) {
+      current = [n];
+      out.set(n.data.slice(2), current);
+    } else if (current) {
+      current.push(n);
+      if (n.nodeType === 8 && n.data === "/v")
+        current = null;
+    }
+  }
+  return out;
+}
+async function swap(session, state, next, kept) {
+  const { doc, apps } = session;
+  const { views } = state;
+  const script = next.getElementById("hozu-payload");
+  const fresh = ranges(next.body);
+  const live = ranges(doc.body);
+  if (!script?.textContent || kept.some((v) => !fresh.has(v) || !live.has(v)))
+    return false;
+  const payload = JSON.parse(script.textContent);
+  const keep = new Set(kept);
+  const found = islandsIn(next.body);
+  const needed = /* @__PURE__ */ new Set();
+  for (const v of keep)
+    for (const f of views.get(v) ?? [])
+      needed.add(f);
+  session.islands(payload).forEach((island, i) => {
+    const view = found[i]?.view;
+    if (view === void 0 || view === null || !keep.has(view))
+      needed.add(island.feature);
+  });
+  for (const [id, app] of apps)
+    if (!needed.has(id)) {
+      app.destroy();
+      apps.delete(id);
+    }
+  for (const v of [...views.keys()])
+    if (!keep.has(v))
+      views.delete(v);
+  const anchor = doc.getElementById("hozu-payload");
+  let cursor = 0;
+  const order = [...live.keys()].filter((v) => keep.has(v));
+  for (const [ref, nodes] of fresh) {
+    if (keep.has(ref)) {
+      cursor++;
+      continue;
+    }
+    const before = order[cursor] ? live.get(order[cursor])[0] : anchor;
+    for (const n of nodes)
+      doc.body.insertBefore(n, before);
+  }
+  for (const [ref, nodes] of live)
+    if (!keep.has(ref))
+      for (const n of nodes)
+        n.remove();
+  if (anchor)
+    anchor.textContent = script.textContent;
+  for (const el of doc.head.querySelectorAll(HEAD))
+    el.remove();
+  for (const el of next.head.querySelectorAll(HEAD))
+    doc.head.append(el);
+  doc.documentElement.lang = next.documentElement.lang;
+  await session.mount(payload, found.map((f) => f.view !== null && keep.has(f.view) ? void 0 : f.marker));
+  track(state, session, payload, found);
+  return true;
+}
+function soft(session) {
+  const { doc } = session;
+  const win = doc.defaultView;
+  const script = doc.getElementById("hozu-payload");
+  if (!win?.navigation || !script?.textContent)
+    return;
+  const state = { views: /* @__PURE__ */ new Map(), soft: {}, routes: {} };
+  track(state, session, JSON.parse(script.textContent), islandsIn(doc.body));
+  let announcer = null;
+  let bypass = false;
+  const announce = (title) => {
+    if (!announcer) {
+      announcer = doc.createElement("div");
+      announcer.setAttribute("aria-live", "polite");
+      announcer.style.cssText = "position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap";
+      doc.body.append(announcer);
+    }
+    announcer.textContent = title;
+  };
+  win.navigation.addEventListener("navigate", (event) => {
+    const e = event;
+    if (bypass || !e.canIntercept || e.hashChange || e.downloadRequest !== null || e.formData)
+      return;
+    if (e.navigationType === "reload")
+      return;
+    const url = new URL(e.destination.url);
+    if (url.origin !== win.location.origin)
+      return;
+    const target = routeOf(state.routes, url.pathname);
+    const kept = target ? state.soft[target] : void 0;
+    if (!kept)
+      return;
+    const hard = () => {
+      bypass = true;
+      win.location.replace(url.href);
+    };
+    e.intercept({
+      handler: async () => {
+        const root = doc.documentElement;
+        root.setAttribute("data-hozu-navigating", "");
+        try {
+          const response = await win.fetch(url.href, { headers: { accept: "text/html" } });
+          const type = response.headers.get("content-type") ?? "";
+          if (response.status !== 200 || response.redirected || !type.includes("text/html"))
+            return hard();
+          const next = new win.DOMParser().parseFromString(await response.text(), "text/html");
+          let ok = true;
+          const run = async () => {
+            ok = await swap(session, state, next, kept);
+          };
+          const transition2 = doc.startViewTransition;
+          if (transition2)
+            await transition2.call(doc, run).updateCallbackDone;
+          else
+            await run();
+          if (!ok)
+            return hard();
+          announce(doc.title);
+        } catch {
+          hard();
+        } finally {
+          root.removeAttribute("data-hozu-navigating");
+        }
+      }
+    });
+  });
+}
+var HEAD, groups, patternOf;
+var init_navigate = __esm({
+  "packages/runtime-client/dist/navigate.js"() {
+    "use strict";
+    HEAD = 'title,meta[name=description],meta[name=robots],link[rel=canonical],meta[property],script[type="application/ld+json"]';
+    groups = { "?": "(?:/[^/]+)?", "+": "(?:/[^/]+)+", "*": "(?:/[^/]+)*" };
+    patternOf = (path) => {
+      let keys = 0;
+      const source = path.split(/(\/:[A-Za-z]\w*[?*+]?)/).map((part, i) => {
+        if (i % 2 === 0)
+          return part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const mod = part.at(-1);
+        keys += mod === "+" || mod === "*" ? 1.01 : 1;
+        return groups[mod] ?? "/[^/]+";
+      }).join("");
+      return { pattern: new RegExp(`^${source.replace(/\/$/, "")}/?$`), keys };
+    };
+  }
+});
+
+// packages/machine/dist/data.js
+function getIn(value, path) {
+  let current = value;
+  for (const key of path) {
+    if (current === null || typeof current !== "object")
+      return null;
+    current = current[key];
+  }
+  return current === void 0 ? null : current;
+}
+function setIn(value, path, next, i = 0) {
+  if (i === path.length)
+    return next;
+  const key = path[i];
+  if (Array.isArray(value)) {
+    const copy = value.slice();
+    copy[Number(key)] = setIn(value[Number(key)] ?? null, path, next, i + 1);
+    return copy;
+  }
+  const base = value !== null && typeof value === "object" ? value : {};
+  return { ...base, [key]: setIn(base[key] ?? null, path, next, i + 1) };
+}
+function equal(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object")
+    return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length)
+      return false;
+    for (let i = 0; i < a.length; i++)
+      if (!equal(a[i], b[i]))
+        return false;
+    return true;
+  }
+  if (Array.isArray(b))
+    return false;
+  const ka = Object.keys(a);
+  if (ka.length !== Object.keys(b).length)
+    return false;
+  for (const k of ka)
+    if (!Object.hasOwn(b, k) || !equal(a[k], b[k]))
+      return false;
+  return true;
+}
+var pathOf = (pattern, params, search) => {
+  const [route = "", defaults = ""] = pattern.split("?");
+  const path = route.replace(/\/:([A-Za-z]\w*)[?*+]?/g, (_, key) => {
+    const x = getIn(params, [key]);
+    return [x ?? []].flat().map((s) => `/${encodeURIComponent(String(s))}`).join("");
+  }) || "/";
+  const skip = defaults.split("&");
+  let q = "";
+  if (search && typeof search === "object")
+    for (const key of Object.keys(search).sort()) {
+      const x = search[key];
+      const pair = `${encodeURIComponent(key)}=${encodeURIComponent(String(x))}`;
+      if (x !== null && typeof x !== "object" && !skip.includes(pair))
+        q += `${q && "&"}${pair}`;
+    }
+  return q ? `${path}?${q}` : path;
+};
+
+// packages/machine/dist/compile.js
+var CompileError = class extends Error {
+  name = "CompileError";
+};
+function compileValue(v, fns) {
+  if ("literal" in v) {
+    const literal = v.literal;
+    return () => literal;
+  }
+  if ("object" in v) {
+    const entries = Object.entries(v.object).map(([k, x]) => [k, compileValue(x, fns)]);
+    return (env) => {
+      const out = {};
+      for (const [k, get] of entries)
+        out[k] = get(env);
+      return out;
+    };
+  }
+  if ("fn" in v) {
+    const impl = fns[v.fn];
+    if (!impl)
+      throw new CompileError(`No implementation bound for fn ${v.fn}`);
+    const arg = compileValue(v.arg, fns);
+    return (env) => impl(arg(env));
+  }
+  if ("link" in v) {
+    const id = v.link;
+    const params = compileValue(v.params, fns);
+    const search = compileValue(v.search, fns);
+    return (env) => pathOf(env.routes?.[id] ?? "", params(env), search(env));
+  }
+  if ("test" in v) {
+    const test = guard(v.test, fns);
+    return (env) => test(env);
+  }
+  const { path } = v;
+  if (v.ref === "binding") {
+    const depth = v.depth;
+    return path.length ? (env) => getIn(env.bindings?.[depth], path) : (env) => env.bindings?.[depth] ?? null;
+  }
+  if (v.ref === "dom") {
+    const [field, ...rest] = path;
+    return (env) => env.dom && field ? getIn(env.dom(field), rest) : null;
+  }
+  const ref = v.ref;
+  if (path.length === 0)
+    return (env) => env[ref] ?? null;
+  return (env) => getIn(env[ref], path);
+}
+var numeric = (x) => typeof x === "number" || typeof x === "string" ? x : Number.NaN;
+function guard(g, fns) {
+  switch (g.op) {
+    case "and": {
+      const args = g.args.map((a) => guard(a, fns));
+      return (env) => args.every((t) => t(env));
+    }
+    case "or": {
+      const args = g.args.map((a) => guard(a, fns));
+      return (env) => args.some((t) => t(env));
+    }
+    case "not": {
+      const arg = guard(g.arg, fns);
+      return (env) => !arg(env);
+    }
+    case "fn": {
+      const call = compileValue({ fn: g.fn, arg: g.arg }, fns);
+      return (env) => call(env) === true;
+    }
+    default: {
+      const l = compileValue(g.left, fns);
+      const r = compileValue(g.right, fns);
+      switch (g.op) {
+        case "eq":
+          return (env) => equal(l(env), r(env));
+        case "neq":
+          return (env) => !equal(l(env), r(env));
+        case "lt":
+          return (env) => numeric(l(env)) < numeric(r(env));
+        case "lte":
+          return (env) => numeric(l(env)) <= numeric(r(env));
+        case "gt":
+          return (env) => numeric(l(env)) > numeric(r(env));
+        default:
+          return (env) => numeric(l(env)) >= numeric(r(env));
+      }
+    }
+  }
+}
+function assign(a, fns) {
+  const { path } = a;
+  const v = compileValue(a.value, fns);
+  switch (a.op) {
+    case "set":
+      return (ctx, env) => setIn(ctx, path, v({ ...env, context: ctx }));
+    case "append":
+      return (ctx, env) => {
+        const list = getIn(ctx, path);
+        return setIn(ctx, path, [...Array.isArray(list) ? list : [], v({ ...env, context: ctx })]);
+      };
+    case "inc":
+      return (ctx, env) => setIn(ctx, path, Number(getIn(ctx, path) ?? 0) + Number(v({ ...env, context: ctx })));
+    case "removeWhere": {
+      const key = a.key;
+      return (ctx, env) => {
+        const list = getIn(ctx, path);
+        const match = v({ ...env, context: ctx });
+        const items = Array.isArray(list) ? list : [];
+        return setIn(ctx, path, items.filter((item) => !equal(item !== null && typeof item === "object" && !Array.isArray(item) ? item[key] : null, match)));
+      };
+    }
+  }
+}
+var navigateTo = (url, routes) => (env) => url({ ...env, routes });
+function compileMachine(feature, fns = {}, routes = {}) {
+  const m = feature.machine;
+  if (!m)
+    throw new CompileError(`Feature ${feature.id} has no machine`);
+  const names = Object.keys(m.states);
+  const index = new Map(names.map((n, i) => [n, i]));
+  const indexOf = (name) => {
+    const i = index.get(name);
+    if (i === void 0)
+      throw new CompileError(`Unknown state "${name}" in ${feature.id}`);
+    return i;
+  };
+  const transitions = [];
+  const compile = (t, id) => {
+    transitions.push(id);
+    return {
+      id,
+      guard: t.guard ? guard(t.guard, fns) : null,
+      target: indexOf(t.target),
+      assign: t.assign.map((a) => assign(a, fns)),
+      navigate: t.navigate ? navigateTo(compileValue(t.navigate, fns), routes) : null
+    };
+  };
+  const states = names.map((name) => {
+    const s = m.states[name];
+    const on = /* @__PURE__ */ new Map();
+    for (const [event, list] of Object.entries(s.on))
+      on.set(event, list.map((t, i) => compile(t, `${name}/on/${event}/${i}`)));
+    const after2 = /* @__PURE__ */ new Map();
+    s.after.forEach((a, i) => {
+      const t = compile(a.transition, `${name}/after/${i}`);
+      after2.set(a.ms, [...after2.get(a.ms) ?? [], t]);
+    });
+    const invoke = s.invoke;
+    return {
+      name,
+      final: s.final,
+      on,
+      invoke: invoke && {
+        effect: invoke.effect,
+        input: compileValue(invoke.input, fns),
+        done: invoke.done.map((t, i) => compile(t, `${name}/invoke/done/${i}`)),
+        failed: new Map(Object.entries(invoke.failed).map(([error, list]) => [
+          error,
+          list.map((t, i) => compile(t, `${name}/invoke/failed/${error}/${i}`))
+        ]))
+      },
+      after: after2,
+      timers: [...after2.keys()].sort((a, b) => a - b)
+    };
+  });
+  return {
+    feature: feature.id,
+    initial: indexOf(m.initial),
+    initialContext: m.initialContext,
+    states,
+    index,
+    transitions
+  };
+}
+
+// packages/machine/dist/transition.js
+function enterEffects(machine, state, context, entry, effects) {
+  const s = machine.states[state];
+  if (s.invoke)
+    effects.push({ type: "invoke", entry, effect: s.invoke.effect, input: s.invoke.input({ context }) });
+  for (const ms of s.timers)
+    effects.push({ type: "timer", entry, ms });
+}
+function enter(machine, state, context, entry = 1) {
+  const index = machine.index.get(state);
+  if (index === void 0)
+    throw new Error(`Unknown state "${state}" in ${machine.feature}`);
+  const effects = [];
+  enterEffects(machine, index, context, entry, effects);
+  return { snapshot: { state, context, entry }, effects, taken: null };
+}
+var init = (machine) => enter(machine, machine.states[machine.initial].name, machine.initialContext);
+var ignored = (snapshot) => ({ snapshot, effects: [], taken: null });
+function fire(machine, snapshot, candidates, env) {
+  if (!candidates)
+    return ignored(snapshot);
+  for (const t of candidates) {
+    if (t.guard && !t.guard(env))
+      continue;
+    let context = snapshot.context;
+    for (const update of t.assign)
+      context = update(context, env);
+    const entry = snapshot.entry + 1;
+    const effects = t.navigate === null ? [] : [{ type: "navigate", url: String(t.navigate(env)) }];
+    enterEffects(machine, t.target, context, entry, effects);
+    return { snapshot: { state: machine.states[t.target].name, context, entry }, effects, taken: t.id };
+  }
+  return ignored(snapshot);
+}
+function transition(machine, snapshot, input) {
+  const state = machine.states[machine.index.get(snapshot.state) ?? -1];
+  if (!state || state.final)
+    return ignored(snapshot);
+  const context = snapshot.context;
+  switch (input.type) {
+    case "event":
+      return fire(machine, snapshot, state.on.get(input.event), { context, event: input.payload });
+    case "done":
+      if (input.entry !== snapshot.entry || !state.invoke)
+        return ignored(snapshot);
+      return fire(machine, snapshot, state.invoke.done, { context, result: input.result });
+    case "failed": {
+      if (input.entry !== snapshot.entry || !state.invoke)
+        return ignored(snapshot);
+      const failed = state.invoke.failed;
+      const declared = failed.has(input.error);
+      const error = declared ? input.data : { message: messageOf(input.data, input.error) };
+      return fire(machine, snapshot, failed.get(declared ? input.error : "Unexpected"), { context, error });
+    }
+    case "timer":
+      if (input.entry !== snapshot.entry)
+        return ignored(snapshot);
+      return fire(machine, snapshot, state.after.get(input.ms), { context });
+  }
+}
+function messageOf(data, error) {
+  if (data !== null && typeof data === "object" && !Array.isArray(data) && typeof data.message === "string")
+    return data.message;
+  return error;
+}
+
+// packages/runtime-client/dist/dom.js
+var SVG_NS = "http://www.w3.org/2000/svg";
+var stringBooleans = /* @__PURE__ */ new Set(["contenteditable", "draggable", "spellcheck"]);
+var text = (v) => v === null || v === void 0 ? "" : typeof v === "object" ? JSON.stringify(v) : String(v);
+function attrText(name, x) {
+  if (x === null || x === void 0)
+    return null;
+  if (typeof x === "boolean") {
+    if (name.startsWith("aria-") || name.startsWith("data-") || stringBooleans.has(name))
+      return String(x);
+    return x ? "" : null;
+  }
+  return text(x);
+}
+var properties = /* @__PURE__ */ new Set(["value", "checked", "selected", "muted"]);
+var passive = /* @__PURE__ */ new Set([
+  "scroll",
+  "wheel",
+  "touchstart",
+  "touchmove",
+  "touchend",
+  "pointermove",
+  "mousemove"
+]);
+var num = (x) => typeof x === "number" && !Number.isNaN(x) ? x : null;
+var uploads = /* @__PURE__ */ new Map();
+var fileList = (files) => files ? [...files].map((f) => {
+  const token = `u${uploads.size + 1}`;
+  uploads.set(token, f);
+  return { name: f.name, size: f.size, type: f.type, token };
+}) : [];
+var domField = (e) => (field) => {
+  const t = e.target;
+  switch (field) {
+    case "value":
+      return typeof t?.value === "string" ? t.value : "";
+    case "checked":
+      return t?.checked === true;
+    case "valueAsNumber":
+      return num(t?.valueAsNumber);
+    case "files":
+      return fileList(t?.files ?? e.dataTransfer?.files);
+    case "form": {
+      const out = {};
+      const form = e.target;
+      const win = form.ownerDocument.defaultView;
+      for (const [k, v] of new (win?.FormData ?? FormData)(form))
+        out[k] = typeof v === "string" ? v : v.name;
+      return out;
+    }
+    case "open":
+      return t?.open === true;
+    case "returnValue":
+      return typeof t?.returnValue === "string" ? t.returnValue : "";
+    default: {
+      const x = field in e ? e[field] : t?.[field];
+      return typeof x === "number" ? num(x) : typeof x === "string" || typeof x === "boolean" ? x : null;
+    }
+  }
+};
+var classText = (base, active) => base ? active.length ? `${base} ${active.join(" ")}` : base : active.join(" ");
+
+// packages/core/dist/canonical/stringify.js
+var quote = JSON.stringify;
+function canonicalStringify(value) {
+  if (value === null)
+    return "null";
+  switch (typeof value) {
+    case "string":
+      return quote(value);
+    case "boolean":
+      return value ? "true" : "false";
+    case "number":
+      if (!Number.isFinite(value))
+        throw new TypeError(`Non-finite number ${value} is not valid JSON`);
+      return Object.is(value, -0) ? "0" : String(value);
+    case "object": {
+      if (Array.isArray(value))
+        return `[${value.map(canonicalStringify).join(",")}]`;
+      const obj = value;
+      const keys = Object.keys(obj).sort();
+      let out = "{";
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const v = obj[key];
+        if (v === void 0)
+          throw new TypeError(`Undefined value at key "${key}"`);
+        out += `${i ? "," : ""}${quote(key)}:${canonicalStringify(v)}`;
+      }
+      return `${out}}`;
+    }
+    default:
+      throw new TypeError(`Value of type ${typeof value} is not valid JSON`);
+  }
+}
+
+// packages/runtime-client/dist/mount.js
+var guardReads = (g) => {
+  switch (g.op) {
+    case "and":
+    case "or":
+      return g.args.some(guardReads);
+    case "not":
+      return guardReads(g.arg);
+    case "fn":
+      return reads(g.arg);
+    default:
+      return reads(g.left) || reads(g.right);
+  }
+};
+var reads = (v) => "ref" in v ? v.ref === "context" || v.ref === "binding" : "object" in v ? Object.values(v.object).some(reads) : "fn" in v ? reads(v.arg) : "test" in v && guardReads(v.test);
+var payloadKey = (query, input) => query + canonicalStringify(input);
+var store = (payload) => payload instanceof Map ? { data: payload, versions: /* @__PURE__ */ new Map() } : payload;
+var isComment = (n, data) => n !== null && n.nodeType === 8 && n.data === data;
+function range(first, last) {
+  const out = [first];
+  let n = first;
+  while (n !== last) {
+    n = n.nextSibling;
+    if (!n)
+      break;
+    out.push(n);
+  }
+  return out;
+}
+function span(c, run) {
+  const prev = c.next ? c.next.previousSibling : c.parent.lastChild;
+  run();
+  return [prev ? prev.nextSibling : c.parent.firstChild, c.next ? c.next.previousSibling : c.parent.lastChild];
+}
+function clear(start, end) {
+  while (start.nextSibling && start.nextSibling !== end)
+    start.nextSibling.remove();
+}
+function createApp(doc, options) {
+  const { machine, fns = {}, params = null, search = null, routes = {} } = options;
+  const { data: payload } = store(options.payload);
+  const ranges2 = [];
+  const timers = /* @__PURE__ */ new Set();
+  let first = machine ? options.snapshot ? null : init(machine) : null;
+  let snapshot = options.snapshot ?? first?.snapshot ?? null;
+  const root = [];
+  const detached = /* @__PURE__ */ new Set();
+  const mounted = /* @__PURE__ */ new Set();
+  const getters = /* @__PURE__ */ new WeakMap();
+  const value = (v, scope, dom) => {
+    let get = getters.get(v);
+    if (!get) {
+      get = compileValue(v, fns);
+      getters.set(v, get);
+    }
+    return get({
+      context: snapshot?.context ?? null,
+      bindings: scope,
+      params,
+      search,
+      routes,
+      ...dom ? { dom } : {}
+    });
+  };
+  const bind = (block, v, scope, apply) => {
+    let last = value(v, scope);
+    apply(last);
+    if (reads(v))
+      block.push(() => {
+        const next = value(v, scope);
+        if (next === last)
+          return;
+        last = next;
+        apply(next);
+      });
+  };
+  const marker = (c, data) => {
+    if (c.claim && isComment(c.next, data)) {
+      const m = c.next;
+      c.next = m.nextSibling;
+      return m;
+    }
+    return c.parent.insertBefore(doc.createComment(data), c.next);
+  };
+  const skip = (c) => {
+    if (!c.claim || !isComment(c.next, "["))
+      return;
+    let depth = 0;
+    while (c.next) {
+      const n = c.next;
+      c.next = n.nextSibling;
+      if (isComment(n, "["))
+        depth++;
+      else if (isComment(n, "]") && --depth === 0)
+        return;
+    }
+  };
+  const render = (node, scope, c, block, ns) => {
+    switch (node.kind) {
+      case "text": {
+        let t;
+        if (c.claim && c.next?.nodeType === 3) {
+          t = c.next;
+          c.next = t.nextSibling;
+        } else
+          t = c.parent.insertBefore(doc.createTextNode(""), c.next);
+        if (c.claim && isComment(c.next, ""))
+          c.next = c.next.nextSibling;
+        bind(block, node.value, scope, (x) => {
+          const s = text(x);
+          if (t.data !== s)
+            t.data = s;
+        });
+        return;
+      }
+      case "el": {
+        const tag = node.tag;
+        const space = tag === "svg" ? SVG_NS : ns;
+        let el;
+        const claimed = c.claim && c.next?.nodeType === 1 && c.next.localName === tag;
+        if (claimed) {
+          el = c.next;
+          c.next = el.nextSibling;
+        } else {
+          el = space ? doc.createElementNS(space, tag) : doc.createElement(tag);
+          if (node.class)
+            el.setAttribute("class", node.class);
+          c.parent.insertBefore(el, c.next);
+        }
+        for (const name in node.attrs) {
+          const v = node.attrs[name];
+          const prop = properties.has(name) && name in el;
+          if (claimed && !reads(v))
+            continue;
+          bind(block, v, scope, (x) => {
+            if (prop) {
+              const p = el;
+              const next = name === "value" ? text(x) : x === true;
+              if (p[name] !== next)
+                p[name] = next;
+              return;
+            }
+            const s = attrText(name, x);
+            if (s === null)
+              el.removeAttribute(name);
+            else if (el.getAttribute(name) !== s)
+              el.setAttribute(name, s);
+          });
+        }
+        styling(el, node, scope, block);
+        for (const event in node.on) {
+          const send = node.on[event];
+          el.addEventListener(event, (e) => {
+            if (event === "submit")
+              e.preventDefault();
+            dispatch({ type: "event", event: send.event, payload: value(send.payload, scope, domField(e)) });
+          }, passive.has(event) ? { passive: true } : void 0);
+        }
+        if (tag === "textarea")
+          return;
+        const inner = { parent: el, next: claimed ? el.firstChild : null, claim: claimed };
+        const childNs = tag === "foreignObject" ? null : space;
+        for (const child of node.children)
+          render(child, scope, inner, block, childNs);
+        return;
+      }
+      case "when": {
+        const visible = () => snapshot ? node.states.includes(snapshot.state) : false;
+        region(c, block, visible, (cc, inner) => {
+          if (visible())
+            for (const child of node.children)
+              render(child, scope, cc, inner, ns);
+        }, node.motion);
+        return;
+      }
+      case "query": {
+        let bound = scope;
+        const key = () => {
+          const k = payloadKey(node.query, value(node.input, scope));
+          const r = payload.get(k);
+          if (r && bound !== scope)
+            bound.splice(0, bound.length, ...scope, r.ok ? r.value : r.data);
+          return `${k}|${!r ? "" : r.ok ? "ready" : node.failed[r.error] ? r.error : "Unexpected"}`;
+        };
+        region(c, block, key, (cc, inner) => {
+          const input = value(node.input, scope);
+          const k = payloadKey(node.query, input);
+          const result = payload.get(k);
+          bound = scope;
+          if (!result) {
+            if (!cc.claim)
+              request(k, node.query, input);
+            if (node.pending)
+              render(node.pending, scope, cc, inner, ns);
+            return;
+          }
+          const branch = result.ok ? node.ready : node.failed[result.error] ?? node.failed.Unexpected;
+          bound = [...scope, result.ok ? result.value : result.data];
+          if (branch)
+            render(branch, bound, cc, inner, ns);
+        });
+        return;
+      }
+      case "each":
+        each(node, scope, c, block, ns);
+        return;
+      case "widget":
+        widget(node, scope, c, block);
+        return;
+      case "if": {
+        const test = () => value({ test: node.test }, scope) === true;
+        region(c, block, test, (cc, inner) => {
+          const branch = test() ? node.ifTrue : node.ifFalse;
+          for (const child of branch)
+            render(child, scope, cc, inner, ns);
+        }, node.motion);
+        return;
+      }
+      case "html": {
+        const start = marker(c, "[");
+        let end;
+        if (c.claim) {
+          while (c.next && !isComment(c.next, "]"))
+            c.next = c.next.nextSibling;
+          end = c.next ?? c.parent.appendChild(doc.createComment("]"));
+          c.next = end.nextSibling;
+        } else
+          end = marker(c, "]");
+        let last = c.claim ? text(value(node.value, scope)) : null;
+        bind(block, node.value, scope, (x) => {
+          const html = text(x);
+          if (html === last)
+            return;
+          last = html;
+          clear(start, end);
+          const t = doc.createElement("template");
+          t.innerHTML = html;
+          end.parentNode.insertBefore(t.content, end);
+        });
+        return;
+      }
+      case "global": {
+        const anchor = marker(c, "g");
+        const target = node.target === "window" ? doc.defaultView : doc;
+        const stops = [];
+        for (const event in node.on) {
+          const send = node.on[event];
+          const listener = (e) => dispatch({ type: "event", event: send.event, payload: value(send.payload, scope, domField(e)) });
+          const opts = passive.has(event) ? { passive: true } : void 0;
+          target.addEventListener(event, listener, opts);
+          stops.push(() => target.removeEventListener(event, listener));
+        }
+        mounted.add({ el: anchor, stop: () => stops.forEach((s) => s()) });
+        return;
+      }
+      default:
+        skip(c);
+    }
+  };
+  const styling = (el, node, scope, block) => {
+    const toggles = Object.entries(node.toggle);
+    if (toggles.length) {
+      const cls = () => {
+        const active = [];
+        for (const [c, v] of toggles)
+          if (value(v, scope) === true)
+            active.push(c);
+        return classText(node.class, active);
+      };
+      let last = cls();
+      if (el.getAttribute("class") !== last)
+        el.setAttribute("class", last);
+      if (toggles.some(([, v]) => reads(v)))
+        block.push(() => {
+          const next = cls();
+          if (next === last)
+            return;
+          last = next;
+          el.setAttribute("class", next);
+        });
+    }
+    for (const name in node.vars)
+      bind(block, node.vars[name], scope, (x) => {
+        const style = el.style;
+        if (x === null || x === "")
+          style.removeProperty(name);
+        else if (style.getPropertyValue(name) !== text(x))
+          style.setProperty(name, text(x));
+      });
+  };
+  const widget = (node, scope, c, block) => {
+    const ref = options.widgets?.[node.widget];
+    const tag = ref?.tag ?? "div";
+    let el;
+    const claimed = c.claim && c.next?.nodeType === 1 && c.next.localName === tag;
+    if (claimed) {
+      el = c.next;
+      c.next = el.nextSibling;
+    } else {
+      el = doc.createElement(tag);
+      if (node.class)
+        el.setAttribute("class", node.class);
+      c.parent.insertBefore(el, c.next);
+    }
+    styling(el, node, scope, block);
+    if (!claimed || ref?.wraps) {
+      const inner = { parent: el, next: claimed ? el.firstChild : null, claim: claimed };
+      for (const child of node.children)
+        render(child, scope, inner, block, null);
+    }
+    if (!ref || !options.loadWidget || !options.mountWidget)
+      return;
+    options.mountWidget({
+      el,
+      ref,
+      name: node.widget,
+      doc,
+      props: () => value(node.props, scope),
+      emit: (name, detail) => {
+        const send = node.on[name];
+        if (send)
+          dispatch({
+            type: "event",
+            event: send.event,
+            payload: value(send.payload, scope, (f) => f === "detail" ? detail : null)
+          });
+      },
+      load: options.loadWidget,
+      watch: (update) => block.push(update),
+      own: (stop) => mounted.add({ el, stop }),
+      same: equal
+    });
+  };
+  const fetching = /* @__PURE__ */ new Set();
+  const request = (key, query, input) => {
+    if (!options.onQuery || fetching.has(key))
+      return;
+    fetching.add(key);
+    void options.onQuery(query, input).then((result) => {
+      fetching.delete(key);
+      payload.set(key, result);
+      for (const u of root)
+        u();
+      sweep();
+    });
+  };
+  const sweep = () => {
+    for (let i = root.length - 1; i >= 0; i--)
+      if (detached.delete(root[i]))
+        root.splice(i, 1);
+    for (const m of mounted)
+      if (!m.el.isConnected) {
+        m.stop();
+        mounted.delete(m);
+      }
+  };
+  const region = (c, block, key, fill, motion = null) => {
+    const start = marker(c, "[");
+    let current = key();
+    let inner = [];
+    fill(c, inner);
+    const end = marker(c, "]");
+    block.push(() => {
+      const next = key();
+      if (next === current) {
+        for (const u of inner)
+          u();
+        return;
+      }
+      current = next;
+      inner = [];
+      const m = options.motion;
+      if (!motion || !m || m.reduced(doc)) {
+        clear(start, end);
+        fill({ parent: end.parentNode, next: end, claim: false }, inner);
+        return;
+      }
+      m.leave(start.nextSibling === end ? [] : range(start.nextSibling, end.previousSibling), motion);
+      const [a, b] = span({ parent: end.parentNode, next: end, claim: false }, () => fill({ parent: end.parentNode, next: end, claim: false }, inner));
+      if (a && b && a !== end)
+        m.enter(range(a, b), motion);
+    });
+  };
+  const each = (node, scope, c, block, ns) => {
+    const start = marker(c, "[");
+    const keyOf = (x) => {
+      const k = node.key === null ? x : getIn(x, [node.key]);
+      return typeof k === "string" ? `s${k}` : JSON.stringify(k);
+    };
+    const list = () => {
+      const x = value(node.source, scope);
+      return Array.isArray(x) ? x : [];
+    };
+    const make = (x, cc) => {
+      const s = [...scope, x];
+      const b = [];
+      const [firstNode, lastNode] = span(cc, () => render(node.item, s, cc, b, ns));
+      return { key: keyOf(x), value: x, scope: s, block: b, first: firstNode, last: lastNode };
+    };
+    let items = list().map((x) => make(x, c));
+    const end = marker(c, "]");
+    block.push(() => {
+      const m = options.motion;
+      const motion = node.motion && m && !m.reduced(doc) ? node.motion : null;
+      const rects = motion ? new Map(items.flatMap((i) => i.first.nodeType === 1 ? [[i, i.first.getBoundingClientRect()]] : [])) : null;
+      const old = new Map(items.map((i) => [i.key, i]));
+      const fresh = /* @__PURE__ */ new Set();
+      const next = [];
+      for (const x of list()) {
+        const k = keyOf(x);
+        const hit = old.get(k);
+        if (hit) {
+          old.delete(k);
+          hit.value = x;
+          hit.scope.splice(0, hit.scope.length, ...scope, x);
+          for (const u of hit.block)
+            u();
+          next.push(hit);
+        } else {
+          const item = make(x, { parent: doc.createDocumentFragment(), next: null, claim: false });
+          fresh.add(item);
+          next.push(item);
+        }
+      }
+      for (const gone of old.values())
+        if (motion)
+          m.leave(range(gone.first, gone.last), motion);
+        else
+          for (const n of range(gone.first, gone.last))
+            n.remove();
+      const parent = end.parentNode;
+      let at = start.nextSibling ?? end;
+      for (const item of next) {
+        if (item.first === at)
+          at = item.last.nextSibling ?? end;
+        else
+          for (const n of range(item.first, item.last))
+            parent.insertBefore(n, at);
+      }
+      items = next;
+      if (!motion)
+        return;
+      for (const item of next)
+        if (fresh.has(item))
+          m.enter(range(item.first, item.last), motion);
+        else {
+          const before = rects?.get(item);
+          if (before)
+            m.flip(item.first, before, motion);
+        }
+    });
+  };
+  const effects = (step) => {
+    for (const e of step.effects) {
+      if (e.type === "navigate")
+        options.onNavigate?.(e.url);
+      else if (e.type === "timer") {
+        const t = setTimeout(() => {
+          timers.delete(t);
+          dispatch({ type: "timer", entry: e.entry, ms: e.ms });
+        }, e.ms);
+        timers.add(t);
+      } else
+        options.onInvoke?.(e.effect, e.input).then((r) => dispatch(r.ok ? { type: "done", entry: e.entry, result: r.value } : { type: "failed", entry: e.entry, error: r.error, data: r.data }));
+    }
+  };
+  function dispatch(input) {
+    if (!machine || !snapshot)
+      return;
+    const step = transition(machine, snapshot, input);
+    if (!step.taken)
+      return;
+    snapshot = step.snapshot;
+    for (const u of root)
+      u();
+    sweep();
+    effects(step);
+  }
+  return {
+    attach(parent, before, node, scope, claim) {
+      const c = { parent, next: before, claim };
+      const ns = parent.namespaceURI === SVG_NS ? SVG_NS : null;
+      const block = [];
+      const [a, b] = span(c, () => render(node, scope, c, block, ns));
+      if (a && b)
+        ranges2.push([a, b]);
+      const connected = a?.isConnected === true;
+      const update = () => {
+        if (connected && !a.isConnected)
+          detached.add(update);
+        else
+          for (const u of block)
+            u();
+      };
+      root.push(update);
+    },
+    start() {
+      if (first)
+        effects(first);
+      first = null;
+    },
+    sync: () => {
+      for (const u of root)
+        u();
+      sweep();
+    },
+    dispatch,
+    snapshot: () => snapshot,
+    destroy: () => {
+      for (const t of timers)
+        clearTimeout(t);
+      timers.clear();
+      for (const m of mounted)
+        m.stop();
+      mounted.clear();
+      root.length = 0;
+      for (const [a, b] of ranges2)
+        for (const n of range(a, b))
+          n.remove();
+      ranges2.length = 0;
+    }
+  };
+}
+
+// packages/runtime-client/dist/hydrate.js
+var __rewriteRelativeImportExtension = function(path, preserveJsx) {
+  if (typeof path === "string" && /^\.\.?\//.test(path)) {
+    return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+      return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+    });
+  }
+  return path;
+};
+var islandsOf = (payload) => payload.islands.flatMap(([n, lead, ...tails]) => {
+  const node = payload.ids[n];
+  const feature = node.slice(0, node.indexOf("."));
+  return tails.map((tail) => ({ feature, node, scope: [...Array(lead).fill(null), ...tail] }));
+});
+var endpoint = (name) => new URL(name, import.meta.url);
+var fetchTransport = async (effect, input, keys) => {
+  const json = JSON.stringify({ effect, input, keys });
+  const body = uploads.size ? await (await Promise.resolve().then(() => (init_uploads(), uploads_exports))).encode(json, input, uploads) : json;
+  const response = await fetch(endpoint("effect"), {
+    method: "POST",
+    headers: typeof body === "string" ? { "content-type": "application/json" } : {},
+    body
+  });
+  return await response.json();
+};
+var fetchQuery = async (query, input) => {
+  const response = await fetch(endpoint("query"), {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ query, input })
+  });
+  return await response.json();
+};
+var importWidget = async (url) => (await import(__rewriteRelativeImportExtension(
+  /* @vite-ignore */
+  url
+))).default;
+var importFns = async (url) => (await import(__rewriteRelativeImportExtension(
+  /* @vite-ignore */
+  url
+))).fns;
+async function hydrate(doc, { transport = fetchTransport, query = fetchQuery, live, loadFns = importFns, loadWidget = importWidget } = {}) {
+  const apps = /* @__PURE__ */ new Map();
+  const script = doc.getElementById("hozu-payload");
+  if (!script?.textContent)
+    return apps;
+  const shared = { data: /* @__PURE__ */ new Map(), versions: /* @__PURE__ */ new Map() };
+  const fns = {};
+  const widgets = {};
+  const routes = {};
+  const liveKeys = /* @__PURE__ */ new Map();
+  const loaded = {};
+  const inflight = /* @__PURE__ */ new Map();
+  const onQuery = (q, input) => {
+    const key = q + JSON.stringify(input);
+    let pending = inflight.get(key);
+    if (!pending) {
+      pending = query(q, input).finally(() => inflight.delete(key));
+      inflight.set(key, pending);
+    }
+    return pending;
+  };
+  const onInvoke = async (effect, input) => {
+    const { result, refreshed } = await transport(effect, input, [...shared.data.keys()]);
+    for (const [key, value] of refreshed) {
+      shared.data.set(key, value);
+      shared.versions.set(key, (shared.versions.get(key) ?? 0) + 1);
+    }
+    if (refreshed.length)
+      for (const app of apps.values())
+        app.sync();
+    return result;
+  };
+  const dev = true ? { restore: (await Promise.resolve().then(() => (init_dev(), dev_exports))).restore(doc), machines: /* @__PURE__ */ new Map() } : null;
+  const session = {
+    doc,
+    apps,
+    islands: islandsOf,
+    async mount(payload2, markers2) {
+      if (!loaded.motion && payload2.motion)
+        loaded.motion = await Promise.resolve().then(() => (init_motion(), motion_exports));
+      if (payload2.visible)
+        void Promise.resolve().then(() => (init_visible(), visible_exports)).then((m) => m.watch(doc));
+      if (!loaded.mountWidget && Object.keys(payload2.widgets).length)
+        loaded.mountWidget = (await Promise.resolve().then(() => (init_widget(), widget_exports))).mountWidget;
+      if (!loaded.fns && payload2.fns) {
+        Object.assign(fns, await loadFns(payload2.fns));
+        loaded.fns = true;
+      }
+      Object.assign(widgets, payload2.widgets);
+      Object.assign(routes, payload2.routes);
+      for (const [key, value] of payload2.data) {
+        if (shared.data.has(key))
+          shared.versions.set(key, (shared.versions.get(key) ?? 0) + 1);
+        shared.data.set(key, value);
+      }
+      const created = [];
+      for (const [id, machine] of Object.entries(payload2.features)) {
+        if (apps.has(id))
+          continue;
+        const snapshot = dev?.restore(id, machine) || payload2.snapshots?.[id];
+        if (true)
+          dev?.machines.set(id, machine);
+        const app = createApp(doc, {
+          machine: machine ? compileMachine({ id, machine }, fns, routes) : null,
+          payload: shared,
+          params: payload2.params,
+          search: payload2.search,
+          ...snapshot ? { snapshot } : {},
+          fns,
+          widgets,
+          routes,
+          get motion() {
+            return loaded.motion;
+          },
+          get mountWidget() {
+            return loaded.mountWidget;
+          },
+          loadWidget,
+          onQuery,
+          onInvoke,
+          onNavigate: (url) => doc.defaultView?.location.assign(url)
+        });
+        apps.set(id, app);
+        created.push(app);
+      }
+      islandsOf(payload2).forEach((island, i) => {
+        const at = markers2[i];
+        const node = payload2.nodes[island.node];
+        if (at?.parentNode && node)
+          apps.get(island.feature)?.attach(at.parentNode, at.nextSibling, node, island.scope, true);
+      });
+      for (const app of apps.values())
+        app.sync();
+      for (const app of created)
+        app.start();
+      for (const [key, l] of Object.entries(payload2.live ?? {}))
+        liveKeys.set(key, l);
+      if (liveKeys.size && !loaded.live) {
+        loaded.live = true;
+        (live ?? (await Promise.resolve().then(() => (init_live(), live_exports))).liveStream(doc))(async (tags) => {
+          const stale = [...liveKeys].filter(([, l]) => l.tags.some((t) => tags.includes(t)));
+          for (const [key, l] of stale)
+            shared.data.set(key, await query(l.query, l.input));
+          if (stale.length)
+            for (const app of apps.values())
+              app.sync();
+        });
+      }
+    }
+  };
+  const payload = JSON.parse(script.textContent);
+  const markers = [];
+  const walker = doc.createTreeWalker(doc.body ?? doc, 128);
+  while (walker.nextNode())
+    if (walker.currentNode.data === "i")
+      markers.push(walker.currentNode);
+  await session.mount(payload, markers);
+  if (dev)
+    (await Promise.resolve().then(() => (init_dev(), dev_exports))).expose(doc, apps, dev.machines);
+  if (payload.soft)
+    void Promise.resolve().then(() => (init_navigate(), navigate_exports)).then((m) => m.soft(session));
+  return apps;
+}
+
+// packages/runtime-client/dist/browser.js
+void hydrate(document);