@mauroandre/velojs 0.0.59 → 0.0.61

package/dist/channels.js

@@ -1,431 +1,606 @@
-import { DEFAULT_HEARTBEAT_MS as H } from "./events.js";
-import { trace as P, spanRecorder as W, byteLength as le } from "./telemetry.js";
-const F = "snapshot", Q = "slice", ce = "error", ue = "close", B = 50, K = 3e5;
-let f = {}, R = B, N = K, O = H, Y = !0;
-function je(e, t) {
-  f = e ? { ...e } : {}, R = t?.coalesceMs ?? B, N = t?.idleMs ?? K, O = t?.heartbeatMs ?? H, Y = t?.logEmits ?? !0, X(), S.clear();
-}
-function Ae() {
-  return f;
-}
-function ke() {
-  return Object.keys(f);
-}
-const d = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map();
-function de(e, t, n) {
-  const o = D(e, t), r = b.get(o);
-  if (r) {
-    n && r.gestures.push(n);
+import { DEFAULT_HEARTBEAT_MS as se } from "./events.js";
+import { trace as F, byteLength as H, spanRecorder as ie } from "./telemetry.js";
+const X = "snapshot", ae = "slice", Se = "error", le = "close", ce = 50, ue = 3e5;
+let g = {}, Z = ce, L = ue, N = se, fe = !0;
+function Pe(e, t) {
+  g = e ? { ...e } : {}, Z = t?.coalesceMs ?? ce, L = t?.idleMs ?? ue, N = t?.heartbeatMs ?? se, fe = t?.logEmits ?? !0, de(), O.clear(), G.clear();
+}
+function qe() {
+  return g;
+}
+function ze() {
+  return Object.keys(g);
+}
+const S = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Map();
+function Ee(e, t, r) {
+  const n = ee(e, t), o = I.get(n);
+  if (o) {
+    r && o.gestures.push(r);
     return;
   }
   const s = {
     timer: void 0,
     channel: e,
     partition: t,
-    gestures: n ? [n] : []
-  }, i = setTimeout(() => {
-    b.delete(o), fe(s);
-  }, R), c = i.unref;
-  typeof c == "function" && c.call(i), s.timer = i, b.set(o, s);
-}
-async function fe(e) {
-  const t = W(), n = await te(e.channel, e.partition, t);
-  for (const o of e.gestures)
-    o.addSpans(t.spans), o.end({ status: "ok", connections: n });
-}
-function X() {
-  for (const e of b.values()) clearTimeout(e.timer);
-  b.clear();
-}
-function Ce() {
+    gestures: r ? [r] : []
+  }, a = setTimeout(() => {
+    I.delete(n), Ae(s);
+  }, Z), u = a.unref;
+  typeof u == "function" && u.call(a), s.timer = a, I.set(n, s);
+}
+async function Ae(e) {
+  const t = ie(), r = await ve(e.channel, e.partition, t);
+  for (const n of e.gestures)
+    n.addSpans(t.spans), n.end({ status: "ok", connections: r });
+}
+function de() {
+  for (const e of I.values()) clearTimeout(e.timer);
+  I.clear();
+}
+function Le() {
   const e = [];
   let t = 0;
-  for (const [o, r] of d) {
-    const s = [];
-    for (const [i, c] of r) {
-      const p = /* @__PURE__ */ new Map();
-      for (const a of c) {
-        const u = p.get(a.moduleId) ?? { count: 0, last: void 0 };
-        u.count += 1, a.lastDeliveryAt !== void 0 && (u.last === void 0 || a.lastDeliveryAt > u.last) && (u.last = a.lastDeliveryAt), p.set(a.moduleId, u);
+  const r = /* @__PURE__ */ new Map();
+  for (const [o, s] of S) {
+    const a = [];
+    for (const [u, v] of s) {
+      const l = /* @__PURE__ */ new Map();
+      for (const i of v) {
+        const f = l.get(i.moduleId) ?? { count: 0, last: void 0 };
+        if (f.count += 1, i.lastDeliveryAt !== void 0 && (f.last === void 0 || i.lastDeliveryAt > f.last) && (f.last = i.lastDeliveryAt), l.set(i.moduleId, f), i.kind === "live" && i.liveId) {
+          let h = r.get(i.liveId);
+          if (h || (h = {
+            moduleId: i.moduleId,
+            action: i.actionName ?? "(anonymous)",
+            channels: [],
+            args: i.args ? { ...i.args } : null,
+            lastDeliveryAt: null
+          }, r.set(i.liveId, h)), h.channels.push({ channel: o, partition: u }), i.lastDeliveryAt !== void 0) {
+            const w = new Date(i.lastDeliveryAt).toISOString();
+            (h.lastDeliveryAt === null || w > h.lastDeliveryAt) && (h.lastDeliveryAt = w);
+          }
+        } else i.kind !== "live" && (t += 1);
       }
-      for (const [a, u] of p)
-        s.push({
-          moduleId: a,
-          partition: i,
-          connections: u.count,
-          lastDeliveryAt: u.last === void 0 ? null : new Date(u.last).toISOString()
+      for (const [i, f] of l)
+        a.push({
+          moduleId: i,
+          partition: u,
+          connections: f.count,
+          lastDeliveryAt: f.last === void 0 ? null : new Date(f.last).toISOString()
         });
     }
     e.push({
       channel: o,
-      groups: s,
-      connections: U(r)
-    }), t += U(r);
+      groups: a,
+      connections: be(s)
+    });
   }
+  t += r.size;
   const n = [];
-  for (const o of b.values())
+  for (const o of I.values())
     n.push({ channel: o.channel, partition: o.partition });
-  return { channels: e, openCoalesceWindows: n, totalConnections: t };
+  return {
+    channels: e,
+    openCoalesceWindows: n,
+    liveActions: [...r.values()],
+    totalConnections: t
+  };
 }
-function U(e) {
+function be(e) {
   let t = 0;
-  for (const n of e.values()) t += n.size;
+  for (const r of e.values()) t += r.size;
   return t;
 }
-function D(e, t) {
+function ee(e, t) {
   return `${e}\0${t}`;
 }
 function pe(e) {
-  let t = d.get(e.channel);
-  t || (t = /* @__PURE__ */ new Map(), d.set(e.channel, t));
-  let n = t.get(e.partition);
-  n || (n = /* @__PURE__ */ new Set(), t.set(e.partition, n));
-  const o = n.size === 0;
-  return n.add(e), o;
-}
-function V(e) {
-  const t = d.get(e.channel), n = t?.get(e.partition);
-  if (!t || !n) return !1;
-  n.delete(e);
-  const o = n.size === 0;
-  return o && t.delete(e.partition), t.size === 0 && d.delete(e.channel), o;
-}
-function Z(e, t, n) {
-  const o = D(e, t), r = f[e]?.onGroupOpen, s = (async () => {
-    if (typeof r == "function")
+  let t = S.get(e.channel);
+  t || (t = /* @__PURE__ */ new Map(), S.set(e.channel, t));
+  let r = t.get(e.partition);
+  r || (r = /* @__PURE__ */ new Set(), t.set(e.partition, r));
+  const n = r.size === 0;
+  return r.add(e), n;
+}
+function ne(e) {
+  const t = S.get(e.channel), r = t?.get(e.partition);
+  if (!t || !r) return !1;
+  r.delete(e);
+  const n = r.size === 0;
+  return n && t.delete(e.partition), t.size === 0 && S.delete(e.channel), n;
+}
+const G = /* @__PURE__ */ new Map();
+function te(e, t, r) {
+  const n = ee(e, t), o = g[e]?.onGroupOpen;
+  G.set(n, r);
+  const s = (async () => {
+    if (typeof o == "function")
       try {
-        await r({ partition: t, params: n });
-      } catch (i) {
+        await o({ partition: t, params: r.params, args: r.args });
+      } catch (a) {
         console.error(
           `[velojs] channel "${e}" onGroupOpen failed for partition "${t}":`,
-          i
+          a
         );
       }
   })();
-  return S.set(o, s), s.then(() => {
-    S.get(o) === s && S.delete(o);
+  return O.set(n, s), s.then(() => {
+    O.get(n) === s && O.delete(n);
   }), s;
 }
-async function me(e) {
-  const t = D(e.channel, e.partition), n = S.get(t);
-  n && await n;
-  const o = d.get(e.channel)?.get(e.partition);
-  if (!o || !o.has(e) || o.size > 1) {
-    V(e);
+async function he(e) {
+  const t = ee(e.channel, e.partition), r = O.get(t);
+  r && await r;
+  const n = S.get(e.channel)?.get(e.partition);
+  if (!n || !n.has(e) || n.size > 1) {
+    ne(e);
     return;
   }
-  const r = f[e.channel]?.onGroupClose;
-  if (typeof r == "function")
+  const o = g[e.channel]?.onGroupClose, s = G.get(t) ?? { params: e.params };
+  if (typeof o == "function")
     try {
-      await r({ partition: e.partition });
-    } catch (c) {
+      await o({ partition: e.partition, args: s.args });
+    } catch (v) {
       console.error(
         `[velojs] channel "${e.channel}" onGroupClose failed for partition "${e.partition}":`,
-        c
+        v
       );
     }
-  V(e);
-  const s = d.get(e.channel)?.get(e.partition), i = s ? [...s][0] : void 0;
-  i && await Z(e.channel, e.partition, i.params);
+  ne(e);
+  const a = S.get(e.channel)?.get(e.partition), u = a ? [...a][0] : void 0;
+  u ? await te(e.channel, e.partition, {
+    params: u.params,
+    args: u.args
+  }) : G.delete(t);
 }
-function Te() {
-  d.clear(), S.clear(), X();
+function Ne() {
+  S.clear(), O.clear(), G.clear(), de();
 }
-async function T(e, t) {
-  const n = e.scope;
-  return typeof n != "function" ? "all" : await n(t);
+async function x(e, t) {
+  const r = e.scope;
+  return typeof r != "function" ? "all" : await r(t);
 }
-function he(e, t) {
+function ye(e, t) {
   return e.get(t);
 }
-async function ee(e, t) {
-  const n = d.get(e)?.get(t);
-  if (!n || n.size === 0) return null;
-  const o = f[e], r = [];
-  for (const s of [...n]) {
-    let i;
+async function me(e, t) {
+  const r = S.get(e)?.get(t);
+  if (!r || r.size === 0) return null;
+  const n = g[e], o = [];
+  for (const s of [...r]) {
+    let a;
     try {
-      i = await T(o, {
-        user: s.principal,
-        params: s.params
-      });
-    } catch (c) {
-      console.error(`[velojs] channel "${e}" scope threw on emit:`, c), i = null;
+      a = await x(n, je(s));
+    } catch (u) {
+      console.error(`[velojs] channel "${e}" scope threw on emit:`, u), a = null;
     }
-    if (i == null || i !== t) {
+    if (a == null || a !== t) {
       await s.terminate();
       continue;
     }
-    r.push(s);
+    o.push(s);
   }
-  return r.length > 0 ? r : null;
-}
-async function te(e, t, n) {
-  const o = await ee(e, t);
-  return o ? (await Promise.all(
-    o.map(async (r) => {
-      const s = n.span(`loader:${r.moduleId}`), i = await ne(r);
-      s.end(i);
+  return o.length > 0 ? o : null;
+}
+function je(e) {
+  return e.kind === "live" ? { user: e.principal, args: e.args } : { user: e.principal, params: e.params };
+}
+async function ve(e, t, r) {
+  const n = await me(e, t);
+  return n ? (await Promise.all(
+    n.map(async (o) => {
+      const s = r.span(ke(o)), a = await re(o);
+      s.end(a);
     })
-  ), o.length) : 0;
+  ), n.length) : 0;
 }
-async function ne(e) {
-  let t;
-  try {
-    t = await e.loader({
+function ke(e) {
+  return e.kind === "live" ? `action:${e.moduleId}/${e.actionName ?? "anonymous"}` : `loader:${e.moduleId}`;
+}
+async function Te(e) {
+  if (e.kind === "live") {
+    if (typeof e.action != "function")
+      throw new Error("[velojs] live action connection has no action");
+    return e.action({
+      body: e.args ?? {},
       params: e.params,
       query: e.query,
       c: e.c
     });
-  } catch (n) {
+  }
+  if (typeof e.loader != "function")
+    throw new Error("[velojs] channel connection has no loader");
+  return e.loader({ params: e.params, query: e.query, c: e.c });
+}
+async function re(e) {
+  let t;
+  try {
+    t = await Te(e);
+  } catch (r) {
     return await e.send(
-      ce,
+      Se,
       JSON.stringify({
-        message: n instanceof Error ? n.message : String(n)
+        message: r instanceof Error ? r.message : String(r)
       })
     ), "error";
   }
-  return t instanceof Response || await e.send(F, JSON.stringify(t ?? null)), "ok";
+  return t instanceof Response || await e.send(X, JSON.stringify(t ?? null)), "ok";
 }
-function _e(e, t, n, o) {
-  return typeof e == "string" ? ye(e, t ?? {}) : we(e, t, n, o);
+function Ge(e, t, r, n) {
+  return typeof e == "string" ? De(e, t ?? {}) : Ce(e, t, r, n);
 }
-async function ye(e, t) {
-  const n = f[e];
-  if (!n)
+async function De(e, t) {
+  const r = g[e];
+  if (!r)
     throw new Error(
       `[velojs] emit("${e}"): this channel has no entry in app/channels.ts. Add one — a typo or a renamed channel would otherwise be a silent no-op.`
     );
-  const o = await T(n, t), r = o == null ? 0 : d.get(e)?.get(o)?.size ?? 0;
-  oe(e, o, "invalidate", r);
-  const s = P("emit", {
+  const n = await x(r, t), o = n == null ? 0 : S.get(e)?.get(n)?.size ?? 0;
+  ge(e, n, "invalidate", o);
+  const s = F("emit", {
     channel: e,
-    partition: o ?? null,
+    partition: n ?? null,
     mode: "invalidate",
-    connections: r
+    connections: o
   });
-  if (o == null) {
+  if (n == null) {
     s.end({ status: "ok", connections: 0 });
     return;
   }
-  if (r === 0) {
+  if (o === 0) {
     s.end({ status: "ok", connections: 0 });
     return;
   }
-  if (R <= 0) {
-    const i = W(), c = await te(e, o, i);
-    s.addSpans(i.spans), s.end({ status: "ok", connections: c });
+  if (Z <= 0) {
+    const a = ie(), u = await ve(e, n, a);
+    s.addSpans(a.spans), s.end({ status: "ok", connections: u });
     return;
   }
-  de(e, o, s);
+  Ee(e, n, s);
 }
-async function we(e, t, n, o) {
-  const r = e?.metadata?.moduleId;
-  if (!r)
+async function Ce(e, t, r, n) {
+  const o = e?.metadata?.moduleId;
+  if (!o)
     throw new Error(
       `[velojs] emit(module, "${t}", …): the module has no metadata.moduleId — pass the imported route module (the Vite plugin injects its metadata), the same object the route tree uses.`
     );
   const s = e.channels;
   if (!Array.isArray(s) || !s.includes(t))
     throw new Error(
-      `[velojs] emit(module, "${t}", …): module "${r}" does not declare channel "${t}" — add it to the module's \`channels\` export, or use emit("${t}", ctx) for the invalidation mode.`
+      `[velojs] emit(module, "${t}", …): module "${o}" does not declare channel "${t}" — add it to the module's \`channels\` export, or use emit("${t}", ctx) for the invalidation mode.`
     );
   if (typeof e.loader != "function")
     throw new Error(
-      `[velojs] emit(module, "${t}", …): module "${r}" has no \`loader\` — there is no data shape to slice.`
+      `[velojs] emit(module, "${t}", …): module "${o}" has no \`loader\` — there is no data shape to slice.`
     );
-  const i = f[t];
-  if (!i)
+  const a = g[t];
+  if (!a)
     throw new Error(
       `[velojs] emit(module, "${t}", …): this channel has no entry in app/channels.ts. Add one — a typo or a renamed channel would otherwise be a silent no-op.`
     );
-  if (o === null || typeof o != "object" || Array.isArray(o))
+  if (n === null || typeof n != "object" || Array.isArray(n))
     throw new Error(
-      `[velojs] emit(module, "${t}", …): the slice must be the object of changed keys — got ${o === null ? "null" : Array.isArray(o) ? "an array" : typeof o}.`
+      `[velojs] emit(module, "${t}", …): the slice must be the object of changed keys — got ${n === null ? "null" : Array.isArray(n) ? "an array" : typeof n}.`
     );
-  const c = await T(i, n), p = c == null ? void 0 : d.get(t)?.get(c), a = p?.size ?? 0;
-  oe(t, c, "slice", a);
-  const u = P("emit", {
+  const u = await x(a, r), v = u == null ? void 0 : S.get(t)?.get(u), l = v?.size ?? 0;
+  ge(t, u, "slice", l);
+  const i = F("emit", {
     channel: t,
-    partition: c ?? null,
+    partition: u ?? null,
     mode: "slice",
-    connections: a
+    connections: l
   });
-  if (c == null) {
-    u.end({ status: "ok", connections: 0 });
+  if (u == null) {
+    i.end({ status: "ok", connections: 0 });
     return;
   }
-  if (!p || a === 0) {
-    u.end({ status: "ok", connections: 0 });
+  if (!v || l === 0) {
+    i.end({ status: "ok", connections: 0 });
     return;
   }
-  const m = await ee(t, c);
-  if (!m) {
-    u.end({ status: "ok", connections: 0 });
+  const f = await me(t, u);
+  if (!f) {
+    i.end({ status: "ok", connections: 0 });
     return;
   }
-  const y = m.filter((E) => E.moduleId === r);
-  if (y.length === 0) {
-    u.end({ status: "ok", connections: 0 });
+  const h = f.filter(
+    (E) => E.moduleId === o && E.kind !== "live"
+  );
+  if (h.length === 0) {
+    i.end({ status: "ok", connections: 0 });
     return;
   }
-  const j = JSON.stringify(o);
-  await Promise.all(y.map((E) => E.send(Q, j))), u.end({ status: "ok", connections: y.length });
+  const w = JSON.stringify(n);
+  await Promise.all(h.map((E) => E.send(ae, w))), i.end({ status: "ok", connections: h.length });
 }
-function oe(e, t, n, o) {
-  if (!Y) return;
-  const r = typeof t == "string" ? `"${t}"` : "null";
+function ge(e, t, r, n) {
+  if (!fe) return;
+  const o = typeof t == "string" ? `"${t}"` : "null";
   console.log(
-    `[velojs] emit kind=${n} channel="${e}" partition=${r} connections=${o} at=${(/* @__PURE__ */ new Date()).toISOString()}`
+    `[velojs] emit kind=${r} channel="${e}" partition=${o} connections=${n} at=${(/* @__PURE__ */ new Date()).toISOString()}`
   );
 }
-function ge(e, t) {
-  let n = Promise.resolve();
-  return (o) => (n = n.then(() => t(o)).then(() => {
-  }).catch((r) => {
+function we(e, t) {
+  let r = Promise.resolve();
+  return (n) => (r = r.then(() => t(n)).then(() => {
+  }).catch((o) => {
     console.warn(
       `[velojs] channel "${e}": SSE write failed — the snapshot did not reach the client:`,
-      r
+      o
     );
-  }), n);
+  }), r);
 }
-const C = "_route";
-function ve(e) {
+const W = "_route";
+function _e(e) {
   return e ? e.split("/").filter((t) => t.startsWith(":")).map((t) => t.slice(1)) : [];
 }
-function Ee(e, t) {
+function Oe(e, t) {
   if (e == null || e === "")
     return { params: {}, error: null };
-  let n;
+  let r;
   try {
-    n = JSON.parse(e);
+    r = JSON.parse(e);
   } catch {
-    return { params: {}, error: `the ?${C}= payload is not valid JSON` };
+    return { params: {}, error: `the ?${W}= payload is not valid JSON` };
   }
-  if (n === null || typeof n != "object" || Array.isArray(n))
+  if (r === null || typeof r != "object" || Array.isArray(r))
     return {
       params: {},
-      error: `the ?${C}= payload must be an object of route params`
+      error: `the ?${W}= payload must be an object of route params`
     };
-  const o = {};
-  for (const [r, s] of Object.entries(n)) {
-    if (!t.includes(r)) {
-      const i = t.length > 0 ? t.join(", ") : "none";
+  const n = {};
+  for (const [o, s] of Object.entries(r)) {
+    if (!t.includes(o)) {
+      const a = t.length > 0 ? t.join(", ") : "none";
       return {
         params: {},
-        error: `route param "${r}" is not declared by the module's path (declared: ${i})`
+        error: `route param "${o}" is not declared by the module's path (declared: ${a})`
       };
     }
     if (typeof s != "string")
-      return { params: {}, error: `route param "${r}" must be a URL string` };
-    o[r] = s;
+      return { params: {}, error: `route param "${o}" must be a URL string` };
+    n[o] = s;
   }
-  return { params: o, error: null };
+  return { params: n, error: null };
 }
-function Me(e, t, n, o, r, s) {
-  if (typeof o.loader != "function")
+function xe(e, t, r, n, o, s) {
+  if (typeof n.loader != "function")
     throw new Error(
-      `[velojs] module "${r}" declares \`channels\` without a \`loader\` — there is nothing to synchronize. Add a loader or remove the export.`
+      `[velojs] module "${o}" declares \`channels\` without a \`loader\` — there is nothing to synchronize. Add a loader or remove the export.`
     );
-  if (!f[n])
+  if (!g[r])
     throw new Error(
-      `[velojs] module "${r}" declares channel "${n}" with no entry in app/channels.ts — add the partition resolver for "${n}".`
+      `[velojs] module "${o}" declares channel "${r}" with no entry in app/channels.ts — add the partition resolver for "${r}".`
     );
-  const i = o.loader, c = ve(o.metadata?.fullPath), p = async (a) => {
-    const u = f[n], m = P("channel-connect", { route: t, module: r, channel: n }), y = Ee(
-      a.req.query(C),
-      c
+  const a = n.loader, u = _e(n.metadata?.fullPath), v = async (l) => {
+    const i = g[r], f = F("channel-connect", { route: t, module: o, channel: r }), h = Oe(
+      l.req.query(W),
+      u
     );
-    if (y.error)
-      return console.error(`[velojs] channel "${n}": rejecting subscription — ${y.error}`), m.end({ status: "error" }), a.json({ error: "invalid-route-params", message: y.error }, 400);
-    const j = y.params, E = he(a, "user");
-    let A;
+    if (h.error)
+      return console.error(`[velojs] channel "${r}": rejecting subscription — ${h.error}`), f.end({ status: "error" }), l.json({ error: "invalid-route-params", message: h.error }, 400);
+    const w = h.params, E = ye(l, "user");
+    let T;
     try {
-      A = await T(u, { user: E, params: j });
-    } catch (w) {
-      return console.error(`[velojs] channel "${n}" scope threw:`, w), m.end({ status: "error" }), a.json({ error: "forbidden" }, 403);
+      T = await x(i, { user: E, params: w });
+    } catch (p) {
+      return console.error(`[velojs] channel "${r}" scope threw:`, p), f.end({ status: "error" }), l.json({ error: "forbidden" }, 403);
     }
-    if (A == null)
-      return m.end({ status: "error" }), a.json({ error: "forbidden" }, 403);
-    const { streamSSE: re } = await import("hono/streaming"), I = {};
-    for (const [w, h] of Object.entries(a.req.query()))
-      w !== C && (I[w] = h);
-    const k = await re(a, async (w) => {
-      let h = !1, L = () => {
+    if (T == null)
+      return f.end({ status: "error" }), l.json({ error: "forbidden" }, 403);
+    const { streamSSE: Y } = await import("hono/streaming"), R = {};
+    for (const [p, y] of Object.entries(l.req.query()))
+      p !== W && (R[p] = y);
+    const b = await Y(l, async (p) => {
+      let y = !1, j = () => {
       };
-      const se = new Promise((l) => {
-        L = l;
-      }), _ = ge(
-        n,
-        (l) => typeof l == "string" ? w.write(l) : w.writeSSE(l)
-      ), g = {
-        channel: n,
-        partition: A,
-        moduleId: r,
+      const P = new Promise((d) => {
+        j = d;
+      }), D = we(
+        r,
+        (d) => typeof d == "string" ? p.write(d) : p.writeSSE(d)
+      ), A = {
+        channel: r,
+        partition: T,
+        moduleId: o,
         principal: E,
-        loader: i,
-        c: a,
-        params: j,
-        query: I,
-        telemetry: m,
-        send: (l, M) => h ? Promise.resolve() : l === F || l === Q ? (g.telemetry?.enabled && g.telemetry.delivery(le(M)), _({ event: l, data: M }).then(() => {
-          h || (g.lastDeliveryAt = Date.now(), x());
-        })) : _({ event: l, data: M }),
-        terminate: (l) => q(l)
-      }, G = () => {
-        h || (h = !0, v !== null && clearTimeout(v), $ !== null && clearInterval($), L(), g.telemetry?.close(), me(g));
-      }, q = async (l = "partition") => {
-        h || (await g.send(ue, JSON.stringify({ reason: l })), G());
-      };
-      let v = null;
-      const x = () => {
-        if (N <= 0 || h) return;
-        v !== null && clearTimeout(v), v = setTimeout(() => {
-          v = null, q("idle");
-        }, N);
-        const l = v.unref;
-        typeof l == "function" && l.call(v);
+        loader: a,
+        c: l,
+        params: w,
+        query: R,
+        telemetry: f,
+        send: (d, c) => y ? Promise.resolve() : d === X || d === ae ? (A.telemetry?.enabled && A.telemetry.delivery(H(c)), D({ event: d, data: c }).then(() => {
+          y || (A.lastDeliveryAt = Date.now(), z());
+        })) : D({ event: d, data: c }),
+        terminate: (d) => q(d)
+      }, C = () => {
+        y || (y = !0, $ !== null && clearTimeout($), m !== null && clearInterval(m), j(), A.telemetry?.close(), he(A));
+      }, q = async (d = "partition") => {
+        y || (await A.send(le, JSON.stringify({ reason: d })), C());
       };
       let $ = null;
-      O > 0 && ($ = setInterval(() => {
-        h || _(`: ping
+      const z = () => {
+        if (L <= 0 || y) return;
+        $ !== null && clearTimeout($), $ = setTimeout(() => {
+          $ = null, q("idle");
+        }, L);
+        const d = $.unref;
+        typeof d == "function" && d.call($);
+      };
+      let m = null;
+      N > 0 && (m = setInterval(() => {
+        y || D(`: ping
 
 `);
-      }, O));
-      const ie = pe(g);
-      if (w.onAbort(G), x(), $ !== null) {
-        const l = $.unref;
-        typeof l == "function" && l.call($);
+      }, N));
+      const J = pe(A);
+      if (p.onAbort(C), z(), m !== null) {
+        const d = m.unref;
+        typeof d == "function" && d.call(m);
       }
-      ie && await Z(n, A, j);
-      const ae = m.span("snapshot"), J = await ne(g);
-      ae.end(J), m.end({ status: J }), await se;
-    }), z = new Headers(k.headers);
-    return z.set("Cache-Control", "no-store"), new Response(k.body, {
-      status: k.status,
-      statusText: k.statusText,
-      headers: z
+      J && await te(r, T, { params: w });
+      const k = f.span("snapshot"), V = await re(A);
+      k.end(V), f.end({ status: V }), await P;
+    }), M = new Headers(b.headers);
+    return M.set("Cache-Control", "no-store"), new Response(b.body, {
+      status: b.status,
+      statusText: b.statusText,
+      headers: M
+    });
+  };
+  s.length > 0 ? e.on(["GET"], [t], ...s, v) : e.on(["GET"], [t], v);
+}
+const Q = "_args", K = 4096;
+function Ie(e) {
+  if (e == null || e === "")
+    return { args: {}, error: null };
+  let t;
+  try {
+    t = JSON.parse(e);
+  } catch {
+    return { args: {}, error: `the ?${Q}= payload is not valid JSON` };
+  }
+  return t === null || typeof t != "object" || Array.isArray(t) ? {
+    args: {},
+    error: `the ?${Q}= payload must be an object of the action's arguments`
+  } : { args: t, error: null };
+}
+let oe = 0;
+function Je(e, t, r, n, o, s, a) {
+  const u = o[`action_${r}`];
+  if (typeof u != "function")
+    throw new Error(
+      `[velojs] module "${s}" declares liveActions.${r} but has no \`export const action_${r}\` — there is nothing to synchronize. Add the action or remove the entry.`
+    );
+  for (const l of n)
+    if (!g[l])
+      throw new Error(
+        `[velojs] module "${s}" liveActions.${r} declares channel "${l}" with no entry in app/channels.ts — add the partition resolver for "${l}".`
+      );
+  const v = async (l) => {
+    const i = F("live-action-connect", { route: t, module: s, name: r }), f = Ie(l.req.query(Q));
+    if (f.error)
+      return console.error(
+        `[velojs] live action "${s}/${r}": rejecting subscription — ` + f.error
+      ), i.end({ status: "error" }), l.json({ error: "invalid-args", message: f.error }, 400);
+    const h = f.args, w = JSON.stringify(h);
+    if (H(w) > K) {
+      const p = `[velojs] live action "${s}/${r}": the serialized args are ${H(w)} bytes — the limit is ${K}. Pass less data (an id, not the document) — the args are the tab's address.`;
+      return console.error(p), i.end({ status: "error" }), l.json(
+        { error: "args-too-large", message: p, limit: K },
+        400
+      );
+    }
+    const E = ye(l, "user"), T = [];
+    for (const p of n) {
+      const y = g[p];
+      let j;
+      try {
+        j = await x(y, { user: E, args: h });
+      } catch (P) {
+        return console.error(`[velojs] channel "${p}" scope threw:`, P), i.end({ status: "error" }), l.json({ error: "forbidden" }, 403);
+      }
+      if (j == null)
+        return i.end({ status: "error" }), l.json({ error: "forbidden" }, 403);
+      T.push({ channel: p, partition: j });
+    }
+    const { streamSSE: Y } = await import("hono/streaming"), R = {};
+    for (const [p, y] of Object.entries(l.req.query()))
+      p !== Q && (R[p] = y);
+    const b = await Y(l, async (p) => {
+      let y = !1, j = () => {
+      };
+      const P = new Promise((c) => {
+        j = c;
+      }), D = we(
+        `${s}/${r}`,
+        (c) => typeof c == "string" ? p.write(c) : p.writeSSE(c)
+      );
+      oe += 1;
+      const A = `live-${oe}`, C = T.map(({ channel: c, partition: _ }) => ({
+        channel: c,
+        partition: _,
+        moduleId: s,
+        kind: "live",
+        principal: E,
+        action: u,
+        actionName: r,
+        args: h,
+        liveId: A,
+        c: l,
+        params: {},
+        query: R,
+        telemetry: i,
+        send: (U, B) => q(U, B),
+        terminate: (U) => z(U)
+      })), q = (c, _) => y ? Promise.resolve() : c === X ? (i.enabled && i.delivery(H(_)), D({ event: c, data: _ }).then(() => {
+        if (y) return;
+        const B = Date.now();
+        for (const $e of C) $e.lastDeliveryAt = B;
+        J();
+      })) : D({ event: c, data: _ }), $ = () => {
+        if (!y) {
+          y = !0, m !== null && clearTimeout(m), k !== null && clearInterval(k), j(), i.close();
+          for (const c of C) he(c);
+        }
+      }, z = async (c = "partition") => {
+        y || (await q(le, JSON.stringify({ reason: c })), $());
+      };
+      let m = null;
+      const J = () => {
+        if (L <= 0 || y) return;
+        m !== null && clearTimeout(m), m = setTimeout(() => {
+          m = null, z("idle");
+        }, L);
+        const c = m.unref;
+        typeof c == "function" && c.call(m);
+      };
+      let k = null;
+      if (N > 0 && (k = setInterval(() => {
+        y || D(`: ping
+
+`);
+      }, N)), p.onAbort($), J(), k !== null) {
+        const c = k.unref;
+        typeof c == "function" && c.call(k);
+      }
+      for (const c of C)
+        pe(c) && await te(c.channel, c.partition, {
+          params: {},
+          args: h
+        });
+      const V = i.span("snapshot"), d = await re(C[0]);
+      V.end(d), i.end({ status: d }), await P;
+    }), M = new Headers(b.headers);
+    return M.set("Cache-Control", "no-store"), new Response(b.body, {
+      status: b.status,
+      statusText: b.statusText,
+      headers: M
     });
   };
-  s.length > 0 ? e.on(["GET"], [t], ...s, p) : e.on(["GET"], [t], p);
+  a.length > 0 ? e.on(["GET"], [t], ...a, v) : e.on(["GET"], [t], v);
 }
 export {
-  ue as CHANNEL_CLOSE_EVENT,
-  ce as CHANNEL_ERROR_EVENT,
-  B as DEFAULT_COALESCE_MS,
-  K as DEFAULT_IDLE_MS,
-  C as ROUTE_PARAMS_QUERY,
-  Q as SLICE_EVENT,
-  F as SNAPSHOT_EVENT,
-  Te as __resetChannels,
-  ke as channelNames,
-  ge as createChannelWriteChain,
-  ve as declaredRouteParams,
-  _e as emit,
-  Ae as getChannelMap,
-  Ce as inspectChannels,
-  Ee as parseRouteParamsQuery,
-  ne as pushSnapshot,
-  Me as registerChannelRoute,
-  je as registerChannels
+  le as CHANNEL_CLOSE_EVENT,
+  Se as CHANNEL_ERROR_EVENT,
+  ce as DEFAULT_COALESCE_MS,
+  ue as DEFAULT_IDLE_MS,
+  K as LIVE_ARGS_MAX_BYTES,
+  Q as LIVE_ARGS_QUERY,
+  W as ROUTE_PARAMS_QUERY,
+  ae as SLICE_EVENT,
+  X as SNAPSHOT_EVENT,
+  Ne as __resetChannels,
+  ze as channelNames,
+  we as createChannelWriteChain,
+  _e as declaredRouteParams,
+  Ge as emit,
+  qe as getChannelMap,
+  Le as inspectChannels,
+  Ie as parseLiveArgsQuery,
+  Oe as parseRouteParamsQuery,
+  re as pushSnapshot,
+  xe as registerChannelRoute,
+  Pe as registerChannels,
+  Je as registerLiveActionRoute
 };