akanjs 3.0.0-beta.9 → 3.0.1

package/server/resolver/service.resolver.ts

@@ -1,103 +1,27 @@
-import type { PromiseOrObject } from "akanjs/base";
 import { capitalize } from "akanjs/common";
 import type { QueryOf } from "akanjs/constant";
-import {
-  assertFilterFitsCrud,
-  type CRUDEventType,
-  type DatabaseModel,
-  type DataInputOf,
-  type Doc,
-  type DocumentUpdateInput,
-  documentQueryHelper,
-  type FindQueryOption,
-  getFilterInfoByKey,
-  getFilterMeta,
-  type ListQueryOption,
-  type SaveEventType,
-  splitFilterArgs,
-  type UpdateChain,
-} from "akanjs/document";
-import type { DatabaseService, ServiceCls } from "akanjs/service";
+import type { DatabaseModel, DataInputOf, Doc, DocumentUpdateInput } from "akanjs/document";
+import { type DatabaseService, type ServiceCls, ServiceModel } from "akanjs/service";
 import type { CascadeRunner } from "./CascadeRunner";
+import { DatabaseResolver } from "./database.resolver";
 
 export class ServiceResolver {
   static #getDefaultDbServiceMethods(refName: string, className: string, cascade: CascadeRunner) {
-    const dbServiceMethods = {
-      async __get(this: DatabaseService, id: string) {
-        return await this.__databaseModel.__get(id);
-      },
-      async [`get${className}`](this: DatabaseService, id: string) {
-        return this.__get(id);
-      },
-      async __load(this: DatabaseService, id?: string) {
-        return await this.__databaseModel.__load(id);
-      },
-      async [`load${className}`](this: DatabaseService, id?: string) {
-        return this.__load(id);
-      },
-      async __loadMany(this: DatabaseService, ids: string[]) {
-        return await this.__databaseModel.__loadMany(ids);
-      },
-      async [`load${className}Many`](this: DatabaseService, ids: string[]) {
-        return this.__loadMany(ids);
-      },
-      async __list(this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption) {
-        return await this.__databaseModel.__list(query, queryOption);
-      },
-      async __listIds(this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption) {
-        return await this.__databaseModel.__listIds(query, queryOption);
-      },
-      async __find(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
-        return await this.__databaseModel.__find(query, queryOption);
-      },
-      async __findId(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
-        return await this.__databaseModel.__findId(query, queryOption);
-      },
-      async __pick(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
-        return await this.__databaseModel.__pick(query, queryOption);
-      },
-      async __pickId(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
-        return await this.__databaseModel.__pickId(query, queryOption);
-      },
-      async __exists(this: DatabaseService, query: QueryOf<any>) {
-        return await this.__databaseModel.__exists(query);
-      },
-      async __count(this: DatabaseService, query: QueryOf<any>) {
-        return await this.__databaseModel.__count(query);
-      },
-      async __insight(this: DatabaseService, query: QueryOf<any>) {
-        return await this.__databaseModel.__insight(query);
-      },
-      listenPre(
-        this: DatabaseService,
-        type: SaveEventType,
-        listener: (doc: Doc, type: CRUDEventType, previous?: Doc) => PromiseOrObject<void>,
-      ) {
-        return this.__databaseModel.listenPre(type, listener);
-      },
-      listenPost(
-        this: DatabaseService,
-        type: SaveEventType,
-        listener: (doc: Doc, type: CRUDEventType, previous?: Doc) => PromiseOrObject<void>,
-      ) {
-        return this.__databaseModel.listenPost(type, listener);
-      },
+    
+    const { _preCreate, _postCreate, _preUpdate, _postUpdate, _preRemove, _postRemove, ...methods } =
+      ServiceModel.getDefaultDbServiceMethods(className);
+    return {
+      ...methods,
       async __create(this: DatabaseService, data: DataInputOf) {
         const input = await this.__libsPreCreate(data);
         const doc = await this.__databaseModel.__create(input);
         return await this.__libsPostCreate(doc);
       },
-      async [`create${className}`](this: DatabaseService, data: DataInputOf) {
-        return this.__create(data);
-      },
       async __update(this: DatabaseService, id: string, data: DataInputOf) {
         const input = await this.__libsPreUpdate(id, data);
         const doc = await this.__databaseModel.__update(id, input);
         return await this.__libsPostUpdate(doc);
       },
-      async [`update${className}`](this: DatabaseService, id: string, data: DataInputOf) {
-        return this.__update(id, data);
-      },
       async __remove(this: DatabaseService, id: string): Promise<Doc> {
         await this.__libsPreRemove(id);
         const doc = await this.__databaseModel.__remove(id);
@@ -105,9 +29,6 @@ export class ServiceResolver {
         await cascade.run(refName, removed as Record<string, unknown>);
         return removed;
       },
-      async [`remove${className}`](this: DatabaseService, id: string): Promise<Doc> {
-        return this.__remove(id);
-      },
       async __removeMany(this: DatabaseService, query: QueryOf<any>) {
         return await this.__databaseModel.__removeMany(query);
       },
@@ -121,84 +42,11 @@ export class ServiceResolver {
         return await this.__databaseModel.__updateOne(query, update);
       },
     };
-    return dbServiceMethods;
   }
   static resolveDatabaseService(database: DatabaseModel, srvRef: ServiceCls, cascade: CascadeRunner): ServiceCls {
     const className = capitalize(database.refName);
     Object.assign(srvRef.prototype, ServiceResolver.#getDefaultDbServiceMethods(database.refName, className, cascade));
-    const getQueryDataFromKey = (queryKey: string, args: any): { query: any; queryOption: any } => {
-      const filterInfo = getFilterInfoByKey(database.filter, queryKey);
-      const queryFn = filterInfo.queryFn;
-      if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);
-      const { queryArgs, queryOption } = splitFilterArgs(filterInfo, args);
-      return { query: queryFn(...queryArgs, documentQueryHelper), queryOption };
-    };
-    const filterMeta = getFilterMeta(database.filter);
-    const queryKeys = Object.keys(filterMeta.query);
-    queryKeys.forEach((queryKey) => {
-      const filterInfo = getFilterInfoByKey(database.filter, queryKey);
-      const queryFn = filterInfo.queryFn;
-      if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);
-      const capitalizedQueryKey = capitalize(queryKey);
-      assertFilterFitsCrud(database.refName, queryKey, className);
-      Object.assign(srvRef.prototype, {
-        [`list${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return this.__list(query, queryOption);
-        },
-        [`listIds${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return this.__listIds(query, queryOption);
-        },
-        [`find${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return this.__find(query, queryOption);
-        },
-        [`findId${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return this.__findId(query, queryOption);
-        },
-        [`pick${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return this.__pick(query, queryOption);
-        },
-        [`pickId${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return this.__pickId(query, queryOption);
-        },
-        [`exists${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return this.__exists(query);
-        },
-        [`count${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return this.__count(query);
-        },
-        [`insight${capitalize(queryKey)}`]: async function (this: DatabaseService, ...args: any) {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return this.__insight(query);
-        },
-        [`query${capitalize(queryKey)}`]: function (this: DatabaseService, ...args: any) {
-          return queryFn(...splitFilterArgs(filterInfo, args).queryArgs, documentQueryHelper);
-        },
-        [`remove${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return this.__removeMany(query);
-        },
-        [`removeOne${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return this.__removeOne(query);
-        },
-        [`update${capitalizedQueryKey}`]: function (this: DatabaseService, ...args: any): UpdateChain {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return { set: (update) => this.__updateMany(query, update) };
-        },
-        [`updateOne${capitalizedQueryKey}`]: function (this: DatabaseService, ...args: any): UpdateChain {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return { set: (update) => this.__updateOne(query, update) };
-        },
-      });
-    });
+    DatabaseResolver.applyFilterMethods(srvRef.prototype, database, className);
     return srvRef;
   }
 }

package/server/resolver/signal.resolver.ts

@@ -5,6 +5,7 @@ import {
   type Cls,
   ENDPOINT_META,
   FIELD_META,
+  Float,
   getEnv,
   ID,
   INTERNAL_META,
@@ -14,16 +15,19 @@ import {
   SLICE_META,
 } from "akanjs/base";
 import { capitalize, cookieHeaderHasAuthToken, Logger } from "akanjs/common";
-import { deserialize, resolvePageLimit, resolvePageSkip, serialize } from "akanjs/constant";
+import { type ConstantField, deserialize, resolvePageLimit, resolvePageSkip, serialize } from "akanjs/constant";
 import { baseDocumentColumns, documentQueryHelper, getFilterSortByKey, type QueryFieldMap } from "akanjs/document";
 import {
   type AkanJob,
   type AkanJobOptions,
+  type DocumentStore,
   type InjectRegistry,
+  type LiveChange,
   type LiveRegistry,
   type WebsocketAdaptor,
   WebsocketAdaptorRole,
 } from "akanjs/service";
+import { websocketRoomContract } from "../../common/websocketContract";
 import { type Endpoint, type EndpointCls, sliceEndpoint } from "../../signal/endpoint";
 import type { EndpointInfo } from "../../signal/endpointInfo";
 import type { Internal, InternalCls } from "../../signal/internal";
@@ -42,20 +46,25 @@ import type {
 } from "../../signal/types";
 import type { HttpRoutes, LocalPublish, SignalRoutes, WebsocketRoutes } from "../types";
 
-type HttpRouteHandler = (req: Bun.BunRequest) => Response | Promise<Response | undefined> | undefined;
 type LiveChangeListener = (doc: unknown, type: unknown, previous?: unknown) => void;
-type HttpMethodRoutes = Record<string, HttpRouteHandler>;
+type LiveRoute = (next: Record<string, unknown>, previous?: Record<string, unknown>) => Promise<LiveDelivery[]>;
+interface LiveDelivery {
+  roomId: string;
+  payload: LiveEventPayload;
+}
+type HttpMethodRoutes = Record<string, (req: Bun.BunRequest) => Response | Promise<Response | undefined> | undefined>;
 
 export class SignalResolver {
   static logger = new Logger("SignalResolver");
 
   static makeRoomId(key: string, args: unknown[]) {
-    return `${key}${args.length ? "-" : ""}${args.join("-")}`;
+    return websocketRoomContract.idOf(key, args);
   }
   static #localPublish: LocalPublish = () => {
     SignalResolver.logger.verbose(`Local publish is not initialized yet`);
   };
   static readonly #coalescingRooms = new Set<string>();
+  static readonly #liveRoutes = new Map<string, { store: DocumentStore; route: LiveRoute }>();
 
   static coalescesRoom(roomId: string): boolean {
     const separator = roomId.indexOf("-");
@@ -64,13 +73,26 @@ export class SignalResolver {
   static setLocalPublish(localPublish: LocalPublish, websocket: WebsocketAdaptor, live?: LiveRegistry) {
     SignalResolver.#localPublish = localPublish;
     websocket.setEventHandler((roomId, data) => localPublish(roomId, data as object | object[] | Uint8Array));
-
+    
     websocket.onRecovered?.(() => {
       for (const roomId of live?.syncHub.roomIds() ?? []) {
         const payload: LiveEventPayload = { op: "invalidate", id: "" };
         localPublish(roomId, payload);
       }
     });
+    websocket.onChange?.((change) => {
+      void SignalResolver.#routeChange(change, live).catch((error: unknown) =>
+        SignalResolver.logger.warn(`Live routing failed for ${change.refName}: ${String(error)}`),
+      );
+    });
+  }
+  static async #routeChange({ refName, next, previous }: LiveChange, live?: LiveRegistry) {
+    const target = SignalResolver.#liveRoutes.get(refName);
+    if (!target || !live?.syncHub.roomCountOf(refName)) return;
+    await target.route(
+      target.store.deserialize(next) as Record<string, unknown>,
+      previous ? (target.store.deserialize(previous) as Record<string, unknown>) : undefined,
+    );
   }
   static resolveServerSignal(
     serverSignalCls: ServerSignalCls,
@@ -81,7 +103,6 @@ export class SignalResolver {
     const websocket = SignalResolver.#getWebsocket(registry);
     Object.entries(endpointMeta).forEach(([key, endpointInfo]) => {
       if (endpointInfo.type !== "pubsub") throw new Error(`Endpoint ${key} is not a pubsub endpoint`);
-      websocket.registerEndpoint(key, endpointInfo.returns.returnRef as Cls, endpointInfo.returns.arrDepth);
       const isBinaryFrame = endpointInfo.returns.returnRef === Binary && !endpointInfo.returns.arrDepth;
       if (isBinaryFrame && endpointInfo.signalOption.backpressure !== "queue") SignalResolver.#coalescingRooms.add(key);
       let warnedRawBytes = false;
@@ -103,7 +124,7 @@ export class SignalResolver {
           const roomId = SignalResolver.makeRoomId(key, roomArgs);
           if (isBinaryFrame) {
             const bytes = Binary._parse(resolvedData as Uint8Array) as Uint8Array;
-            websocket.publish(roomId, bytes);
+            websocket.publish(roomId, bytes, { coalesce: SignalResolver.coalescesRoom(roomId) });
             SignalResolver.#localPublish(roomId, bytes);
             return;
           }
@@ -134,14 +155,7 @@ export class SignalResolver {
     });
     return serverSignalCls;
   }
-  /**
-   * Attaches the change listeners that feed live rooms, once per model that declares a `.live()` slice.
-   *
-   * Only the document write paths reach here. A query-level write — `updateManyByQuery`, the generated
-   * `update<Filter>` / `remove<Filter>`, `updateById` / `removeById` — is one atomic statement that fires no
-   * document hooks at all, exactly as it fires no cascade, so a model whose fields move that way will not push
-   * those moves to a live list. It is the same blind spot cascade has and it cannot be closed from here.
-   */
+
   static registerLiveSync(
     sliceCls: SliceCls,
     { registry, live }: { registry: InjectRegistry; live: LiveRegistry },
@@ -155,18 +169,20 @@ export class SignalResolver {
       .map(([key]) => `${refName}Live${capitalize(key)}`);
     if (!liveKeys.length) return [];
     const service = live.service.get(refName) as
-      | { listenPost: (type: "create" | "update" | "remove", listener: LiveChangeListener) => unknown }
+      | {
+          listenPost: (type: "create" | "update" | "remove", listener: LiveChangeListener) => unknown;
+          __databaseModel: { __store: DocumentStore };
+        }
       | undefined;
     if (!service) throw new Error(`Live slice on "${refName}" has no service to listen to`);
+    const store = service.__databaseModel.__store;
     const websocket = SignalResolver.#getWebsocket(registry);
-
-    for (const liveKey of liveKeys) websocket.registerEndpoint(liveKey, Any, 0);
-    const publish = async (next: Record<string, unknown>, previous?: Record<string, unknown>) => {
+    const route: LiveRoute = async (next, previous) => {
       const targets = live.syncHub.route(refName, next, previous);
-      if (!targets.length) return;
+      if (!targets.length) return [];
       const id = String(next.id);
       const needsLight = targets.some((target) => !target.invalidate && target.payload === "light");
-
+      
       const light = needsLight
         ? ((await SignalContext.resolveReturn(next, {
             signalContext: null,
@@ -177,15 +193,26 @@ export class SignalResolver {
           })) as object)
         : null;
       const lightData = light ? (serialize(cnst.light, 0, light, "object", {}) as object | null) : null;
-      for (const target of targets) {
+      return targets.map((target) => {
         const payload: LiveEventPayload = target.invalidate
           ? { op: "invalidate", id }
           : { op: target.op, id, light: target.payload === "light" ? lightData : null };
-        websocket.publish(target.roomId, payload);
         SignalResolver.#localPublish(target.roomId, payload);
-      }
+        return { roomId: target.roomId, payload };
+      });
     };
-
+    SignalResolver.#liveRoutes.set(refName, { store, route });
+    const publish = async (next: Record<string, unknown>, previous?: Record<string, unknown>) => {
+      websocket.publishChange?.({
+        refName,
+        next: store.serialize(next),
+        previous: previous ? store.serialize(previous) : undefined,
+      });
+      const delivered = await route(next, previous);
+      
+      if (!websocket.publishChange) for (const { roomId, payload } of delivered) websocket.publish(roomId, payload);
+    };
+    
     const listener: LiveChangeListener = (doc, _type, previous) => {
       void publish(doc as Record<string, unknown>, previous as Record<string, unknown> | undefined).catch(
         (error: unknown) => SignalResolver.logger.warn(`Live publish failed for ${refName}: ${String(error)}`),
@@ -208,7 +235,7 @@ export class SignalResolver {
         case "process": {
           if (!internalInfo.execFn) throw new Error(`Exec function is not set for ${key}`);
           const execFn = internalInfo.execFn.bind(internal);
-
+          
           internal.queue.registerProcessWorker(
             key,
             SignalResolver.#traced(
@@ -222,6 +249,7 @@ export class SignalResolver {
           internal.schedule.registerInit(
             key,
             SignalResolver.#traced(key, () => internalInfo.execFn?.bind(internal)()),
+            { once: internalInfo.signalOption.once },
           );
           break;
         case "destroy":
@@ -262,15 +290,11 @@ export class SignalResolver {
       }
     });
   }
-  /**
-   * Every run of an internal is one `internal:<key>` trace, so the handler's own logs carry a traceId. The
-   * schedule adaptor's started/finished/error lines wrap this call from outside and stay uncorrelated.
-   */
   static #traced<A extends unknown[], R>(key: string, fn: (...args: A) => R) {
     return async (...args: A) =>
       await runTraced(SignalTrace.create(key, "internal", "internal"), async () => await fn(...args));
   }
-  /** Why an internal is not scheduled on this server, or null when it is. `placement` marks a deliberate role split. */
+  
   static getScheduleSkipReason(
     internalInfo: InternalInfo,
     serverMode: "federation" | "batch" | "all",
@@ -290,10 +314,6 @@ export class SignalResolver {
     return null;
   }
 
-  /**
-   * A `process` producer is installed on every server regardless of placement, so a skipped worker means this
-   * server can enqueue jobs that nothing here consumes. Surface that asymmetry instead of failing silently.
-   */
   static #warnMissingProcessWorker(
     key: string,
     internalInfo: InternalInfo,
@@ -305,7 +325,6 @@ export class SignalResolver {
     else SignalResolver.logger.warn(message);
   }
 
-  /** Maps a job payload back onto the internal's declared `msg` args, deserializing each to its declared type. */
   static #getJobArgs(key: string, internalInfo: InternalInfo, job: AkanJob): unknown[] {
     const data = Array.isArray(job.data) ? (job.data as unknown[]) : job.data === undefined ? [] : [job.data];
     return internalInfo.args.map((arg, idx) =>
@@ -376,7 +395,7 @@ export class SignalResolver {
           SignalResolver.#assertLiveSort(refName, key, sliceInfo);
           SignalResolver.#assertLivePauseOn(refName, key, sliceInfo);
           const liveKey = `${refName}Live${capitalizedKey}`;
-
+          
           const liveBuilder = (builder as any).pubsub(Any, {
             ...sliceInfo.signalOption,
             mcp: false,
@@ -457,16 +476,11 @@ export class SignalResolver {
     }) {}
     return SliceEndpoint;
   }
-  /**
-   * The three things about a declared live sort that can be known without a request.
-   *
-   * A client places a new row itself only for a sort it can reproduce, so a sort key naming a field the row does
-   * not carry produces a list that is quietly in the wrong order — the one failure mode with no symptom. The
-   * `_doc` case is a warning rather than a refusal because it is the slice author's call: the two dialects order
-   * a JSON field differently from each other, so there is no single server answer to match.
-   */
+
+  static readonly #clientOrderableTypes = new Set<unknown>([Int, Float, String, ID, Boolean, Date]);
   static #assertLiveSort(refName: string, key: string, sliceInfo: SliceInfo) {
-    const lightFields = (sliceInfo.light as unknown as { [FIELD_META]?: Record<string, unknown> })[FIELD_META] ?? {};
+    const lightFields =
+      (sliceInfo.light as unknown as { [FIELD_META]?: Record<string, ConstantField> })[FIELD_META] ?? {};
     for (const sortKey of sliceInfo.liveOption?.sort ?? []) {
       const sort = getFilterSortByKey(sliceInfo.filter, sortKey);
       if (!sort)
@@ -478,14 +492,16 @@ export class SignalResolver {
             `Live slice "${refName}.${key}" declares sort "${sortKey}" on "${path}", which is not in ` +
               `Light${capitalize(refName)}. A subscriber cannot order by a field it never receives.`,
           );
+        const { modelRef, isArray, isMap } = lightFields[path].getProps();
+        if (!isArray && !isMap && SignalResolver.#clientOrderableTypes.has(modelRef)) continue;
         SignalResolver.logger.warn(
-          `Live slice "${refName}.${key}" sorts by "${path}", which is stored inside the document rather than in a ` +
-            `column. SQLite and Postgres order those differently, so a client placing a row may disagree with the server.`,
+          `Live slice "${refName}.${key}" sorts "${sortKey}" by "${path}", which is not an Int, Float, String, ID, ` +
+            `Boolean or Date field, so a client placing a new row may disagree with the server. Sort by one of ` +
+            `those, or leave "${sortKey}" out of .live({ sort }) so the list refetches when a row arrives.`,
         );
       }
     }
   }
-  /** Refuses a subscribe carrying an argument the slice named in `pauseOn`, naming the argument it refused on. */
   static #assertNotPaused(
     key: string,
     liveOption: LiveEndpointOption,
@@ -501,13 +517,6 @@ export class SignalResolver {
       );
     }
   }
-  /**
-   * That every argument `pauseOn` names is one this slice has, and one that can actually be empty.
-   *
-   * A name that is not an argument would do nothing at all, and a `param` — which is never nullable, so it is
-   * present on every call — would switch the room off for good rather than while a box is filled. Both are the
-   * kind of mistake whose only symptom is a list that never updates, so neither is allowed to boot.
-   */
   static #assertLivePauseOn(refName: string, key: string, sliceInfo: SliceInfo) {
     for (const name of sliceInfo.liveOption?.pauseOn ?? []) {
       const arg = sliceInfo.args.find((candidate) => candidate.name === name);
@@ -523,10 +532,7 @@ export class SignalResolver {
         );
     }
   }
-  /**
-   * The model's field metadata, which membership routing reads for one thing: whether a path is an array, because
-   * a bare value on an array field means membership rather than equality.
-   */
+  
   static #queryFieldsOf(live: LiveRegistry, refName: string): QueryFieldMap {
     const sliceCls = live.sliceCls.get(refName);
     const doc = sliceCls?.srv.db?.doc as { [FIELD_META]?: QueryFieldMap } | undefined;
@@ -536,11 +542,7 @@ export class SignalResolver {
     Bun.ServerWebSocket<unknown>,
     Map<string, SignalContext<WebSocketExecutionContext>>
   >();
-  /**
-   * Message contexts that registered a lifecycle handler. A message context is otherwise dropped the moment it
-   * answers, so `ws.on("disconnect", …)` from one would land in an object nothing reads again — a silent
-   * no-op beside the same call working from a pubsub subscribe.
-   */
+  
   static #liveWsMessageCtx = new WeakMap<Bun.ServerWebSocket<unknown>, Set<SignalContext<WebSocketExecutionContext>>>();
   static #retainWsContext(ws: Bun.ServerWebSocket<unknown>, context: SignalContext<WebSocketExecutionContext>) {
     const wsCtx = context.getWebSocketContext();
@@ -549,13 +551,7 @@ export class SignalResolver {
     contexts.add(context);
     SignalResolver.#liveWsMessageCtx.set(ws, contexts);
   }
-  /**
-   * Cleanup handlers belong to the app, so one that throws must not take the rest of the teardown with it: a
-   * rejection here would skip `unregisterSocket` and leak the socket's room membership in Redis for good.
-   *
-   * A close ends both the subscription and the connection, so it passes both events — and a handler registered
-   * for both, the way a cleanup that must happen either way is written, runs once rather than twice.
-   */
+
   static async #runLifecycleHandlers(
     contexts: Iterable<SignalContext<WebSocketExecutionContext>>,
     events: ("unsubscribe" | "disconnect")[],
@@ -572,11 +568,7 @@ export class SignalResolver {
       if (result.status === "rejected")
         SignalResolver.logger.error(`WebSocket cleanup handler failed: ${result.reason}`);
   }
-  /**
-   * A path may legitimately carry several methods — a `query` GET and a `mutation` POST sharing a custom `path` —
-   * so methods merge rather than replace. The same method twice leaves one of the two endpoints unreachable with
-   * nothing said about it, and the shadowed half is as easily the guarded one, so it fails the boot instead.
-   */
+  
   static #mountHttpRoute(routes: HttpRoutes, path: string, handlers: HttpMethodRoutes, owner?: string) {
     const table = routes as Record<string, HttpMethodRoutes | undefined>;
     const existing = table[path];
@@ -588,7 +580,6 @@ export class SignalResolver {
     table[path] = { ...existing, ...handlers };
   }
 
-  /** Same rule across endpoint classes, which are resolved one at a time and then folded into one table. */
   static mergeHttpRoutes(target: HttpRoutes, source: HttpRoutes) {
     for (const [path, handlers] of Object.entries((source ?? {}) as Record<string, HttpMethodRoutes>))
       SignalResolver.#mountHttpRoute(target, path, handlers);
@@ -610,8 +601,7 @@ export class SignalResolver {
     const wsRoutes: WebsocketRoutes = {};
     const defaultPrefix = endpointCls.srv.cnst?.refName;
     Object.entries(endpointMeta).forEach(([key, endpointInfo]) => {
-      const servicePrefix = SignalResolver.#resolveServicePrefix(endpointInfo.signalOption.prefix, defaultPrefix);
-      const path = `${servicePrefix}${endpointInfo.getPath(key)}`;
+      const path = endpointInfo.getRoutePath(key, defaultPrefix);
       if (endpointInfo.signalOption.globalPrefix !== undefined) {
         routeOptions[path] = { globalPrefix: endpointInfo.signalOption.globalPrefix };
       }
@@ -625,7 +615,7 @@ export class SignalResolver {
             live,
             middleware,
           }).init();
-
+          
           return (await context.exec()) as Response | undefined;
         });
       if (endpointInfo.signalOption.method && endpointInfo.type !== "mutation")
@@ -640,8 +630,9 @@ export class SignalResolver {
             SignalResolver.#canUsePrimitiveQueryFastPath(endpointInfo, middleware)
               ? {
                   GET: async (req) => {
-                    if (SignalResolver.#hasAuthCredential(req)) return await normalHttpHandler(req);
-
+                    if (req.headers.get("authorization") || cookieHeaderHasAuthToken(req.headers.get("cookie")))
+                      return await normalHttpHandler(req);
+                    
                     return await SignalContext.try(
                       endpoint,
                       endpointInfo,
@@ -679,14 +670,15 @@ export class SignalResolver {
               ).init();
               const subscribe = event === "subscribe";
               const liveOption = endpointInfo.signalOption.live;
-
+              
               const requestRoomId = context.getRoomId(key);
               if (subscribe) {
-
+                
                 if (liveOption) SignalResolver.#assertNotPaused(key, liveOption, endpointInfo, context);
                 const query = await context.exec();
                 const roomId = liveOption ? context.getLiveRoomId(key) : requestRoomId;
-                if (liveOption)
+                const roomCtxMap = SignalResolver.#liveWsPubsubRoomCtx.get(ws) ?? new Map();
+                if (liveOption && !roomCtxMap.has(roomId))
                   live.syncHub.join({
                     refName: liveOption.refName,
                     roomId,
@@ -695,10 +687,8 @@ export class SignalResolver {
                     fields: SignalResolver.#queryFieldsOf(live, liveOption.refName),
                   });
                 ws.subscribe(roomId);
-                const roomCtxMap = SignalResolver.#liveWsPubsubRoomCtx.get(ws) ?? new Map();
                 roomCtxMap.set(roomId, context);
                 SignalResolver.#liveWsPubsubRoomCtx.set(ws, roomCtxMap);
-                
                 websocket.joinRoom(ws, roomId);
                 SignalResolver.logger.verbose(`WebSocket subscribed to room ${roomId}`);
                 const ack: WebsocketSubscribeAck = { type: "sub", roomId, requestRoomId, subscribe };
@@ -708,13 +698,12 @@ export class SignalResolver {
               const roomId = liveOption ? context.getLiveRoomId(key) : requestRoomId;
               ws.unsubscribe(roomId);
               const roomCtxMap = SignalResolver.#liveWsPubsubRoomCtx.get(ws);
-              if (roomCtxMap) {
-                const roomCtx = roomCtxMap.get(roomId);
-                if (roomCtx) await SignalResolver.#runLifecycleHandlers([roomCtx], ["unsubscribe"]);
+              const roomCtx = roomCtxMap?.get(roomId);
+              if (roomCtxMap && roomCtx) {
+                await SignalResolver.#runLifecycleHandlers([roomCtx], ["unsubscribe"]);
                 roomCtxMap.delete(roomId);
                 if (roomCtxMap.size === 0) SignalResolver.#liveWsPubsubRoomCtx.delete(ws);
                 if (liveOption) live.syncHub.leave(roomId);
-                
                 websocket.leaveRoom(ws, roomId);
                 SignalResolver.logger.verbose(`WebSocket unsubscribed from room ${roomId}`);
               }
@@ -744,14 +733,6 @@ export class SignalResolver {
     return { routes, wsRoutes, routeOptions };
   }
 
-  static #resolveServicePrefix(prefix: false | string | undefined, defaultPrefix?: string): string {
-    if (prefix === false || prefix === "") return "";
-    const resolved = prefix ?? defaultPrefix;
-    if (!resolved) return "";
-    const trimmed = resolved.trim().replace(/^\/+|\/+$/g, "");
-    return trimmed ? `/${trimmed}` : "";
-  }
-
   static #selectCache = new WeakMap<Cls, Record<string, true>>();
   static #selectForConstant(constant: Cls): Record<string, true> | undefined {
     const cached = SignalResolver.#selectCache.get(constant);
@@ -776,15 +757,6 @@ export class SignalResolver {
     );
   }
 
-  static #hasAuthCredential(req: Request) {
-    return Boolean(req.headers.get("authorization") || cookieHeaderHasAuthToken(req.headers.get("cookie")));
-  }
-
-  /**
-   * Re-checks the guards of every room this socket is subscribed to and drops the ones that no
-   * longer pass. Called when the socket's credential changes: a pubsub room is authorized once at
-   * subscribe time, so without this a signed-out socket would keep receiving its old rooms.
-   */
   static async revalidateWsRooms(
     ws: Bun.ServerWebSocket<any>,
     registry: InjectRegistry,
@@ -816,7 +788,7 @@ export class SignalResolver {
     const roomCtxMap = SignalResolver.#liveWsPubsubRoomCtx.get(ws);
     const contexts = [...(roomCtxMap?.values() ?? []), ...(SignalResolver.#liveWsMessageCtx.get(ws) ?? [])];
     await SignalResolver.#runLifecycleHandlers(contexts, ["unsubscribe", "disconnect"]);
-
+    
     for (const roomId of roomCtxMap?.keys() ?? []) live?.syncHub.leave(roomId);
     SignalResolver.#liveWsPubsubRoomCtx.delete(ws);
     SignalResolver.#liveWsMessageCtx.delete(ws);