akanjs 3.1.1-rc.4 → 3.1.1-rc.6

package/client/csrLocation.ts

@@ -4,10 +4,11 @@ declare global {
   var __AKAN_EMBED__: { kind: "mcp-app"; origin?: string; account?: Record<string, unknown> | null } | undefined;
 }
 
-/** The document's location and history, as the CSR router reads and moves them. */
+/** The document's location and history, as the routers read and move them. */
 export class CsrLocation {
   
   #view: URL | null = null;
+  #entry: { idx: number | undefined; href: string } | null = null;
 
   /** Reads `href`, a path on the app's origin, as this document's location from now on; a view never moves. */
   view(href: string) {
@@ -41,13 +42,40 @@ export class CsrLocation {
     return origin !== "null" && href.startsWith(origin) ? href.slice(origin.length) : href;
   }
 
+  /**
+   * The entry on screen as of the last write or traversal, and its index; during a `popstate` it is still the entry
+   * left, which `state` no longer reads.
+   */
+  entry() {
+    return this.#entry ?? this.observe();
+  }
+
+  observe() {
+    this.#entry = { idx: CsrLocation.idxOf(window.history?.state), href: this.href };
+    return this.#entry;
+  }
+
   push(state: unknown, href: string) {
-    window.history.pushState(state, "", href);
+    window.history.pushState(CsrLocation.#indexed(state, (this.entry().idx ?? 0) + 1), "", href);
+    this.observe();
   }
 
   replace(state: unknown, href?: string) {
-    if (href === undefined) window.history.replaceState(state, "");
-    else window.history.replaceState(state, "", href);
+    const indexed = CsrLocation.#indexed(state, this.entry().idx ?? 0);
+    if (href === undefined) window.history.replaceState(indexed, "");
+    else window.history.replaceState(indexed, "", href);
+    this.observe();
+  }
+
+  static idxOf(state: unknown) {
+    const idx = (state as { __akanRouter?: { idx?: unknown } } | null)?.__akanRouter?.idx;
+    return Number.isInteger(idx) ? (idx as number) : undefined;
+  }
+
+  static #indexed(state: unknown, idx: number) {
+    if (CsrLocation.idxOf(state) !== undefined) return state;
+    const record = (state ?? {}) as { __akanRouter?: object };
+    return { ...record, __akanRouter: { ...record.__akanRouter, idx } };
   }
 
   back() {

package/client/index.ts

@@ -12,6 +12,7 @@ export * from "./locale";
 export * from "./makePageProto";
 export * from "./mcpView";
 export * from "./nativeHost";
+export * from "./navigationGuards";
 export * from "./resolveServerUrl";
 export * from "./route";
 export * from "./router";

package/client/navigationGuards.ts

@@ -0,0 +1,72 @@
+import { Logger } from "akanjs/common";
+
+export type NavigationKind = "push" | "replace" | "back" | "pop";
+
+export interface Navigation {
+  /** `pop` is the browser's back or forward; `back` is `router.back()`, a native back button or a swipe. */
+  kind: NavigationKind;
+  /** The route on screen, without its locale and basePath, as `/docs/1?tab=a`. */
+  from: string;
+  /** Where it goes, written the same way; `null` for `back`, whose entry is not known until it arrives. */
+  to: string | null;
+}
+
+/** Answers `false` to keep the page; a guard that throws or rejects keeps it too. */
+export type NavigationGuard = (navigation: Navigation) => boolean | Promise<boolean>;
+
+export class NavigationRefused extends Error {
+  constructor(navigation: Navigation) {
+    super(`A navigation guard kept ${navigation.from} instead of moving to ${navigation.to ?? "the previous page"}`);
+    this.name = "NavigationRefused";
+  }
+}
+
+export class NavigationGuards {
+  #guards = new Set<NavigationGuard>();
+  #isDeciding: boolean = false;
+
+  get size() {
+    return this.#guards.size;
+  }
+
+  add(guard: NavigationGuard) {
+    this.#guards.add(guard);
+    return () => {
+      this.#guards.delete(guard);
+    };
+  }
+
+  decide(navigation: Navigation): boolean | Promise<boolean> {
+    if (this.#isDeciding) return false;
+    const guards = [...this.#guards];
+    for (const [idx, guard] of guards.entries()) {
+      const answer = NavigationGuards.#ask(guard, navigation);
+      if (answer === false) return false;
+      if (answer === true) continue;
+      this.#isDeciding = true;
+      return NavigationGuards.#decideRest(answer, guards.slice(idx + 1), navigation).finally(() => {
+        this.#isDeciding = false;
+      });
+    }
+    return true;
+  }
+
+  static async #decideRest(first: Promise<boolean>, rest: NavigationGuard[], navigation: Navigation) {
+    if (!(await first)) return false;
+    for (const guard of rest) if (!(await NavigationGuards.#ask(guard, navigation))) return false;
+    return true;
+  }
+
+  static #ask(guard: NavigationGuard, navigation: Navigation): boolean | Promise<boolean> {
+    const refuse = (error: unknown) => {
+      Logger.error(`A navigation guard failed, so ${navigation.from} was kept: ${String(error)}`);
+      return false;
+    };
+    try {
+      const answer = guard(navigation);
+      return answer instanceof Promise ? answer.then((value) => value !== false, refuse) : answer !== false;
+    } catch (error) {
+      return refuse(error);
+    }
+  }
+}

package/client/router.ts

@@ -1,8 +1,16 @@
 import { getEnv } from "akanjs/base";
-import { getBasePathFromPathname, Logger, parseAkanI18nEnv, parseBasePaths, trimSlashes } from "akanjs/common";
-import { csrLocation } from "./csrLocation";
+import {
+  getBasePathFromPathname,
+  Logger,
+  originFromRequest,
+  parseAkanI18nEnv,
+  parseBasePaths,
+  trimSlashes,
+} from "akanjs/common";
+import { CsrLocation, csrLocation } from "./csrLocation";
 import { Href } from "./href";
 import { isMcpView } from "./mcpView";
+import { type Navigation, type NavigationGuard, NavigationGuards, NavigationRefused } from "./navigationGuards";
 
 export interface RouteOptions {
   scrollToTop?: boolean;
@@ -91,13 +99,8 @@ function getServerRequestContext() {
 }
 
 const getServerPublicOrigin = () => {
-  const { getRequest, headers } = getServerRequestContext();
-  const h = headers();
-  const url = getRequest()?.url;
-  const host = h.get("x-forwarded-host")?.split(",")[0]?.trim() ?? h.get("host");
-  const proto = h.get("x-forwarded-proto")?.split(",")[0]?.trim();
-  if (!host) return url;
-  return `${proto ?? (url ? new URL(url).protocol.replace(":", "") : "https")}://${host}`;
+  const request = getServerRequestContext().getRequest();
+  return request ? originFromRequest(request.headers, new URL(request.url)) : undefined;
 };
 
 const getConfiguredBasePaths = () => new Set(parseBasePaths(process.env.AKAN_PUBLIC_BASE_PATHS));
@@ -193,6 +196,9 @@ class Router {
   #backsAwaitingPopstate = 0;
   #redirects = 0;
   #navigations = 0;
+  #guards = new NavigationGuards();
+  
+  #expectedPops: { idx: number; isAllowed: boolean; onLand?: () => void }[] = [];
   
   #beforeInit: (() => void)[] = [];
   #instance: RouterInstance = {
@@ -317,14 +323,62 @@ class Router {
     csrLocation.replace({ ...state, __akanRouter: { ...akanState, idx: this.#historyIdx } });
     if (this.#listensToPopstate || !globalThis.window.addEventListener) return;
     this.#listensToPopstate = true;
-    globalThis.window.addEventListener("popstate", (event) => {
-      const nextState = ((event.state as Record<string, unknown> | null)?.__akanRouter ?? {}) as { idx?: number };
-      if (Number.isInteger(nextState.idx)) this.#historyIdx = nextState.idx as number;
-      if (this.#backsAwaitingPopstate === 0) return;
-      this.#backsAwaitingPopstate -= 1;
-      this.postPathChange(this.#getPathInfo(csrLocation.href));
+    
+    globalThis.window.addEventListener("popstate", (event) => this.#onPopstate(event), true);
+    globalThis.window.addEventListener("hashchange", () => csrLocation.observe());
+  }
+  #onPopstate(event: PopStateEvent) {
+    const left = csrLocation.entry();
+    const landed = CsrLocation.idxOf(event.state);
+    const expected = this.#expectedPops.shift();
+    if (expected && expected.idx === landed) {
+      expected.onLand?.();
+      if (expected.isAllowed) this.#landOn(landed);
+      else {
+        event.stopImmediatePropagation();
+        csrLocation.observe();
+      }
+      return;
+    }
+    if (expected) this.#expectedPops.length = 0;
+    if (left.idx === undefined || landed === undefined || landed === left.idx || !this.#asks(null)) {
+      this.#landOn(landed);
+      return;
+    }
+    const leftIdx = left.idx;
+    const navigation: Navigation = {
+      kind: "pop",
+      from: this.#routeShown(left.href),
+      to: this.#routeShown(csrLocation.href),
+    };
+    const verdict = this.#guards.decide(navigation);
+    if (verdict === true) {
+      this.#landOn(landed);
+      return;
+    }
+    event.stopImmediatePropagation();
+    const reverted = this.#traverse(landed, leftIdx, false);
+    if (verdict === false) return;
+    
+    void Promise.all([verdict, reverted]).then(([isAllowed]) => {
+      if (isAllowed) void this.#traverse(leftIdx, landed, true);
     });
   }
+  #traverse(from: number, to: number, isAllowed: boolean) {
+    return new Promise<void>((onLand) => {
+      this.#expectedPops.push({ idx: to, isAllowed, onLand });
+      globalThis.window.history.go(to - from);
+    });
+  }
+  #landOn(idx: number | undefined) {
+    if (idx !== undefined) this.#historyIdx = idx;
+    csrLocation.observe();
+    
+    if (idx === undefined) setTimeout(() => csrLocation.observe(), 0);
+    if (this.#backsAwaitingPopstate === 0) return;
+    this.#backsAwaitingPopstate -= 1;
+    this.postPathChange(this.#getPathInfo(csrLocation.href));
+  }
 
   #rememberHistoryState(kind: "push" | "replace") {
     if (getEnv().side === "server" || this.#historyWrittenByNavigation) return;
@@ -424,9 +478,16 @@ class Router {
     const stack = this.resolveDeepLinkStack(href);
     if (stack.length === 0) return false;
     const { resetStack: _resetStack, ...routeOptions } = options;
-    this.replace(stack[0], routeOptions);
-    stack.slice(1).forEach((target, index) => {
-      setTimeout(() => this.push(target, routeOptions), DEEP_LINK_STACK_STEP_DELAY * (index + 1));
+    
+    this.#guarded("replace", normalizeDeepLinkHref(href), () => {
+      const moved = this.#move("replace", stack[0], routeOptions);
+      stack.slice(1).forEach((target, index) => {
+        setTimeout(
+          () => this.#track(this.#move("push", target, routeOptions)),
+          DEEP_LINK_STACK_STEP_DELAY * (index + 1),
+        );
+      });
+      return moved;
     });
     return true;
   }
@@ -434,24 +495,60 @@ class Router {
     if (this.#deferredUntilInit(() => this.push(href, routeOptions))) return undefined as never;
     this.#checkInitialized();
     if (this.#refusesOffsite("push", href, routeOptions)) return undefined as never;
-    this.#navigations += 1;
-    this.#track(this.#instance.push(href, routeOptions));
-    this.#rememberHistoryState("push");
-    this.#postDevSyncNavigation("push", href);
+    this.#guarded("push", href, () => this.#move("push", href, routeOptions));
     return undefined as never;
   }
   replace(href: string, routeOptions?: RouteOptions) {
     if (this.#deferredUntilInit(() => this.replace(href, routeOptions))) return undefined as never;
     this.#checkInitialized();
     if (this.#refusesOffsite("replace", href, routeOptions)) return undefined as never;
-    this.#navigations += 1;
-    this.#track(this.#instance.replace(href, routeOptions));
-    this.#rememberHistoryState("replace");
-    this.#postDevSyncNavigation("replace", href);
+    this.#guarded("replace", href, () => this.#move("replace", href, routeOptions));
     return undefined as never;
   }
-  /** The last `push`/`replace`; rejects when the route refused to move. A method, not a getter: through the `router`
-   * Proxy a getter would run with the Proxy as `this` and fail on the private field. */
+  #move(kind: "push" | "replace", href: string, routeOptions?: RouteOptions) {
+    this.#navigations += 1;
+    const moved = this.#instance[kind](href, routeOptions);
+    this.#rememberHistoryState(kind);
+    this.#postDevSyncNavigation(kind, href);
+    return moved;
+  }
+  /**
+   * Asks `guard` before every in-app move — `push`, `replace`, `back`, a `Link`, the browser's back and forward, the
+   * agent's navigate — and keeps the page when it answers `false`; returns the call that removes it. A redirect, a
+   * not-found, a locale switch and a move off the origin are not asked.
+   */
+  addNavigationGuard(guard: NavigationGuard) {
+    return this.#guards.add(guard);
+  }
+  #guarded(kind: "push" | "replace" | "back", href: string | null, move: () => void | Promise<void>) {
+    if (!this.#asks(href)) return this.#track(move());
+    const navigation: Navigation = {
+      kind,
+      from: this.#routeShown(csrLocation.href),
+      to: href === null ? null : Router.#routeHref(this.#getPathInfo(href)),
+    };
+    const verdict = this.#guards.decide(navigation);
+    if (verdict === true) return this.#track(move());
+    this.#track(
+      Promise.resolve(verdict).then((isAllowed) => {
+        if (!isAllowed) throw new NavigationRefused(navigation);
+        return move();
+      }),
+    );
+  }
+
+  #asks(href: string | null) {
+    if (this.#guards.size === 0 || globalThis.__AKAN_DEV_SYNC_NAVIGATION_APPLYING__) return false;
+    return href === null || !this.#leavesOrigin(href);
+  }
+  #routeShown(href: string) {
+    return Router.#routeHref(this.#getVisiblePathInfo(href));
+  }
+  static #routeHref({ path, search, hash }: { path: string; search: string; hash: string }) {
+    return `${path}${search ? `?${search}` : ""}${hash ? `#${hash}` : ""}`;
+  }
+  /** The last `push`, `replace` or `back`; rejects when a navigation guard or the route refused to move. A method, not
+   * a getter: through the `router` Proxy a getter would run with the Proxy as `this` and fail on the private field. */
   navigation(): Promise<void> {
     return this.#navigation;
   }
@@ -495,8 +592,12 @@ class Router {
   back(routeOptions?: RouteOptions) {
     if (getEnv().side === "server") throw new Error("back is only available in client side");
     this.#checkInitialized();
-    this.#navigations += 1;
-    this.#instance.back(routeOptions);
+    this.#guarded("back", null, () => {
+      this.#navigations += 1;
+      const idx = this.#guards.size ? csrLocation.entry().idx : undefined;
+      if (idx !== undefined) this.#expectedPops.push({ idx: idx - 1, isAllowed: true });
+      this.#instance.back(routeOptions);
+    });
     return undefined as never;
   }
   refresh() {

package/common/index.ts

@@ -82,6 +82,7 @@ export {
 } from "./fileUpload";
 export { formatNumber } from "./formatNumber";
 export { type AkanHmrPhase, getAkanHmrPhase, isAkanHmrApplying } from "./hmrPhase";
+export { IpLiteral } from "./IpLiteral";
 export { interpolateTranslation } from "./interpolateTranslation";
 export { isDayjs } from "./isDayjs";
 export { isEmail } from "./isEmail";

package/dictionary/agent.dictionary.ts

@@ -38,6 +38,7 @@ export const agentDictionary = serviceDictionary(["en", "ko"])
       "The agent's usage limit for this account has been reached",
       "이 계정의 에이전트 사용 한도에 도달했습니다.",
     ],
+    requestRefused: ["This app's agent does not take this request", "이 앱의 에이전트는 이 요청을 받지 않습니다."],
   });
 
 export const agentTurnDictionary = scalarDictionary(["en", "ko"])

package/document/by.ts

@@ -1,6 +1,7 @@
 import { type Cls, FIELD_META, type GetActionObject } from "akanjs/base";
 import { applyMixins } from "akanjs/common";
 import { ConstantRegistry, type DocumentConstantModelRef, type DocumentModel, type FieldObject } from "akanjs/constant";
+import type { DocumentTouchOptions } from "./documentQuery";
 
 export type DatabaseCls<Schema = unknown> = Cls<Schema, { refName: string; [FIELD_META]: FieldObject }>;
 export type DatabaseInstanceOf<DatabaseRef extends DatabaseCls> = DatabaseRef extends new (
@@ -14,7 +15,7 @@ export interface DefaultDocMtds<TDocument> {
   refresh(): Promise<this>;
   isModified(field?: keyof TDocument & string): boolean;
   set(data: Partial<TDocument>): this;
-  save(): Promise<this>;
+  save(options?: DocumentTouchOptions): Promise<this>;
   toJSON(): DocumentModel<TDocument>;
   toObject(): DocumentModel<TDocument>;
 }
@@ -25,7 +26,7 @@ type HydratedDocumentMethods<TDocument, Self> = Omit<
   refresh(): Promise<Self>;
   isModified(field?: keyof TDocument & string): boolean;
   set(data: Partial<TDocument>): Self;
-  save(): Promise<Self>;
+  save(options?: DocumentTouchOptions): Promise<Self>;
 };
 type HydratedDocumentWithId<TDocument> = TDocument & { id: string } & HydratedDocumentMethods<TDocument, TDocument>;
 interface ChainableHydratedMethods<TDocument>
@@ -33,7 +34,7 @@ interface ChainableHydratedMethods<TDocument>
   refresh(): Promise<this>;
   isModified(field?: keyof TDocument & string): boolean;
   set(data: Partial<TDocument>): this;
-  save(): Promise<this>;
+  save(options?: DocumentTouchOptions): Promise<this>;
 }
 type ChainableHydratedDocument<TDocument> = TDocument & {
   id: string;

package/document/into.ts

@@ -25,8 +25,8 @@ interface DefaultMdlStats<
   _FilterQuery extends DocumentQuery<TSchema> = DocumentQuery<TSchema>,
   _Projection = DocumentProjection<TSchema>,
 > {
-  pickOneAndWrite: (query: _FilterQuery, rawData: _Partial) => Promise<TDocument>;
-  pickAndWrite: (docId: string, rawData: _Partial) => Promise<TDocument>;
+  pickOneAndWrite: (query: _FilterQuery, rawData: _Partial, options?: DocumentTouchOptions) => Promise<TDocument>;
+  pickAndWrite: (docId: string, rawData: _Partial, options?: DocumentTouchOptions) => Promise<TDocument>;
   pickOne: (query: _FilterQuery, projection?: _Projection) => Promise<TDocument>;
   pickById: (docId: string | undefined, projection?: _Projection) => Promise<TDocument>;
   sample: (query: _FilterQuery, size?: number) => Promise<TDocument[]>;

package/fetch/client/fetchClient.ts

@@ -84,6 +84,12 @@ export interface FetchBridge {
   call(request: FetchBridgeCall): Promise<unknown>;
 }
 
+export interface FetchClaim {
+  key: string;
+  /** What in its module claims the key, phrased for a boot error: `the mutation "removeX"`, `the root slice`. */
+  by: string;
+}
+
 const FETCH_BRIDGE_KEY = Symbol.for("akanjs.fetch.bridge");
 const globalWithFetchBridge = globalThis as typeof globalThis & { [FETCH_BRIDGE_KEY]?: FetchBridge | null };
 
@@ -112,6 +118,8 @@ export class FetchClient {
   #wsOptions: WsClientOptions = {};
   readonly #handlerStore: Record<string, FetchHandler> = {};
   readonly #handlerFactory = new Map<string, FetchHandlerFactory>();
+  /** The refName whose slice generated each handler, so its cleanup never takes another module's same-named endpoint. */
+  readonly #generatedBy = new Map<string, string>();
   #sharedRegistryAppliedVersion = 0;
   #clientIp: string | null = null;
   /** Cloned toward another server: the request being served is this server's visitor, not that server's caller. */
@@ -320,9 +328,11 @@ export class FetchClient {
     if (!handler) throw new Error(`${owner} requires fetch handler "${key}", but it is not registered`);
     return handler as T;
   }
-  #setHandlerFactory(key: string, factory: FetchHandlerFactory) {
+  #setHandlerFactory(key: string, factory: FetchHandlerFactory, generatedBy?: string) {
     this.#handlerFactory.set(key, factory);
     delete this.#handlerStore[key];
+    if (generatedBy) this.#generatedBy.set(key, generatedBy);
+    else this.#generatedBy.delete(key);
   }
   
   connect() {
@@ -715,11 +725,14 @@ export class FetchClient {
     const guards = verb === "get" ? signal.getGuards : (signal[`${verb}Guards`] ?? signal.cruGuards);
     return guards?.some((guard) => guard !== "None") ? guards : undefined;
   }
-  #registerModelBaseEndpoint(refName: string, signal: SerializedSignal) {
+  static #modelNames(refName: string) {
     const capRefName = capitalize(refName);
-    const names = {
+    return {
+      createModel: `create${capRefName}`,
       updateModel: `update${capRefName}`,
+      removeModel: `remove${capRefName}`,
       model: refName,
+      lightModel: `light${capRefName}`,
       viewModel: `view${capRefName}`,
       getModelView: `get${capRefName}View`,
       editModel: `edit${capRefName}`,
@@ -727,34 +740,90 @@ export class FetchClient {
       addModelFiles: `add${capRefName}Files`,
       mergeModel: `merge${capRefName}`,
     };
+  }
+  
+  static #helpersOf(signal: SerializedSignal) {
+    const get = !!FetchClient.#mountedGuards(signal, "get");
+    const update = !!FetchClient.#mountedGuards(signal, "update");
+    const write =
+      update || !!FetchClient.#mountedGuards(signal, "create") || !!FetchClient.#mountedGuards(signal, "remove");
+    return { view: get, edit: get && write, merge: update };
+  }
+  static #sliceNames(refName: string, suffix: string) {
+    const capSuffix = capitalize(suffix);
+    const capRefName = capitalize(refName);
+    return {
+      list: `${refName}List${capSuffix}`,
+      insight: `${refName}Insight${capSuffix}`,
+      live: `${refName}Live${capSuffix}`,
+      init: `init${capRefName}${capSuffix}`,
+      getInit: `get${capRefName}Init${capSuffix}`,
+    };
+  }
+  /** The `fetch.*` names a module's signal registers, and the bare socket route of each pubsub and message. */
+  static claimsOf(refName: string, signal: SerializedSignal) {
+    const handlers: FetchClaim[] = [];
+    const sockets: FetchClaim[] = [];
+    const claim = (key: string, endpoint: SerializedEndpoint, by: string) => {
+      handlers.push({ key: endpoint.type === "pubsub" ? `subscribe${capitalize(key)}` : key, by });
+      if (endpoint.type === "message") handlers.push({ key: `listen${capitalize(key)}`, by });
+      if (endpoint.type === "pubsub" || endpoint.type === "message") sockets.push({ key, by });
+    };
+    for (const [key, endpoint] of Object.entries(signal.endpoint))
+      claim(key, endpoint, `the ${endpoint.type} "${key}"`);
+    if (!signal.slice) return { handlers, sockets };
+    const generated = "the generated CRUD";
+    for (const [key, endpoint] of Object.entries(FetchClient.getBaseEndpoint(refName, signal)))
+      claim(key, endpoint, generated);
+    const names = FetchClient.#modelNames(refName);
+    const helpers = FetchClient.#helpersOf(signal);
+    const helperKeys = [
+      ...(helpers.view ? [names.viewModel, names.getModelView] : []),
+      ...(helpers.edit ? [names.editModel, names.getModelEdit] : []),
+      ...(helpers.merge ? [names.mergeModel] : []),
+      names.addModelFiles,
+    ];
+    for (const key of helperKeys) handlers.push({ key, by: generated });
+    for (const [suffix, slice] of Object.entries(signal.slice)) {
+      const by = suffix ? `the slice "${suffix}"` : "the root slice";
+      for (const [key, endpoint] of Object.entries(FetchClient.getEndpointFromSlice(refName, suffix, slice)))
+        claim(key, endpoint, by);
+      const { init, getInit } = FetchClient.#sliceNames(refName, suffix);
+      handlers.push({ key: init, by }, { key: getInit, by });
+    }
+    return { handlers, sockets };
+  }
+  #registerModelBaseEndpoint(refName: string, signal: SerializedSignal) {
+    const names = FetchClient.#modelNames(refName);
     
-    const generated = [`create${capRefName}`, `remove${capRefName}`, `light${capRefName}`, ...Object.values(names)];
-    for (const key of generated.filter((key) => key !== names.addModelFiles && !(key in signal.endpoint))) {
+    for (const key of Object.values(names).filter((key) => this.#generatedBy.get(key) === refName)) {
       this.#handlerFactory.delete(key);
+      this.#generatedBy.delete(key);
       delete this.#handlerStore[key];
     }
     const endpoint = FetchClient.getBaseEndpoint(refName, signal);
     Object.entries(endpoint).forEach(([key, value]) => {
-      this.#setHandlerFactory(key, () => this.#makeHttpFn(key, value, signal.prefix));
+      this.#setHandlerFactory(key, () => this.#makeHttpFn(key, value, signal.prefix), refName);
     });
 
-    const getGuards = FetchClient.#mountedGuards(signal, "get");
-    const updateGuards = FetchClient.#mountedGuards(signal, "update");
-    const anyCruGuards =
-      FetchClient.#mountedGuards(signal, "create") ?? updateGuards ?? FetchClient.#mountedGuards(signal, "remove");
-    if (getGuards) {
-      this.#setHandlerFactory(names.viewModel, () =>
-        this.#makeModelHandleFn(refName, names.model, names.viewModel, `${refName}View`),
+    const helpers = FetchClient.#helpersOf(signal);
+    if (helpers.view) {
+      this.#setHandlerFactory(
+        names.viewModel,
+        () => this.#makeModelHandleFn(refName, names.model, names.viewModel, `${refName}View`),
+        refName,
       );
-      this.#setHandlerFactory(names.getModelView, () => this.#makeModelObjFn(refName, names.getModelView));
+      this.#setHandlerFactory(names.getModelView, () => this.#makeModelObjFn(refName, names.getModelView), refName);
     }
-    if (getGuards && anyCruGuards) {
-      this.#setHandlerFactory(names.editModel, () =>
-        this.#makeModelHandleFn(refName, names.model, names.editModel, `${refName}Edit`),
+    if (helpers.edit) {
+      this.#setHandlerFactory(
+        names.editModel,
+        () => this.#makeModelHandleFn(refName, names.model, names.editModel, `${refName}Edit`),
+        refName,
       );
-      this.#setHandlerFactory(names.getModelEdit, () => this.#makeModelObjFn(refName, names.getModelEdit));
+      this.#setHandlerFactory(names.getModelEdit, () => this.#makeModelObjFn(refName, names.getModelEdit), refName);
     }
-    if (updateGuards) {
+    if (helpers.merge) {
       this.#setHandlerFactory(
         names.mergeModel,
         () =>
@@ -762,6 +831,7 @@ export class FetchClient {
             const id = typeof modelOrId === "string" ? modelOrId : modelOrId.id;
             return this.#requireHandler(names.updateModel, names.mergeModel)(id, data, option);
           }) as FetchHandler,
+        refName,
       );
     }
 
@@ -832,12 +902,7 @@ export class FetchClient {
     suffix: string,
     slice: SerializedSlice,
   ): { [key: string]: SerializedEndpoint } {
-    const capSuffix = capitalize(suffix);
-    const names = {
-      list: `${refName}List${capSuffix}`,
-      insight: `${refName}Insight${capSuffix}`,
-      live: `${refName}Live${capSuffix}`,
-    };
+    const names = FetchClient.#sliceNames(refName, suffix);
     
     const mcp = {
       ...(slice.mcp === false ? { mcp: false as const } : {}),
@@ -874,12 +939,7 @@ export class FetchClient {
     const capSuffix = capitalize(suffix);
     const sliceName = `${refName}${capSuffix}`;
     const capRefName = capitalize(refName);
-    const names = {
-      list: `${refName}List${capSuffix}`,
-      insight: `${refName}Insight${capSuffix}`,
-      init: `init${capRefName}${capSuffix}`,
-      getInit: `get${capRefName}Init${capSuffix}`,
-    };
+    const names = FetchClient.#sliceNames(refName, suffix);
 
     const endpoint = FetchClient.getEndpointFromSlice(refName, suffix, slice);
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.1.1-rc.4",
+  "version": "3.1.1-rc.6",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/akanApp.ts

@@ -24,6 +24,7 @@ import type { OpsRoute } from "./ops/opsRoute";
 import { StatusAccess } from "./ops/statusAccess";
 import { ProcessMetricsCollector } from "./processMetricsCollector";
 import { HostAllowlist } from "./routing/hostAllowlist";
+import { WsUpgrade } from "./routing/wsUpgrade";
 import { SelfExec } from "./selfExec";
 import { resolveStaticPath } from "./staticPath";
 import { getWebConfigFromEnv } from "./types";
@@ -670,6 +671,7 @@ export class AkanApp {
     } catch {
       return new Response("Forbidden", { status: 403 });
     }
+    if (!WsUpgrade.isRequested(req)) return WsUpgrade.required();
     const upstreamWs = new WebSocket(`ws://${upstream.host}:${upstream.port}${url.pathname}${url.search}`, {
       headers: makeAkanChildProxyHeaders(req, child.idx, server.requestIP(req)),
     } as unknown as string[]);