akanjs 3.0.0 → 3.0.2-rc.0

package/server/cachePolicy.ts

@@ -7,6 +7,7 @@ export interface RouteCacheKeyInput {
   request: Request;
   url: URL;
   theme?: string;
+  variant?: string;
 }
 
 export interface RouteCacheRenderState {
@@ -116,7 +117,7 @@ export function isRouteCachePathAllowed(
   return matches(allow);
 }
 
-export function createRouteCacheKey({ request, url, theme = "" }: RouteCacheKeyInput): string {
+export function createRouteCacheKey({ request, url, theme = "", variant }: RouteCacheKeyInput): string {
   return [
     getClientFacingOrigin(request, url),
     request.headers.get("x-base-path") ?? "",
@@ -126,6 +127,7 @@ export function createRouteCacheKey({ request, url, theme = "" }: RouteCacheKeyI
     url.search,
     request.headers.get("accept-language") ?? "",
     theme,
+    ...(variant ? [variant] : []),
   ].join("\n");
 }
 
@@ -153,7 +155,15 @@ export function resolvePublicRouteCacheEntryDecision(input: PublicRouteCacheEntr
     return { entry: null, reason: "path-excluded" };
   }
   if (!isPublicRouteCacheableRequest(input.request)) return { entry: null, reason: "request-not-public" };
-  return { entry: createRouteCacheEntry({ request: input.request, url: input.url, theme: input.theme, ttl }) };
+  return {
+    entry: createRouteCacheEntry({
+      request: input.request,
+      url: input.url,
+      theme: input.theme,
+      variant: input.variant,
+      ttl,
+    }),
+  };
 }
 
 export function resolveRouteCacheStoreTtl(baseTtl: number, state: RouteCacheRenderState): number | null {

package/server/crawler.ts

@@ -0,0 +1,6 @@
+
+const crawlerPattern =
+  /(?<!cu)bot|crawl|spider|slurp|-user\b|preview|facebookexternalhit|facebookcatalog|meta-external|kakaotalk-scrap|whatsapp|vkshare|embedly|iframely|mastodon|anthropic-ai|cohere-ai|google-inspectiontool|googleother|mediapartners-google|yeti\b|daum\/|daumoa|ia_archiver/i;
+
+export const isCrawlerUserAgent = (userAgent: string | null | undefined): boolean =>
+  !!userAgent && crawlerPattern.test(userAgent);

package/server/head.tsx

@@ -39,10 +39,6 @@ export function renderAkanHeadSnapshot(snapshot: AkanHeadSnapshotV1): Head {
   );
 }
 
-export function shouldRenderLocaleAlternates(options: { isSpecialRoute?: boolean }): boolean {
-  return options.isSpecialRoute !== true;
-}
-
 function isResolvedHead(value: unknown): value is ResolvedHead {
   return isRecord(value) && "node" in value;
 }

package/server/mcp/McpAuth.ts

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import type { PromiseOrObject } from "akanjs/base";
-import { clientAddressFromHeaders } from "akanjs/common";
+import { SignalContext } from "../../signal/signalContext";
 import type { HttpRoutes } from "../types";
 
 export interface McpAuthOption {
@@ -157,7 +157,8 @@ export class McpAuth {
 
   static callerKey(req: Request): string {
     const token = McpAuth.#bearer(req);
-    if (!token) return `ip:${clientAddressFromHeaders(req.headers) ?? "anonymous"}`;
+    
+    if (!token) return `ip:${SignalContext.clientIpOf(req) ?? "anonymous"}`;
     const claims = McpAuth.#claims(token);
     const id = [claims?.sid, claims?.jti, claims?.sub].find((value) => typeof value === "string" && value);
     return typeof id === "string" ? `token:${id}` : `token:${createHash("sha256").update(token).digest("base64url")}`;

package/server/mcp/McpExecutionContext.ts

@@ -19,23 +19,24 @@ export class McpExecutionContext extends HttpExecutionContext {
     this.#arguments = args;
   }
 
-  override async getArgs(endpointInfo: EndpointInfo): Promise<unknown[]> {
+  override async readArgs(endpointInfo: EndpointInfo): Promise<unknown[]> {
     const declared = new Set(endpointInfo.args.filter(McpExecutionContext.#describable).map((arg) => arg.name));
     const undeclared = Object.keys(this.#arguments).find((name) => !declared.has(name));
     if (undeclared) throw new McpArgumentError(`Unknown argument "${undeclared}".`);
-    return endpointInfo.args.map((arg) => {
-      const value = McpExecutionContext.#lift(arg, this.#arguments[arg.name] ?? null);
-      try {
-        return deserialize(arg.argRef, arg.arrDepth, value, {
-          key: arg.name,
-          nullable: arg.option?.nullable,
-          enum: arg.enum,
-        });
-      } catch {
-        
-        throw new McpArgumentError(McpExecutionContext.#argumentMessage(arg, value));
-      }
-    });
+    return endpointInfo.args.map((arg) => McpExecutionContext.#lift(arg, this.#arguments[arg.name] ?? null));
+  }
+
+  override parseArg(arg: McpArg, value: unknown): unknown {
+    try {
+      return deserialize(arg.argRef, arg.arrDepth, value, {
+        key: arg.name,
+        nullable: arg.option?.nullable,
+        enum: arg.enum,
+      });
+    } catch {
+      
+      throw new McpArgumentError(McpExecutionContext.#argumentMessage(arg, value));
+    }
   }
 
   override makeResponse(result: unknown, endpointInfo: EndpointInfo) {

package/server/mcp/McpRateLimiter.ts

@@ -1,9 +1,6 @@
-import { type Dayjs, dayjs } from "akanjs/base";
-import { Logger } from "akanjs/common";
+import { type RateCounter, RateLimiter } from "akanjs/service";
 
-export interface McpSharedCounter {
-  incr(topic: string, key: string, by?: number, option?: { expireAt?: Dayjs }): Promise<number>;
-}
+export type McpSharedCounter = RateCounter;
 
 export interface McpRateLimitOption {
   /** Per caller per window; `0` turns the counter off. */
@@ -17,23 +14,14 @@ export type McpRateLimitVerdict =
   | { ok: true; release: () => void }
   | { ok: false; reason: "calls" | "concurrent"; retryAfterMs: number };
 
-interface McpRateBucket {
-  windowStart: number;
-  count: number;
-  inFlight: number;
-}
-
 export class McpRateLimiter {
   static readonly defaults = { calls: 120, windowMs: 60_000, concurrent: 8 } as const;
-  static readonly #logger = new Logger("McpRateLimiter");
 
   readonly calls: number;
   readonly windowMs: number;
   readonly concurrent: number;
-  readonly #shared: McpSharedCounter | null;
-  readonly #buckets = new Map<string, McpRateBucket>();
-  #sweptAt = 0;
-  #sharedFailed = false;
+  readonly #limiter: RateLimiter;
+  readonly #inFlight = new Map<string, number>();
 
   constructor(
     {
@@ -46,74 +34,37 @@ export class McpRateLimiter {
     this.calls = Math.max(0, Math.floor(calls));
     this.windowMs = Math.max(1, Math.floor(windowMs));
     this.concurrent = Math.max(0, Math.floor(concurrent));
-    this.#shared = shared;
+    this.#limiter = new RateLimiter(shared, { topic: "mcpRate" });
   }
 
   async acquire(key: string, now = Date.now()): Promise<McpRateLimitVerdict> {
-    this.#sweep(now);
-    const bucket = this.#bucketOf(key, now);
-    if (this.concurrent && bucket.inFlight >= this.concurrent)
-      return { ok: false, reason: "concurrent", retryAfterMs: 1_000 };
+    const held = this.#inFlight.get(key) ?? 0;
+    if (this.concurrent && held >= this.concurrent) return { ok: false, reason: "concurrent", retryAfterMs: 1_000 };
     
-    bucket.inFlight += 1;
+    this.#inFlight.set(key, held + 1);
     let released = false;
     const release = () => {
       if (released) return;
       released = true;
-      bucket.inFlight = Math.max(0, bucket.inFlight - 1);
+      const left = (this.#inFlight.get(key) ?? 1) - 1;
+      if (left > 0) this.#inFlight.set(key, left);
+      else this.#inFlight.delete(key);
     };
-    const retryAfterMs = this.calls ? await this.#spend(key, bucket, now) : null;
-    if (retryAfterMs === null) return { ok: true, release };
+    if (!this.calls) return { ok: true, release };
+    const verdict = await this.#limiter.consume(key, { calls: this.calls, windowMs: this.windowMs }, now);
+    if (verdict.ok) return { ok: true, release };
     release();
-    return { ok: false, reason: "calls", retryAfterMs };
+    return { ok: false, reason: "calls", retryAfterMs: verdict.retryAfterMs };
   }
 
   describe() {
-    const across = this.#shared ? " across instances" : "";
+    const shared = this.#limiter.isShared;
     const window = this.calls
-      ? `${this.calls} calls / ${Math.round(this.windowMs / 1000)}s${across}`
+      ? `${this.calls} calls / ${Math.round(this.windowMs / 1000)}s${shared ? " across instances" : ""}`
       : "unlimited calls";
     const inFlight = this.concurrent
-      ? `${this.concurrent} in flight${this.#shared ? " per instance" : ""}`
+      ? `${this.concurrent} in flight${shared ? " per instance" : ""}`
       : "unlimited in flight";
     return `${window}, ${inFlight}, per caller`;
   }
-
-  async #spend(key: string, bucket: McpRateBucket, now: number): Promise<number | null> {
-    if (this.#shared) {
-      const window = Math.floor(now / this.windowMs);
-      const end = (window + 1) * this.windowMs;
-      try {
-        const count = await this.#shared.incr("mcpRate", `${key}:${window}`, 1, {
-          expireAt: dayjs(end + this.windowMs),
-        });
-        this.#sharedFailed = false;
-        return count > this.calls ? Math.max(1, end - now) : null;
-      } catch (error) {
-        if (!this.#sharedFailed)
-          McpRateLimiter.#logger.warn(
-            `MCP rate limit cannot reach the cache, so each instance counts its own window until it can: ${String(error)}`,
-          );
-        this.#sharedFailed = true;
-      }
-    }
-    if (bucket.count >= this.calls) return Math.max(1, bucket.windowStart + this.windowMs - now);
-    bucket.count += 1;
-    return null;
-  }
-
-  #bucketOf(key: string, now: number) {
-    const found = this.#buckets.get(key);
-    if (found && now - found.windowStart < this.windowMs) return found;
-    const bucket: McpRateBucket = { windowStart: now, count: 0, inFlight: found?.inFlight ?? 0 };
-    this.#buckets.set(key, bucket);
-    return bucket;
-  }
-
-  #sweep(now: number) {
-    if (now - this.#sweptAt < this.windowMs) return;
-    this.#sweptAt = now;
-    for (const [key, bucket] of this.#buckets)
-      if (!bucket.inFlight && now - bucket.windowStart >= this.windowMs) this.#buckets.delete(key);
-  }
 }

package/server/proxy/webProxyRunner.ts

@@ -1,3 +1,4 @@
+import { SignalContext } from "../../signal/signalContext";
 import {
   WEB_PROXY_RESULT,
   type WebProxy,
@@ -9,6 +10,7 @@ import {
 } from "./types";
 
 export const copyBunRequestFields = (target: Request, source: Request): Request => {
+  SignalContext.carryClientIp(target, source);
   const sourceWithParams = source as Request & { params?: Record<string, string> };
   if (sourceWithParams.params) {
     Object.defineProperty(target, "params", {

package/server/resolver/database.resolver.ts

@@ -10,7 +10,9 @@ import {
   type DataInputOf,
   DataLoader,
   DocumentSchema,
+  type DocumentScopeOptions,
   type DocumentUpdateInput,
+  type DocumentUpdateOptions,
   documentQueryHelper,
   type FindQueryOption,
   getFilterMeta,
@@ -70,7 +72,7 @@ export class DatabaseResolver {
       sort: resolveSort(queryOption?.sort),
       skip: resolvePageSkip(queryOption?.skip),
 
-      limit: queryOption?.limit === undefined ? 0 : resolvePageLimit(queryOption.limit),
+      limit: queryOption?.limit === undefined || queryOption.limit === 0 ? 0 : resolvePageLimit(queryOption.limit),
       select: queryOption?.select,
       sample: queryOption?.sample,
     });
@@ -198,9 +200,13 @@ export class DatabaseResolver {
         function Model(this: any, data: Record<string, unknown>) {
           return store.hydrate(data);
         }
+        
+        const scopeOf = (options?: DocumentScopeOptions) => (options?.withRemoved ? { withRemoved: true } : {});
+        const scopeArgs = (options?: DocumentScopeOptions): [] | [DocumentScopeOptions] =>
+          options?.withRemoved ? [{ withRemoved: true }] : [];
         const createFindManyChain = (
           query: QueryOf<any>,
-          options: { sort?: any; skip?: number; limit?: number; select?: any } = {},
+          options: { sort?: any; skip?: number; limit?: number; select?: any; withRemoved?: boolean } = {},
         ) => {
           const chain: any = {
             sort(sort: any) {
@@ -225,7 +231,10 @@ export class DatabaseResolver {
           };
           return chain;
         };
-        const createFindOneChain = (query: QueryOf<any>, options: { sort?: any; skip?: number; select?: any } = {}) => {
+        const createFindOneChain = (
+          query: QueryOf<any>,
+          options: { sort?: any; skip?: number; select?: any; withRemoved?: boolean } = {},
+        ) => {
           const chain: any = {
             sort(sort: any) {
               return createFindOneChain(query, { ...options, sort });
@@ -261,21 +270,27 @@ export class DatabaseResolver {
           pickAndWrite: async (id: string, rawData: any) => await (await pickById(id)).set(rawData).save(),
           pickOneAndWrite: async (query: QueryOf<any>, rawData: any) =>
             await (await timedQuery(() => store.pickOne(query))).set(rawData).save(),
-          exists: async (query: QueryOf<any>) => await timedQuery(() => store.exists(query)),
+          exists: async (query: QueryOf<any>, options?: DocumentScopeOptions) =>
+            await timedQuery(() => store.exists(query, ...scopeArgs(options))),
           sample: (query: QueryOf<any>, size = 1) => timedQuery(() => store.find(query, { sample: size, limit: size })),
           sampleOne: (query: QueryOf<any>) => timedQuery(() => store.findOne(query, { sample: true })),
-          find: (query: QueryOf<any>, projection?: any) => createFindManyChain(query, { select: projection }),
-          findOne: (query: QueryOf<any>, projection?: any) => createFindOneChain(query, { select: projection }),
-          findById: (id: string | undefined, projection?: any) =>
-            id ? timedQuery(() => store.findOne({ id }, { select: projection })) : Promise.resolve(null),
-          count: (query: QueryOf<any>) => timedQuery(() => store.count(query)),
-          updateOne: (query: QueryOf<any>, update: DocumentUpdateInput, options?: { upsert?: boolean }) =>
+          find: (query: QueryOf<any>, projection?: any, options?: DocumentScopeOptions) =>
+            createFindManyChain(query, { select: projection, ...scopeOf(options) }),
+          findOne: (query: QueryOf<any>, projection?: any, options?: DocumentScopeOptions) =>
+            createFindOneChain(query, { select: projection, ...scopeOf(options) }),
+          findById: (id: string | undefined, projection?: any, options?: DocumentScopeOptions) =>
+            id
+              ? timedQuery(() => store.findOne({ id }, { select: projection, ...scopeOf(options) }))
+              : Promise.resolve(null),
+          count: (query: QueryOf<any>, options?: DocumentScopeOptions) =>
+            timedQuery(() => store.count(query, ...scopeArgs(options))),
+          updateOne: (query: QueryOf<any>, update: DocumentUpdateInput, options?: DocumentUpdateOptions) =>
             timedQuery(() => store.updateOneByQuery(query, update, options)),
-          updateMany: (query: QueryOf<any>, update: DocumentUpdateInput) =>
-            timedQuery(() => store.updateManyByQuery(query, update)),
+          updateMany: (query: QueryOf<any>, update: DocumentUpdateInput, options?: DocumentScopeOptions) =>
+            timedQuery(() => store.updateManyByQuery(query, update, ...scopeArgs(options))),
           removeOne: (query: QueryOf<any>) => timedQuery(() => store.removeOneByQuery(query)),
           removeMany: (query: QueryOf<any>) => timedQuery(() => store.removeManyByQuery(query)),
-          updateById: (id: string, update: DocumentUpdateInput, options?: { upsert?: boolean }) =>
+          updateById: (id: string, update: DocumentUpdateInput, options?: DocumentUpdateOptions) =>
             timedQuery(() => store.updateOneByQuery({ id }, update, options)),
           removeById: (id: string) => timedQuery(() => store.removeOneByQuery({ id })),
           

package/server/resolver/signal.resolver.ts

@@ -15,7 +15,14 @@ import {
   SLICE_META,
 } from "akanjs/base";
 import { capitalize, cookieHeaderHasAuthToken, Logger } from "akanjs/common";
-import { type ConstantField, deserialize, resolvePageLimit, resolvePageSkip, serialize } from "akanjs/constant";
+import {
+  type ConstantField,
+  deserialize,
+  MAX_PAGE_SIZE,
+  resolvePageLimit,
+  resolvePageSkip,
+  serialize,
+} from "akanjs/constant";
 import { baseDocumentColumns, documentQueryHelper, getFilterSortByKey, type QueryFieldMap } from "akanjs/document";
 import {
   type AkanJob,
@@ -30,6 +37,7 @@ import {
 import { websocketRoomContract } from "../../common/websocketContract";
 import { type Endpoint, type EndpointCls, sliceEndpoint } from "../../signal/endpoint";
 import type { EndpointInfo } from "../../signal/endpointInfo";
+import { EndpointRateLimit } from "../../signal/endpointRateLimit";
 import type { Internal, InternalCls } from "../../signal/internal";
 import type { InternalInfo } from "../../signal/internalInfo";
 import type { MiddlewareCls } from "../../signal/middleware";
@@ -65,6 +73,7 @@ export class SignalResolver {
   };
   static readonly #coalescingRooms = new Set<string>();
   static readonly #liveRoutes = new Map<string, { store: DocumentStore; route: LiveRoute }>();
+  static readonly #everyRowAsked = new Set<string>();
 
   static coalescesRoom(roomId: string): boolean {
     const separator = roomId.indexOf("-");
@@ -325,6 +334,17 @@ export class SignalResolver {
     else SignalResolver.logger.warn(message);
   }
 
+  static #clientPageLimit(listKey: string, asked: unknown) {
+    if (asked !== 0) return resolvePageLimit(asked);
+    if (!SignalResolver.#everyRowAsked.has(listKey)) {
+      SignalResolver.#everyRowAsked.add(listKey);
+      SignalResolver.logger.warn(
+        `${listKey} was asked for limit: 0 and served ${MAX_PAGE_SIZE} rows, the most a client may take; paginate, or name a page size`,
+      );
+    }
+    return MAX_PAGE_SIZE;
+  }
+
   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) =>
@@ -371,7 +391,7 @@ export class SignalResolver {
           .exec(async function (this: any, ...requestArgs: any) {
             const args = requestArgs.slice(0, argLength);
             const skip = resolvePageSkip(requestArgs[argLength]);
-            const limit = resolvePageLimit(requestArgs[argLength + 1]);
+            const limit = SignalResolver.#clientPageLimit(listKey, requestArgs[argLength + 1]);
             const sort = requestArgs[argLength + 2] ?? "latest";
             const internalArgs = requestArgs.slice(argLength + 3);
             const query = assertSliceQuery(
@@ -437,41 +457,46 @@ export class SignalResolver {
           });
       });
 
-      endpointObj[refName] = (builder as any)
-        .query(cnst.full, { guards: sliceCls.getGuards })
-        .param(`${refName}Id`, ID)
-        .exec(async function (this: any, id: string) {
-          return await this[serviceName][`get${capitalizedRefName}`](id);
-        });
+      if (sliceCls.crud.get) {
+        endpointObj[refName] = (builder as any)
+          .query(cnst.full, { guards: sliceCls.getGuards })
+          .param(`${refName}Id`, ID)
+          .exec(async function (this: any, id: string) {
+            return await this[serviceName][`get${capitalizedRefName}`](id);
+          });
 
-      endpointObj[`light${capitalizedRefName}`] = (builder as any)
-        .query(cnst.light, { guards: sliceCls.getGuards })
-        .param(`${refName}Id`, ID)
-        .exec(async function (this: any, id: string) {
-          return await this[serviceName][`get${capitalizedRefName}`](id);
-        });
+        endpointObj[`light${capitalizedRefName}`] = (builder as any)
+          .query(cnst.light, { guards: sliceCls.getGuards })
+          .param(`${refName}Id`, ID)
+          .exec(async function (this: any, id: string) {
+            return await this[serviceName][`get${capitalizedRefName}`](id);
+          });
+      }
 
-      endpointObj[`create${capitalizedRefName}`] = (builder as any)
-        .mutation(cnst.full, { guards: sliceCls.createGuards })
-        .body("data", cnst.input)
-        .exec(async function (this: any, data: any) {
-          return await this[serviceName].__create(data);
-        });
+      if (sliceCls.crud.create)
+        endpointObj[`create${capitalizedRefName}`] = (builder as any)
+          .mutation(cnst.full, { guards: sliceCls.createGuards })
+          .body("data", cnst.input)
+          .exec(async function (this: any, data: any) {
+            return await this[serviceName].__create(data);
+          });
 
-      endpointObj[`update${capitalizedRefName}`] = (builder as any)
-        .mutation(cnst.full, { guards: sliceCls.updateGuards })
-        .param(`${refName}Id`, ID)
-        .body("data", cnst.input)
-        .exec(async function (this: any, id: string, data: any) {
-          return await this[serviceName].__update(id, data);
-        });
+      if (sliceCls.crud.update)
+        endpointObj[`update${capitalizedRefName}`] = (builder as any)
+          .mutation(cnst.full, { guards: sliceCls.updateGuards })
+          .param(`${refName}Id`, ID)
+          .body("data", cnst.input)
+          .exec(async function (this: any, id: string, data: any) {
+            return await this[serviceName].__update(id, data);
+          });
 
-      endpointObj[`remove${capitalizedRefName}`] = (builder as any)
-        .mutation(cnst.full, { guards: sliceCls.removeGuards })
-        .param(`${refName}Id`, ID)
-        .exec(async function (this: any, id: string) {
-          return await this[serviceName].__remove(id);
-        });
+      if (sliceCls.crud.remove)
+        endpointObj[`remove${capitalizedRefName}`] = (builder as any)
+          .mutation(cnst.full, { guards: sliceCls.removeGuards })
+          .param(`${refName}Id`, ID)
+          .exec(async function (this: any, id: string) {
+            return await this[serviceName].__remove(id);
+          });
       return endpointObj;
     }) {}
     return SliceEndpoint;
@@ -600,6 +625,7 @@ export class SignalResolver {
     const routeOptions: NonNullable<SignalRoutes["routeOptions"]> = {};
     const wsRoutes: WebsocketRoutes = {};
     const defaultPrefix = endpointCls.srv.cnst?.refName;
+    SignalResolver.#warnUnguarded(endpointMeta);
     Object.entries(endpointMeta).forEach(([key, endpointInfo]) => {
       const path = endpointInfo.getRoutePath(key, defaultPrefix);
       if (endpointInfo.signalOption.globalPrefix !== undefined) {
@@ -627,7 +653,7 @@ export class SignalResolver {
           SignalResolver.#mountHttpRoute(
             routes,
             path,
-            SignalResolver.#canUsePrimitiveQueryFastPath(endpointInfo, middleware)
+            SignalResolver.#canUsePrimitiveQueryFastPath(key, endpointInfo, middleware)
               ? {
                   GET: async (req) => {
                     if (req.headers.get("authorization") || cookieHeaderHasAuthToken(req.headers.get("cookie")))
@@ -733,6 +759,15 @@ export class SignalResolver {
     return { routes, wsRoutes, routeOptions };
   }
 
+  static #warnUnguarded(endpointMeta: { [key: string]: EndpointInfo }) {
+    const open = 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.`,
+    );
+  }
   static #selectCache = new WeakMap<Cls, Record<string, true>>();
   static #selectForConstant(constant: Cls): Record<string, true> | undefined {
     const cached = SignalResolver.#selectCache.get(constant);
@@ -744,9 +779,14 @@ export class SignalResolver {
     return select;
   }
 
-  static #canUsePrimitiveQueryFastPath(endpointInfo: EndpointInfo, middleware: Map<string, MiddlewareCls>) {
+  static #canUsePrimitiveQueryFastPath(
+    key: string,
+    endpointInfo: EndpointInfo,
+    middleware: Map<string, MiddlewareCls>,
+  ) {
     return (
       process.env.AKAN_TRACE !== "1" &&
+      !EndpointRateLimit.budgetOf(key, endpointInfo) &&
       endpointInfo.args.length === 0 &&
       endpointInfo.internalArgs.length === 0 &&
       (endpointInfo.signalOption.guards?.length ?? 0) === 0 &&

package/server/robots.ts

@@ -2,33 +2,11 @@ import { getApiPrefix } from "akanjs/base";
 
 const DEFAULT_DISALLOW_PATHS = ["/_akan", "/admin", "/manager", "/private"] as const;
 
-const DEFAULT_AI_CRAWLERS = [
-  "GPTBot",
-  "ChatGPT-User",
-  "CCBot",
-  "ClaudeBot",
-  "Claude-Web",
-  "anthropic-ai",
-  "Google-Extended",
-  "PerplexityBot",
-  "Perplexity-User",
-  "Bytespider",
-  "Amazonbot",
-  "Applebot-Extended",
-  "Meta-ExternalAgent",
-  "FacebookBot",
-  "Diffbot",
-  "Omgilibot",
-  "Omgili",
-] as const;
-
 export function createDefaultRobotsTxt(): string {
   const lines = [
     "User-agent: *",
     "Allow: /",
     ...[getApiPrefix(), ...DEFAULT_DISALLOW_PATHS].map((path) => `Disallow: ${path}`),
-    "",
-    ...DEFAULT_AI_CRAWLERS.flatMap((crawler) => [`User-agent: ${crawler}`, "Disallow: /", ""]),
   ];
-  return `${lines.join("\n").trimEnd()}\n`;
+  return `${lines.join("\n")}\n`;
 }

package/server/routeTreeBuilder.ts

@@ -171,7 +171,6 @@ export class RouteTreeBuilder {
         : {
             renderPage: routeRender,
             pageIncludesOwnLayout: parsed.leaf === "_index",
-            isSpecialRoute: parsed.isSpecialRoute,
           }),
     } as Route);
   }
@@ -198,7 +197,6 @@ export class RouteTreeBuilder {
               renderRootLayouts: layer.pageRenderRootLayouts,
               renderLayouts: layer.pageRenderLayouts,
               resolveHead: RouteTreeBuilder.#composeHeadResolvers(route.renderPage.resolveHead, pageHead),
-              isSpecialRoute: route.isSpecialRoute,
               pageState: route.pageState ?? defaultPageState,
             },
           ]
@@ -301,6 +299,10 @@ export class RouteTreeBuilder {
       routeRender.getRouteDefinition = async () => (await loadModule()).definition;
     } else {
       routeRender.getLayoutPageConfig = pageConfigOf;
+      routeRender.getLayoutTheme = async () => {
+        const { module: mod } = await loadModule();
+        return "theme" in mod ? (mod.theme as string | undefined) : undefined;
+      };
       routeRender.resolveNotFound = async () => syncFallbacks((await loadModule()).module as LayoutModule).NotFound;
       routeRender.resolveError = async () => syncFallbacks((await loadModule()).module as LayoutModule).Error;
     }