akanjs 3.1.1 → 3.1.2-rc.0

package/server/ops/statusAccess.ts

@@ -1,58 +1,76 @@
 import { createHash, timingSafeEqual } from "node:crypto";
 import { bearerTokenOf, Logger } from "akanjs/common";
+import { isLocalDevRuntime } from "../../signal/trace";
+import { FailureLimiter } from "./failureLimiter";
 
 interface StatusAccessOptions {
   tokens: (string | null | undefined)[];
   open?: boolean;
+  failuresPerMinute?: number;
 }
 
 export class StatusAccess {
+  static readonly minTokenLength = 32;
   static readonly #noStore = { "cache-control": "no-store" };
   static readonly #warned = new Set<string>();
   readonly #digests: Buffer[];
   readonly #open: boolean;
+  readonly #failures: FailureLimiter;
 
-  constructor({ tokens, open = false }: StatusAccessOptions) {
-    this.#digests = tokens.filter((token): token is string => !!token).map((token) => StatusAccess.#digest(token));
+  constructor({ tokens, open = false, failuresPerMinute = 10 }: StatusAccessOptions) {
+    this.#digests = tokens.filter((token): token is string => !!token).map((token) => StatusAccess.digest(token));
     this.#open = open;
+    this.#failures = new FailureLimiter({ limit: failuresPerMinute });
   }
 
   static fromEnv(): StatusAccess {
     return new StatusAccess({
-      tokens: [StatusAccess.#tokenOf("AKAN_STATUS_TOKEN"), StatusAccess.#tokenOf("AKAN_LOG_STREAM_TOKEN")],
-      open: process.env.AKAN_PUBLIC_ENV === "local",
+      tokens: [StatusAccess.tokenOf("AKAN_STATUS_TOKEN"), StatusAccess.tokenOf("AKAN_LOG_STREAM_TOKEN")],
+      open: isLocalDevRuntime(),
     });
   }
 
-  static #tokenOf(name: string): string | null {
+  static tokenOf(name: string): string | null {
     const token = process.env[name]?.trim();
     if (!token) return null;
-    if (!/\s/.test(token)) return token;
-    if (!StatusAccess.#warned.has(name))
-      new Logger("StatusAccess").warn(`${name} must be one word, with no whitespace; it does not unlock status detail`);
-    StatusAccess.#warned.add(name);
-    return null;
+    if (/\s/.test(token)) {
+      StatusAccess.#warnOnce(`${name} must be one word, with no whitespace; it unlocks nothing`);
+      return null;
+    }
+    if (token.length < StatusAccess.minTokenLength)
+      StatusAccess.#warnOnce(
+        `${name} is shorter than ${StatusAccess.minTokenLength} characters, short enough to guess; use a random one`,
+      );
+    return token;
   }
 
-  static #digest(token: string): Buffer {
+  static #warnOnce(message: string) {
+    if (StatusAccess.#warned.has(message)) return;
+    StatusAccess.#warned.add(message);
+    new Logger("StatusAccess").warn(message);
+  }
+
+  static digest(token: string): Buffer {
     return createHash("sha256").update(token).digest();
   }
 
-  allows(req: Request): boolean {
+  allows(req: Request, client?: string | null): boolean {
     if (this.#open) return true;
     const token = bearerTokenOf(req.headers.get("authorization"));
-    if (!token) return false;
-    const presented = StatusAccess.#digest(token);
-    return this.#digests.reduce((matched, digest) => timingSafeEqual(presented, digest) || matched, false);
+    if (!token || this.#failures.blocked(client)) return false;
+    const presented = StatusAccess.digest(token);
+    const matched = this.#digests.reduce((matched, digest) => timingSafeEqual(presented, digest) || matched, false);
+    if (!matched) this.#failures.fail(client);
+    return matched;
   }
 
-  health(req: Request, detail: () => { status: string }): Response {
+  health(req: Request, detail: () => { status: string }, client?: string | null): Response {
     const body = detail();
-    return Response.json(this.allows(req) ? body : { status: body.status }, { headers: StatusAccess.#noStore });
+    return Response.json(this.allows(req, client) ? body : { status: body.status }, { headers: StatusAccess.#noStore });
   }
 
-  metrics(req: Request, detail: () => unknown): Response {
-    if (!this.allows(req))
+  metrics(req: Request, detail: () => unknown, client?: string | null): Response {
+    if (!this.allows(req, client))
       return new Response("Unauthorized", { status: 401, headers: { "www-authenticate": "Bearer" } });
     return Response.json(detail(), { headers: StatusAccess.#noStore });
   }

package/server/proxy/hostBasePathWebProxy.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { getEnv } from "akanjs/base";
-import { Logger, resolveSubRouteHosts } from "akanjs/common";
+import { LocalePath, Logger, parseAkanI18nEnv, resolveSubRouteHosts } from "akanjs/common";
 import type { BaseBuildArtifact } from "../types";
 import { AkanResponse, type WebProxy } from "./types";
 
@@ -29,11 +29,8 @@ export class HostBasePathWebProxy implements WebProxy {
 
     if (firstPath === basePath) {
       if (isInternalProxyRequest(requestUrl)) return AkanResponse.next({ request: { headers } });
-      const publicPath = `/${[locale, ...segments.slice(3)].filter(Boolean).join("/")}`;
-      return Response.redirect(
-        new URL(`${publicPath || `/${locale}`}${targetUrl.search}`, getPublicRequestUrl(request)),
-        308,
-      );
+      const publicPath = LocalePath.join(locale, `/${segments.slice(3).filter(Boolean).join("/")}`, parseAkanI18nEnv());
+      return Response.redirect(new URL(`${publicPath}${targetUrl.search}`, getPublicRequestUrl(request)), 308);
     }
 
     const internalPath = `/${[locale, basePath, ...segments.slice(2)].filter(Boolean).join("/")}`;
@@ -114,7 +111,7 @@ function getProxyTargetUrl(requestUrl: URL): URL {
   return target ? new URL(target, requestUrl.origin) : new URL(requestUrl);
 }
 
-function toProxyRequestUrl(requestUrl: URL, targetUrl: URL): URL {
+export function toProxyRequestUrl(requestUrl: URL, targetUrl: URL): URL {
   if (!isInternalProxyRequest(requestUrl)) return targetUrl;
   const rewritten = new URL(requestUrl);
   rewritten.searchParams.set("url", `${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`);

package/server/proxy/localeWebProxy.ts

@@ -1,6 +1,6 @@
 import { getApiPrefix } from "akanjs/base";
-import { parseAkanI18nEnv } from "akanjs/common";
-import { getPublicRequestUrl, isInternalProxyRequest } from "./hostBasePathWebProxy";
+import { LocalePath, parseAkanI18nEnv } from "akanjs/common";
+import { getPublicRequestUrl, isInternalProxyRequest, toProxyRequestUrl } from "./hostBasePathWebProxy";
 import { AkanResponse, type WebProxy } from "./types";
 
 function getLocale(request: Bun.BunRequest): string {
@@ -46,39 +46,59 @@ export class LocaleWebProxy implements WebProxy {
 
     const targetUrl = getProxyTargetUrl(requestUrl);
     const pathname = targetUrl.pathname;
-    const pathnameIsMissingLocale = i18n.locales.every(
-      (locale) => !pathname.startsWith(`/${locale}/`) && pathname !== `/${locale}`,
-    );
+    const isInternal = isInternalProxyRequest(requestUrl);
+    const isPage = !isInternal && !isWellKnownRequest(pathname) && !isApiRequest(pathname);
+    const { locale, path, isPrefixed } = LocalePath.split(pathname, i18n);
 
-    if (
-      !isInternalProxyRequest(requestUrl) &&
-      !isWellKnownRequest(pathname) &&
-      !isApiRequest(pathname) &&
-      pathnameIsMissingLocale
-    ) {
+    if (isPage && !locale) {
       return Response.redirect(
         new URL(`/${getLocale(request)}/${pathname.slice(1)}${targetUrl.search}`, getPublicRequestUrl(request)),
         307,
       );
     }
 
-    const splits = pathname.split("/");
-    const [, locale = i18n.defaultLocale] = splits;
-    const headers = new Headers(request.headers);
+    if (isPage && locale && LocalePath.omits(locale, i18n)) {
+      const publicUrl = getPublicRequestUrl(request);
+      if (isCsrRequest(targetUrl) && !isPrefixed)
+        return Response.redirect(onOrigin(publicUrl, `/${locale}${pathname}`, targetUrl.search), 307);
+      
+      if (!isCsrRequest(targetUrl) && isPrefixed)
+        return new Response(null, {
+          status: 308,
+          headers: { location: onOrigin(publicUrl, path, targetUrl.search).href, "cache-control": "max-age=86400" },
+        });
+    }
 
-    headers.set("x-locale", i18n.locales.includes(locale) ? locale : i18n.defaultLocale);
-    headers.set("x-path", `/${splits.slice(2).join("/")}`);
+    const headers = new Headers(request.headers);
+    headers.set("x-locale", locale ?? i18n.defaultLocale);
+    headers.set("x-path", path);
 
+    if (locale && !isPrefixed && (isPage || isInternal)) {
+      const localizedUrl = new URL(targetUrl);
+      localizedUrl.pathname = `/${locale}${pathname}`;
+      return AkanResponse.rewrite(toProxyRequestUrl(requestUrl, localizedUrl), { request: { headers } });
+    }
     return AkanResponse.next({ request: { headers } });
   }
 }
 
+function onOrigin(publicUrl: URL, pathname: string, search: string): URL {
+  const location = new URL(publicUrl);
+  location.pathname = pathname;
+  location.search = search;
+  return location;
+}
+
 function getProxyTargetUrl(requestUrl: URL): URL {
   if (!isInternalProxyRequest(requestUrl)) return requestUrl;
   const target = requestUrl.searchParams.get("url");
   return target ? new URL(target, requestUrl.origin) : requestUrl;
 }
 
+function isCsrRequest(url: URL): boolean {
+  return url.searchParams.get("csr") === "true";
+}
+
 function isWellKnownRequest(pathname: string): boolean {
   return pathname === "/.well-known" || pathname.startsWith("/.well-known/");
 }

package/server/resolver/database.resolver.ts

@@ -1,5 +1,5 @@
 import type { PromiseOrObject } from "akanjs/base";
-import { applyMixins, capitalize } from "akanjs/common";
+import { applyMixins, capitalize, modelNames } from "akanjs/common";
 import { type ConstantModel, type QueryOf, resolvePageLimit, resolvePageSkip } from "akanjs/constant";
 import {
   assertFilterFitsCrud,
@@ -65,6 +65,7 @@ export class DatabaseResolver {
     database: DatabaseModel,
   ): { adaptor: AdaptorCls<DatabaseInstance>; schema: DocumentSchema } {
     const [modelName, className]: [string, string] = [database.refName, capitalize(database.refName)];
+    const names = modelNames(modelName);
 
     const resolveSort = (sortKey?: string | null): { [key: string]: 1 | -1 } | null => {
       if (!sortKey) return null;
@@ -133,10 +134,10 @@ export class DatabaseResolver {
     const listenPreHook = listen("pre");
     const listenPostHook = listen("post");
 
-    class DatabaseModelInstance extends adapt(`${modelName}Model`, ({ plug }) => ({
+    class DatabaseModelInstance extends adapt(names.modelModel, ({ plug }) => ({
       __database: plug(DatabaseAdaptorRole, (database) => database),
       __cache: plug(CacheAdaptorRole, (cache) => new CacheDatabase(modelName, cache)),
-      [`${modelName}Cache` as never]: plug(CacheAdaptorRole, (cache) => new CacheDatabase(modelName, cache)),
+      [names.modelCache as never]: plug(CacheAdaptorRole, (cache) => new CacheDatabase(modelName, cache)),
     })) {
       declare readonly __database: DatabaseAdaptor;
       __store!: DocumentStore;
@@ -154,11 +155,11 @@ export class DatabaseResolver {
             const byId = new Map(docs.map((doc) => [String(doc.id), doc]));
             return ids.map((id) => byId.get(String(id)) ?? null);
           },
-          { name: `${modelName}Loader`, cache: false },
+          { name: names.modelLoader, cache: false },
         );
         Object.assign(this, {
           [className]: this.__model,
-          [`${modelName}Loader`]: this.__loader,
+          [names.modelLoader]: this.__loader,
         });
         Object.entries(getLoaderInfos(database.model)).forEach(([key, loaderInfo]) => {
           Object.assign(this, {
@@ -373,19 +374,19 @@ export class DatabaseResolver {
         if (!doc) throw new NoDocumentError(`No Document (${database.refName}): ${id}`);
         return doc;
       }
-      async [`get${className}`](id: string) {
+      async [names.getModel](id: string) {
         return this.__get(id);
       }
       async __load(id?: string) {
         return (id ? await this.__loader.load(id) : null) as unknown;
       }
-      async [`load${className}`](id?: string) {
+      async [names.loadModel](id?: string) {
         return this.__load(id);
       }
       async __loadMany(ids: string[]) {
         return await this.__loader.loadMany(ids);
       }
-      async [`load${className}Many`](ids: string[]) {
+      async [names.loadModelMany](ids: string[]) {
         return this.__loadMany(ids);
       }
       async clone(data: DataInputOf<any, any> & { id: string }) {
@@ -394,13 +395,16 @@ export class DatabaseResolver {
       async __create(data: DataInputOf<any, any>) {
         return await timedQuery(() => this.__store.create(data));
       }
-      async [`create${className}`](data: DataInputOf<any, any>) {
+      async [names.createModel](data: DataInputOf<any, any>) {
         return this.__create(data);
       }
+      async __createMany(data: DataInputOf<any, any>[]) {
+        return await timedQuery(() => this.__store.createMany(data));
+      }
       async __update(id: string, data: DataInputOf<any, any>) {
         return await timedQuery(() => this.__store.update(id, data));
       }
-      async [`update${className}`](id: string, data: DataInputOf<any, any>) {
+      async [names.updateModel](id: string, data: DataInputOf<any, any>) {
         return this.__update(id, data);
       }
       async __remove(id: string) {
@@ -421,7 +425,7 @@ export class DatabaseResolver {
       async __updateOne(query: QueryOf<any>, update: DocumentUpdateInput, options?: DocumentTouchOptions) {
         return await timedQuery(() => this.__store.updateOneByQuery(query, update, ...touchArgs(options)));
       }
-      async [`remove${className}`](id: string) {
+      async [names.removeModel](id: string) {
         return this.__remove(id);
       }
     }

package/server/resolver/service.resolver.ts

@@ -1,4 +1,4 @@
-import { capitalize } from "akanjs/common";
+import { capitalize, modelNames } from "akanjs/common";
 import type { QueryOf } from "akanjs/constant";
 import type { DatabaseModel, DataInputOf, Doc, DocumentTouchOptions, DocumentUpdateInput } from "akanjs/document";
 import { type DatabaseService, type ServiceCls, ServiceModel } from "akanjs/service";
@@ -17,6 +17,15 @@ export class ServiceResolver {
         const doc = await this.__databaseModel.__create(input);
         return await this.__libsPostCreate(doc);
       },
+      async __createMany(this: DatabaseService, data: DataInputOf[]) {
+        if (!data.length) return [];
+        const inputs: DataInputOf[] = [];
+        for (const row of data) inputs.push(await this.__libsPreCreate(row));
+        const created: Doc[] = [];
+        for (const doc of await this.__databaseModel.__createMany(inputs))
+          created.push(await this.__libsPostCreate(doc));
+        return created;
+      },
       async __update(this: DatabaseService, id: string, data: DataInputOf) {
         const input = await this.__libsPreUpdate(id, data);
         const doc = await this.__databaseModel.__update(id, input);
@@ -56,7 +65,13 @@ export class ServiceResolver {
   }
   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 createMany = modelNames(database.refName).createModelMany;
+    const methods = Object.entries(ServiceResolver.#getDefaultDbServiceMethods(database.refName, className, cascade));
+    Object.assign(
+      srvRef.prototype,
+      Object.fromEntries(methods.filter(([key]) => key !== createMany || !(key in srvRef.prototype))),
+    );
     DatabaseResolver.applyFilterMethods(srvRef.prototype, database, className);
     return srvRef;
   }

package/server/resolver/signal.resolver.ts

@@ -13,7 +13,7 @@ import {
   type PromiseOrObject,
   SLICE_META,
 } from "akanjs/base";
-import { capitalize, Logger } from "akanjs/common";
+import { capitalize, Logger, modelNames, moduleNames, sliceNames } from "akanjs/common";
 import {
   type ConstantField,
   deserialize,
@@ -35,7 +35,6 @@ import {
   type WebsocketAdaptor,
   WebsocketAdaptorRole,
 } from "akanjs/service";
-import { websocketRoomContract } from "../../common/websocketContract";
 import { type Endpoint, type EndpointCls, sliceEndpoint } from "../../signal/endpoint";
 import { EndpointErrorContract } from "../../signal/endpointErrorContract";
 import type { EndpointInfo } from "../../signal/endpointInfo";
@@ -43,6 +42,7 @@ import type { Internal, InternalCls } from "../../signal/internal";
 import { Machine } from "../../signal/internalArg";
 import type { InternalInfo } from "../../signal/internalInfo";
 import type { MiddlewareCls } from "../../signal/middleware";
+import { RoomKey } from "../../signal/roomKey";
 import type { ServerSignal, ServerSignalCls } from "../../signal/serverSignal";
 import { SignalContext, type WebSocketExecutionContext } from "../../signal/signalContext";
 import type { SliceCls } from "../../signal/slice";
@@ -70,9 +70,6 @@ type HttpMethodRoutes = Record<string, (req: Bun.BunRequest) => Response | Promi
 export class SignalResolver {
   static logger = new Logger("SignalResolver");
 
-  static makeRoomId(key: string, args: unknown[]) {
-    return websocketRoomContract.idOf(key, args);
-  }
   static #localPublish: LocalPublish = () => {
     SignalResolver.logger.verbose(`Local publish is not initialized yet`);
   };
@@ -143,7 +140,7 @@ export class SignalResolver {
             registry,
             live,
           });
-          const roomId = SignalResolver.makeRoomId(key, roomArgs);
+          const roomId = RoomKey.idOfPublished(key, endpointInfo.args, roomArgs);
           if (isBinaryFrame) {
             const bytes = Binary._parse(resolvedData as Uint8Array) as Uint8Array;
             websocket.publish(roomId, bytes, { coalesce: SignalResolver.coalescesRoom(roomId) });
@@ -197,7 +194,7 @@ export class SignalResolver {
     const refName = cnst.refName;
     const liveKeys = Object.entries(sliceMeta)
       .filter(([, sliceInfo]) => sliceInfo.liveOption && sliceInfo.execFn)
-      .map(([key]) => `${refName}Live${capitalize(key)}`);
+      .map(([key]) => sliceNames(refName, key).endpoint.live);
     if (!liveKeys.length) return [];
     const service = live.service.get(refName) as
       | {
@@ -387,8 +384,8 @@ export class SignalResolver {
     const cnst = sliceCls.srv.cnst;
     if (!cnst) throw new Error("Constant is not set for slice");
     const refName = cnst.refName;
-    const serviceName = `${refName}Service`;
-    const capitalizedRefName = capitalize(refName);
+    const serviceName = moduleNames(refName).service;
+    const names = modelNames(refName);
 
     const assertSliceQuery = (query: unknown, key: string) => {
       if (Array.isArray(query))
@@ -404,10 +401,10 @@ export class SignalResolver {
       const endpointObj: { [key: string]: EndpointInfo } = {};
       Object.entries(sliceMeta).forEach(([key, sliceInfo]) => {
         if (!sliceInfo.execFn) return;
-        const capitalizedKey = capitalize(key);
+        const { slice: sliceName, endpoint: namesOfSlice } = sliceNames(refName, key);
         const argLength = sliceInfo.args.length;
 
-        const listKey = `${refName}List${capitalizedKey}`;
+        const listKey = namesOfSlice.list;
         endpointObj[listKey] = (builder as any)
           .query([sliceInfo.light], sliceInfo.signalOption)
           ._addArgs(sliceInfo.args)
@@ -418,11 +415,7 @@ export class SignalResolver {
           .exec(async function (this: any, ...requestArgs: any) {
             const args = requestArgs.slice(0, argLength);
             const skip = resolvePageSkip(requestArgs[argLength]);
-            const limit = SignalResolver.#clientPageLimit(
-              listKey,
-              `${capitalizedRefName}${capitalizedKey}`,
-              requestArgs[argLength + 1],
-            );
+            const limit = SignalResolver.#clientPageLimit(listKey, capitalize(sliceName), requestArgs[argLength + 1]);
             const sort = requestArgs[argLength + 2] ?? "latest";
             const internalArgs = requestArgs.slice(argLength + 3);
             const query = assertSliceQuery(
@@ -445,7 +438,7 @@ export class SignalResolver {
             );
           SignalResolver.#assertLiveSort(refName, key, sliceInfo);
           SignalResolver.#assertLivePauseOn(refName, key, sliceInfo);
-          const liveKey = `${refName}Live${capitalizedKey}`;
+          const liveKey = namesOfSlice.live;
           
           const liveBuilder = (builder as any).pubsub(Any, {
             ...sliceInfo.signalOption,
@@ -474,7 +467,7 @@ export class SignalResolver {
             });
         }
 
-        const insightKey = `${refName}Insight${capitalizedKey}`;
+        const insightKey = namesOfSlice.insight;
         endpointObj[insightKey] = (builder as any)
           .query(sliceInfo.insight, sliceInfo.signalOption)
           ._addArgs(sliceInfo.args)
@@ -491,23 +484,23 @@ export class SignalResolver {
       });
 
       if (sliceCls.crud.get) {
-        endpointObj[refName] = (builder as any)
+        endpointObj[names.model] = (builder as any)
           .query(cnst.full, { guards: sliceCls.getGuards })
-          .param(`${refName}Id`, ID)
+          .param(names.modelId, ID)
           .exec(async function (this: any, id: string) {
-            return await this[serviceName][`get${capitalizedRefName}`](id);
+            return await this[serviceName][names.getModel](id);
           });
 
-        endpointObj[`light${capitalizedRefName}`] = (builder as any)
+        endpointObj[names.lightModel] = (builder as any)
           .query(cnst.light, { guards: sliceCls.getGuards })
-          .param(`${refName}Id`, ID)
+          .param(names.modelId, ID)
           .exec(async function (this: any, id: string) {
-            return await this[serviceName][`get${capitalizedRefName}`](id);
+            return await this[serviceName][names.getModel](id);
           });
       }
 
       if (sliceCls.crud.create)
-        endpointObj[`create${capitalizedRefName}`] = (builder as any)
+        endpointObj[names.createModel] = (builder as any)
           .mutation(cnst.full, { guards: sliceCls.createGuards })
           .body("data", cnst.input)
           .exec(async function (this: any, data: any) {
@@ -515,18 +508,18 @@ export class SignalResolver {
           });
 
       if (sliceCls.crud.update)
-        endpointObj[`update${capitalizedRefName}`] = (builder as any)
+        endpointObj[names.updateModel] = (builder as any)
           .mutation(cnst.full, { guards: sliceCls.updateGuards })
-          .param(`${refName}Id`, ID)
+          .param(names.modelId, ID)
           .body("data", cnst.input)
           .exec(async function (this: any, id: string, data: any) {
             return await this[serviceName].__update(id, data);
           });
 
       if (sliceCls.crud.remove)
-        endpointObj[`remove${capitalizedRefName}`] = (builder as any)
+        endpointObj[names.removeModel] = (builder as any)
           .mutation(cnst.full, { guards: sliceCls.removeGuards })
-          .param(`${refName}Id`, ID)
+          .param(names.modelId, ID)
           .exec(async function (this: any, id: string) {
             return await this[serviceName].__remove(id);
           });
@@ -658,7 +651,7 @@ export class SignalResolver {
     const routeOptions: NonNullable<SignalRoutes["routeOptions"]> = {};
     const wsRoutes: WebsocketRoutes = {};
     const defaultPrefix = endpointCls.srv.cnst?.refName;
-    SignalResolver.#warnUnguarded(endpointMeta);
+    SignalResolver.#checkUnguarded(endpointMeta);
     SignalResolver.#warnMachineKeyless(endpointMeta);
     SignalResolver.#warnUndefinedErrors(endpointMeta);
     Object.entries(endpointMeta).forEach(([key, endpointInfo]) => {
@@ -711,11 +704,12 @@ export class SignalResolver {
                 
                 const query = subscribe ? await context.exec() : null;
                 
-                const requestRoomId = context.getRoomId(key);
+                const requestRoomId = context.getRequestRoomId(key);
+                const baseRoomId = context.getRoomId(key);
                 if (subscribe) {
                   const isClosed = SignalResolver.#closedWs.has(ws);
                   
-                  if (isClosed || SignalResolver.#pendingSubscribes.isLeft(ws, requestRoomId, arrival)) {
+                  if (isClosed || SignalResolver.#pendingSubscribes.isLeft(ws, baseRoomId, arrival)) {
                     await SignalResolver.#runLifecycleHandlers(
                       [context as SignalContext<WebSocketExecutionContext>],
                       isClosed ? ["unsubscribe", "disconnect"] : ["unsubscribe"],
@@ -729,7 +723,7 @@ export class SignalResolver {
                     };
                     return unsubscribed;
                   }
-                  const roomId = liveOption ? context.getLiveRoomId(key) : requestRoomId;
+                  const roomId = liveOption ? context.getLiveRoomId(key, query) : baseRoomId;
                   const roomCtxMap = SignalResolver.#liveWsPubsubRoomCtx.get(ws) ?? new Map();
                   if (liveOption && !roomCtxMap.has(roomId))
                     live.syncHub.join({
@@ -763,10 +757,10 @@ export class SignalResolver {
                   };
                   return ack;
                 }
-                SignalResolver.#pendingSubscribes.leave(ws, requestRoomId, arrival);
+                SignalResolver.#pendingSubscribes.leave(ws, baseRoomId, arrival);
                 
                 const heldRooms = [...(SignalResolver.#liveWsPubsubRoomCtx.get(ws) ?? [])].filter(
-                  ([, roomCtx]) => roomCtx.getRoomId(roomCtx.key) === requestRoomId,
+                  ([, roomCtx]) => roomCtx.getRoomId(roomCtx.key) === baseRoomId,
                 );
                 for (const [roomId, roomCtx] of heldRooms) {
                   SignalResolver.#leaveWsRoom(ws, roomId, roomCtx, websocket, liveOption ? live : undefined);
@@ -807,15 +801,31 @@ export class SignalResolver {
     return { routes, wsRoutes, routeOptions };
   }
 
-  static #warnUnguarded(endpointMeta: { [key: string]: EndpointInfo }) {
-    const open = Object.entries(endpointMeta)
+  static #checkUnguarded(endpointMeta: { [key: string]: EndpointInfo }) {
+    const unguarded = Object.entries(endpointMeta)
       .filter(([, endpointInfo]) => !endpointInfo.signalOption.guards?.length)
       .map(([key]) => key);
-    if (!open.length) return;
-    SignalResolver.logger.warn(
-      `${open.join(", ")} declare${open.length === 1 ? "s" : ""} no guards, so anyone can call ${open.length === 1 ? "it" : "them"} over HTTP and WebSocket. Name the guards, or \`guards: [Public]\` to keep one open on purpose.`,
+    if (!unguarded.length) return;
+    const names = `${unguarded.join(", ")} declare${unguarded.length === 1 ? "s" : ""} no guards`;
+    const fix = "Name the guards, or `guards: [Public]` to open one on purpose.";
+    if (SignalContext.unguardedOpen()) {
+      SignalResolver.logger.warn(`${names}, and AKAN_UNGUARDED_ENDPOINTS=open lets anyone call them. ${fix}`);
+      return;
+    }
+    if (SignalResolver.#isLocalOperation()) {
+      SignalResolver.logger.warn(`${names}, so every call to them is refused. ${fix}`);
+      return;
+    }
+    throw new Error(
+      `${names}, so every call to them would be refused. ${fix} AKAN_UNGUARDED_ENDPOINTS=open answers them as before.`,
     );
   }
+  
+  static #isLocalOperation() {
+    if (process.env.NODE_ENV === "test") return true;
+    const environment = process.env.AKAN_PUBLIC_ENV ?? "debug";
+    return (process.env.AKAN_PUBLIC_OPERATION_MODE ?? (environment === "local" ? "local" : "cloud")) === "local";
+  }
 
   static #warnUndefinedErrors(endpointMeta: { [key: string]: EndpointInfo }) {
     const declared = Object.entries(endpointMeta).flatMap(([key, endpointInfo]) =>