@ignex/nova 0.1.6 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ignex/nova",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "type": "module",
   "description": "TypeBox-driven FlatBuffer transport: Rust FFI serializer + Bun WebSocket + typed pub/sub API for server and FE.",
   "license": "MIT",

package/public/events.ts

@@ -38,6 +38,7 @@ export {
   emitToGroup,
   emitToTopic,
   emitToUser,
+  emitToUserAnywhere,
   getEventsHub,
   isEventsBound,
   off,

package/src/events/emit.ts

@@ -146,7 +146,13 @@ export function createEmitter(opts: EmitterOptions): EmitEngine {
       if (cluster) {
         const msgId = crypto.randomUUID();
         const traceId = parentTraceId ?? "";
-        if (opts.routeInstances !== undefined && (target.type === "client" || target.type === "user")) {
+        // `user … anywhere: true` forces the full-mesh wildcard publish instead
+        // of presence routing — the user is reached on EVERY instance/service in
+        // the mesh, regardless of where presence thinks they are.
+        const routeable =
+          target.type === "client" ||
+          (target.type === "user" && target.anywhere !== true);
+        if (opts.routeInstances !== undefined && routeable) {
           // ROUTED targeted delivery: only the owning instances receive it
           const instances = opts.routeInstances(target);
           if (instances !== null) {

package/src/events/global.ts

@@ -68,6 +68,18 @@ export function emitToUser<K extends EventName>(userId: string, name: K, payload
   requireHub().emitToUser(userId, name as never, payload as never);
 }
 
+/**
+ * Deliver to the user on EVERY instance/service in the cluster mesh (full
+ * mesh, no presence routing) — reaches the user wherever they are connected.
+ */
+export function emitToUserAnywhere<K extends EventName>(
+  userId: string,
+  name: K,
+  payload: Events[K],
+): void {
+  requireHub().emitToUserAnywhere(userId, name as never, payload as never);
+}
+
 export function emitToClient<K extends EventName>(
   clientId: string,
   name: K,

package/src/events/hub/context-factory.ts

@@ -38,6 +38,8 @@ export function createContextFactory<B extends Bindings>(deps: {
       emit: (name, payload, target) => hub.emit(name as never, payload as never, target),
       emitToGroup: (group, name, payload) => hub.emitToGroup(group, name as never, payload as never),
       emitToUser: (userId, name, payload) => hub.emitToUser(userId, name as never, payload as never),
+      emitToUserAnywhere: (userId, name, payload) =>
+        hub.emitToUserAnywhere(userId, name as never, payload as never),
       emitToClient: (clientId, name, payload) =>
         hub.emitToClient(clientId, name as never, payload as never),
       emitToTopic: (topic, name, payload) => hub.emitToTopic(topic, name as never, payload as never),

package/src/events/hub/index.ts

@@ -364,6 +364,14 @@ export function createEventsHub<B extends Bindings = DefaultBindings>(
     emitToUser(userId, name, payload) {
       api.emit(name, payload, { type: "user", userId });
     },
+    /**
+     * Deliver to the user on EVERY instance/service in the cluster mesh — an
+     * explicit full-mesh emit (no presence routing). Use when the user may be
+     * connected to any service sharing the cluster transport.
+     */
+    emitToUserAnywhere(userId, name, payload) {
+      api.emit(name, payload, { type: "user", userId, anywhere: true });
+    },
     emitToClient(clientId, name, payload) {
       api.emit(name, payload, { type: "client", clientId });
     },

package/src/events/index.ts

@@ -23,6 +23,7 @@ export {
   emitToGroup,
   emitToTopic,
   emitToUser,
+  emitToUserAnywhere,
   getEventsHub,
   isEventsBound,
   off,

package/src/events/types/context.ts

@@ -33,6 +33,8 @@ export interface EventContext<B extends Bindings = DefaultBindings> {
   emit<K extends EventNameOf<B>>(name: K, payload: EventsOf<B>[K], target?: EmitTarget): void;
   emitToGroup<K extends EventNameOf<B>>(group: string, name: K, payload: EventsOf<B>[K]): void;
   emitToUser<K extends EventNameOf<B>>(userId: string, name: K, payload: EventsOf<B>[K]): void;
+  /** Deliver to the user on every instance/service in the cluster mesh. */
+  emitToUserAnywhere<K extends EventNameOf<B>>(userId: string, name: K, payload: EventsOf<B>[K]): void;
   emitToClient<K extends EventNameOf<B>>(clientId: string, name: K, payload: EventsOf<B>[K]): void;
   emitToTopic<K extends EventNameOf<B>>(topic: string, name: K, payload: EventsOf<B>[K]): void;
 }

package/src/events/types/emit-target.ts

@@ -13,6 +13,9 @@
  *   - `{ type: "topic", topic }` — subscribers of a topic (rooms + replay).
  *   - `{ type: "group", group }` — members of a server-side group.
  *   - `{ type: "user", userId }` — every socket acting on behalf of `userId`.
+ *   - `{ type: "user", userId, anywhere: true }` — same, but ALWAYS fanned out
+ *     to every instance/service in the cluster mesh (ignores presence routing), so
+ *     the user is reached no matter which instance holds their socket.
  *   - `{ type: "client", clientId }` — one specific connection.
  *
  * Local delivery is synchronous and allocation-free (the transport scratch +
@@ -23,7 +26,7 @@ export type EmitTarget =
   | { type: "broadcast" }
   | { type: "topic"; topic: string }
   | { type: "group"; group: string }
-  | { type: "user"; userId: string }
+  | { type: "user"; userId: string; anywhere?: true }
   | { type: "client"; clientId: string };
 
 export type EmitTargetKind = EmitTarget["type"];

package/src/events/types/hub.ts

@@ -45,6 +45,11 @@ export interface EventsHub<B extends Bindings = DefaultBindings> {
   emitToTopic<K extends EventNameOf<B>>(topic: string, name: K, payload: EventsOf<B>[K]): void;
   emitToGroup<K extends EventNameOf<B>>(group: string, name: K, payload: EventsOf<B>[K]): void;
   emitToUser<K extends EventNameOf<B>>(userId: string, name: K, payload: EventsOf<B>[K]): void;
+  /**
+   * Deliver to the user on EVERY instance/service in the cluster mesh (full
+   * mesh, no presence routing) — reaches the user wherever they are.
+   */
+  emitToUserAnywhere<K extends EventNameOf<B>>(userId: string, name: K, payload: EventsOf<B>[K]): void;
   emitToClient<K extends EventNameOf<B>>(clientId: string, name: K, payload: EventsOf<B>[K]): void;
 
   // ── client records ("who is connected, on whose behalf") ──────────────