akanjs 3.0.0-alpha.3 → 3.0.0-alpha.5

package/common/Logger.ts

@@ -60,6 +60,10 @@ export class Logger {
   static isVerbose() {
     return Logger.#levelIdx <= 1;
   }
+  /** For hot-path callers that would otherwise build a message the level is about to discard. */
+  static shouldLog(logLevel: LogLevel) {
+    return Logger.#shouldLog(logLevel);
+  }
 
   name?: string;
   constructor(name?: string) {

package/constant/fieldInfo.ts

@@ -450,7 +450,13 @@ export class ConstantField<
   get isMap() {
     return (this.modelRef as Cls) === Map;
   }
+
+  #props: FieldProps | null = null;
   getProps(): FieldProps {
+    this.#props ??= Object.freeze(this.#buildProps());
+    return this.#props;
+  }
+  #buildProps(): FieldProps {
     return {
       nullable: this.nullable as unknown as boolean,
       ref: this.ref,

package/constant/getDefault.ts

@@ -2,17 +2,45 @@ import { DEFAULT_VALUE, FIELD_META, type PrimitiveScalar } from "akanjs/base";
 import type { FieldObject } from ".";
 import type { DefaultOf } from "./types";
 
+interface DefaultPlan {
+  /** Fields whose default is a value that can be shared: a primitive, `null`, or the field's own literal. */
+  shared: Record<string, unknown>;
+  /** Fields that have to be produced per call — a thunk, a fresh array, or a nested scalar record. */
+  perCall: [key: string, make: () => unknown][];
+}
+
+const planCache = new WeakMap<FieldObject, DefaultPlan>();
+
+/**
+ * The split is what keeps this faithful: `default: () => dayjs()` still means "now" on every call, and an array
+ * or nested-scalar default is still a fresh object, so two documents filled from the same model never end up
+ * sharing one. Only values that were already shared before this cache existed live in `shared`.
+ */
 export const getDefault = <T>(fieldObj: FieldObject): DefaultOf<T> => {
-  const result: Record<string, unknown> = {};
+  let plan = planCache.get(fieldObj);
+  if (!plan) {
+    plan = buildPlan(fieldObj);
+    planCache.set(fieldObj, plan);
+  }
+  const result: Record<string, unknown> = { ...plan.shared };
+  for (const [key, make] of plan.perCall) result[key] = make();
+  return result as DefaultOf<T>;
+};
+
+const buildPlan = (fieldObj: FieldObject): DefaultPlan => {
+  const shared: Record<string, unknown> = {};
+  const perCall: [string, () => unknown][] = [];
   for (const [key, field] of Object.entries(fieldObj)) {
-    if (field.fieldType === "hidden" || field.fieldType === "secret") result[key] = null;
+    if (field.fieldType === "hidden" || field.fieldType === "secret") shared[key] = null;
     else if (field.default !== undefined && field.default !== null) {
-      if (typeof field.default === "function") result[key] = (field.default as () => object)();
-      else result[key] = field.default as object;
-    } else if (field.isArray) result[key] = [];
-    else if (field.nullable) result[key] = null;
-    else if (field.isClass) result[key] = field.isScalar ? getDefault(field.modelRef[FIELD_META]) : null;
-    else result[key] = (field.modelRef as unknown as typeof PrimitiveScalar)[DEFAULT_VALUE];
+      if (typeof field.default === "function") perCall.push([key, field.default as () => unknown]);
+      else shared[key] = field.default as object;
+    } else if (field.isArray) perCall.push([key, () => []]);
+    else if (field.nullable) shared[key] = null;
+    else if (field.isClass) {
+      if (field.isScalar) perCall.push([key, () => getDefault(field.modelRef[FIELD_META])]);
+      else shared[key] = null;
+    } else shared[key] = (field.modelRef as unknown as typeof PrimitiveScalar)[DEFAULT_VALUE];
   }
-  return result as DefaultOf<T>;
+  return { shared, perCall };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.5",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/akanApp.ts

@@ -7,6 +7,7 @@ import type { AkanChildRole, AkanChildStatus, AkanIpcMessage, AkanMetricsReport,
 import { isTraceEnabled } from "akanjs/signal";
 import { makeAkanChildProxyHeaders } from "./akanAppHeaders";
 import type { BuilderCsrReq, BuilderCsrRes, BuilderMessage, BuilderReq, BuilderRes } from "./artifact";
+import { resolveEncodedSidecar } from "./assetEncoding";
 import { isPortInUseError } from "./lifecycle/portInUse";
 import { RotatingLogWriter } from "./logging/rotatingLogWriter";
 import { ProcessMetricsCollector } from "./processMetricsCollector";
@@ -808,41 +809,17 @@ export class AkanApp {
     const headers = new Headers({ "Content-Type": options.contentType });
     if (options.cacheControl) headers.set("Cache-Control", options.cacheControl);
 
-    const gzipPath = `${filePath}.gz`;
-    if (this.#acceptsGzip(req) && this.#isCompressible(options.contentType)) {
-      const gzipFile = Bun.file(gzipPath);
-      if (await gzipFile.exists()) {
-        const gzipBytes = await gzipFile.bytes();
-        headers.set("Content-Encoding", "gzip");
-        headers.set("Content-Length", String(gzipBytes.byteLength));
-        headers.set("Vary", "Accept-Encoding");
-        return new Response(this.#toArrayBuffer(gzipBytes), { headers });
-      }
+    const sidecar = await resolveEncodedSidecar(req, filePath, options.contentType);
+    if (sidecar) {
+      headers.set("Content-Encoding", sidecar.encoding);
+      headers.set("Content-Length", String(sidecar.bytes.byteLength));
+      headers.set("Vary", "Accept-Encoding");
+      return new Response(sidecar.bytes, { headers });
     }
 
     return new Response(Bun.file(filePath).stream(), { headers });
   }
 
-  #acceptsGzip(req: Request): boolean {
-    const acceptEncoding = req.headers.get("accept-encoding") ?? "";
-    return /\bgzip\b/.test(acceptEncoding);
-  }
-
-  #isCompressible(contentType: string): boolean {
-    const type = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
-    return (
-      type.startsWith("text/") ||
-      type === "application/javascript" ||
-      type === "application/json" ||
-      type === "application/manifest+json" ||
-      type === "image/svg+xml"
-    );
-  }
-
-  #toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
-    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer;
-  }
-
   #safeResolve(baseDir: string, urlPath: string): string | null {
     let decoded: string;
     try {

package/server/artifact/routeClientCache.ts

@@ -48,12 +48,22 @@ export class RouteClientCache {
   };
   readonly #buildRoute: RouteBuildFn;
   readonly #onMerge?: OnMergeFn;
+  #revision = 0;
 
   constructor({ buildRoute, onMerge }: RouteClientCacheOptions) {
     this.#buildRoute = buildRoute;
     this.#onMerge = onMerge;
   }
 
+  /**
+   * Bumped on every mutation of `merged`, including a delta merge that leaves `generation` where it was. It lets a
+   * consumer memoize work derived from the manifest — merging the runtime manifest over it, say — without having to
+   * copy the manifest to find out whether anything changed. In production nothing after `seed` moves it at all.
+   */
+  get revision(): number {
+    return this.#revision;
+  }
+
   #getEmptyDelta(): BuildRouteClientResult {
     return {
       manifestDelta: {},
@@ -75,6 +85,7 @@ export class RouteClientCache {
     Object.assign(this.merged.ssrManifest.moduleMap, manifest.ssrManifest.moduleMap);
     for (const abs of manifest.knownEntries) this.merged.knownEntries.add(abs);
     for (const routeId of manifest.routeIds) this.#built.set(routeId, this.#getEmptyDelta());
+    this.#revision += 1;
   }
 
   async ensure(routeId: string, seeds: string[]): Promise<MergedManifest> {
@@ -125,6 +136,7 @@ export class RouteClientCache {
     for (const [url, byName] of Object.entries(delta.ssrManifestDelta.moduleMap))
       this.merged.ssrManifest.moduleMap[url] = byName;
     for (const entry of delta.newEntries) this.merged.knownEntries.add(entry);
+    this.#revision += 1;
     this.#built.set(routeId, delta);
     this.#logger.verbose(
       `[route-cache] build done routeId=${routeId} generation=${generation} entries=+${delta.newEntries.length} deps=${delta.clientDeps.length} in ${Date.now() - started}ms`,
@@ -176,6 +188,7 @@ export class RouteClientCache {
     }
     const nextGeneration = this.merged.generation + 1;
     this.merged = this.#getEmptyMerged(nextGeneration);
+    this.#revision += 1;
     this.#building.clear();
     this.#logger.verbose(`[route-cache] cleared generation=${nextGeneration} dropped=${dropped.length}`);
     return dropped;
@@ -209,6 +222,7 @@ export class RouteClientCache {
       ),
     };
     this.merged = next;
+    this.#revision += 1;
   }
 
   static #normalizePath(filePath: string): string {

package/server/assetEncoding.ts

@@ -0,0 +1,47 @@
+const COMPRESSIBLE_TYPES = new Set([
+  "application/javascript",
+  "application/json",
+  "application/manifest+json",
+  "image/svg+xml",
+]);
+
+/**
+ * br is tried first: it is ~15% smaller than gzip across the artifact and ~22% on the CSS bundle.
+ * The gzip sidecar stays the fallback because browsers only advertise `br` on secure origins, so a
+ * plain-http dev server or an intermediary that rewrites Accept-Encoding still gets a compressed body.
+ */
+const SIDECAR_ENCODINGS = [
+  { encoding: "br", ext: ".br", accept: /(?:^|,)\s*(?:br|\*)(?![\w-])\s*(?:;\s*q=([\d.]+))?/i },
+  { encoding: "gzip", ext: ".gz", accept: /(?:^|,)\s*(?:gzip|\*)(?![\w-])\s*(?:;\s*q=([\d.]+))?/i },
+] as const;
+
+export interface EncodedSidecar {
+  bytes: ArrayBuffer;
+  encoding: string;
+}
+
+export const isCompressibleContentType = (contentType: string): boolean => {
+  const type = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  return type.startsWith("text/") || COMPRESSIBLE_TYPES.has(type);
+};
+
+/** Picks the best precompressed sidecar the caller accepts, or null to serve the file as-is. */
+export const resolveEncodedSidecar = async (
+  req: Request,
+  filePath: string,
+  contentType: string,
+): Promise<EncodedSidecar | null> => {
+  if (!isCompressibleContentType(contentType)) return null;
+  const acceptEncoding = req.headers.get("accept-encoding") ?? "";
+  for (const { encoding, ext, accept } of SIDECAR_ENCODINGS) {
+    const match = accept.exec(acceptEncoding);
+    
+    if (!match || (match[1] !== undefined && Number.parseFloat(match[1]) <= 0)) continue;
+    const file = Bun.file(`${filePath}${ext}`);
+    if (!(await file.exists())) continue;
+    const bytes = await file.bytes();
+    const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer;
+    return { bytes: buffer, encoding };
+  }
+  return null;
+};

package/server/di/diLifecycle.ts

@@ -473,7 +473,7 @@ export class DiLifecycle {
       );
     }
 
-    this.#cascade.seal((refName) => this.getService(refName));
+    this.#cascade.seal((refName: string) => this.getService(refName));
   }
 
   async #initializeInternal() {

package/server/index.ts

@@ -9,8 +9,7 @@ export * from "./devtools";
 export type { ChangeBatch, ChangeKind } from "./hmr/changeBatch";
 export * from "./processMetricsCollector";
 export * from "./proxy";
-export * from "./routeElementComposer";
-export * from "./routeTreeBuilder";
+
 export * from "./sitemap";
 export type { SsrManifest, SsrManifestEntry } from "./ssrTypes";
 export * from "./types";

package/server/resolver/signal.resolver.ts

@@ -429,10 +429,15 @@ export class SignalResolver {
     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);
+    if (cached) return cached;
     const fields = (constant as { [FIELD_META]?: Record<string, unknown> })[FIELD_META];
     if (!fields) return undefined;
-    return Object.fromEntries(Object.keys(fields).map((field) => [field, true]));
+    const select = Object.fromEntries(Object.keys(fields).map((field) => [field, true] as const));
+    SignalResolver.#selectCache.set(constant, select);
+    return select;
   }
 
   static #canUsePrimitiveQueryFastPath(endpointInfo: EndpointInfo, middleware: Map<string, MiddlewareCls>) {

package/server/webRouter.ts

@@ -20,6 +20,7 @@ import {
   RouteSeedIndexStore,
   RoutesManifestStore,
 } from "./artifact";
+import { resolveEncodedSidecar } from "./assetEncoding";
 import {
   getClientFacingOrigin,
   hasRouteCacheInvalidationScope,
@@ -297,6 +298,7 @@ export class WebRouter {
   #htmlCacheHits = 0;
   #htmlCacheMisses = 0;
   #htmlCacheBypass = 0;
+  #runtimeManifest: { revision: number; manifest: MergedManifest } | null = null;
   renderState: RenderState;
   #seedIndex: RouteSeedIndex;
   constructor({ artifact, cssBytesByUrl, rsc, seedIndex, upgradeHmrWs }: WebRouterOptions) {
@@ -340,7 +342,7 @@ export class WebRouter {
     if (prebuilt) {
       this.#routeCache.seed(prebuilt);
       await this.#rsc.reload({
-        clientManifest: this.#mergeRuntimeManifest(this.#routeCache.merged).clientManifest,
+        clientManifest: this.#mergeRuntimeManifest().clientManifest,
         cssAssets: this.renderState.cssAssets,
         buildId: this.renderState.buildId,
       });
@@ -813,15 +815,27 @@ export class WebRouter {
     this.#logger.verbose(
       `[route-cache] ensure pathname=${url.pathname} routeId=${matched?.entry.routeId ?? "(none)"} in ${Date.now() - started}ms`,
     );
-    return this.#mergeRuntimeManifest(this.#routeCache.snapshot());
+    return this.#mergeRuntimeManifest();
   }
 
-  #mergeRuntimeManifest(manifest: MergedManifest): MergedManifest {
-    return {
-      ...manifest,
-      clientManifest: WebRouter.#mergeClientManifest(this.#artifact.rscRuntimeClientManifest, manifest.clientManifest),
-      ssrManifest: WebRouter.#mergeSsrManifest(this.#artifact.rscRuntimeSsrManifest, manifest.ssrManifest),
+  /**
+   * Memoized on the route cache's revision. Both the snapshot and the runtime merge copy the whole client manifest
+   * and SSR module map, which is a few hundred KB of structure for a small app — and this ran on every request. In
+   * production the revision never moves after `seed`, so the manifest is built once; in dev a rebuild bumps it and
+   * the next request pays for one fresh copy. The cached object is still a copy, so an in-flight request keeps
+   * consuming a stable manifest across an invalidate exactly as the per-request snapshot made it.
+   */
+  #mergeRuntimeManifest(): MergedManifest {
+    const revision = this.#routeCache.revision;
+    if (this.#runtimeManifest?.revision === revision) return this.#runtimeManifest.manifest;
+    const snapshot = this.#routeCache.snapshot();
+    const manifest: MergedManifest = {
+      ...snapshot,
+      clientManifest: WebRouter.#mergeClientManifest(this.#artifact.rscRuntimeClientManifest, snapshot.clientManifest),
+      ssrManifest: WebRouter.#mergeSsrManifest(this.#artifact.rscRuntimeSsrManifest, snapshot.ssrManifest),
     };
+    this.#runtimeManifest = { revision, manifest };
+    return manifest;
   }
   #renderSystemNotFoundFallbackResponse(req: Request, url: URL): Promise<Response> {
     return createSystemPageResponse({
@@ -1101,16 +1115,12 @@ export class WebRouter {
     headers.set("Last-Modified", new Date(lastModifiedMs).toUTCString());
     if (WebRouter.#isNotModified(req, etag, lastModifiedMs)) return new Response(null, { status: 304, headers });
 
-    const gzipPath = `${filePath}.gz`;
-    if (WebRouter.#acceptsGzip(req) && WebRouter.#isCompressible(options.contentType)) {
-      const gzipFile = Bun.file(gzipPath);
-      if (await gzipFile.exists()) {
-        const gzipBytes = await gzipFile.bytes();
-        headers.set("Content-Encoding", "gzip");
-        headers.set("Content-Length", String(gzipBytes.byteLength));
-        headers.set("Vary", "Accept-Encoding");
-        return new Response(WebRouter.#toArrayBuffer(gzipBytes), { headers });
-      }
+    const sidecar = await resolveEncodedSidecar(req, filePath, options.contentType);
+    if (sidecar) {
+      headers.set("Content-Encoding", sidecar.encoding);
+      headers.set("Content-Length", String(sidecar.bytes.byteLength));
+      headers.set("Vary", "Accept-Encoding");
+      return new Response(sidecar.bytes, { headers });
     }
 
     return new Response(file.stream(), { headers });
@@ -1197,22 +1207,6 @@ export class WebRouter {
     return Number.isFinite(sinceMs) && sinceMs >= lastModifiedMs;
   }
 
-  static #acceptsGzip(req: Request): boolean {
-    const acceptEncoding = req.headers.get("accept-encoding") ?? "";
-    return /\bgzip\b/.test(acceptEncoding);
-  }
-
-  static #isCompressible(contentType: string): boolean {
-    const type = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
-    return (
-      type.startsWith("text/") ||
-      type === "application/javascript" ||
-      type === "application/json" ||
-      type === "application/manifest+json" ||
-      type === "image/svg+xml"
-    );
-  }
-
   static #safeResolve(baseDir: string, urlPath: string): string | null {
     let decoded: string;
     try {

package/service/predefinedAdaptor/database.adaptor.ts

@@ -119,7 +119,7 @@ export interface DocumentStore {
   exists(query?: DocumentQuery): Promise<string | null>;
   count(query?: DocumentQuery): Promise<number>;
   insight(query?: DocumentQuery): Promise<any>;
-  hydrate(data: DocumentRecord, originalData?: DocumentRecord): any;
+  hydrate(data: DocumentRecord, originalData?: DocumentRecord, options?: { track?: boolean }): any;
 }
 
 export interface SqlResultRows<Row = Record<string, unknown>> {
@@ -960,6 +960,17 @@ class UpdateCompiler {
   }
 }
 
+/**
+ * Per-document modification state, attached only when a document is hydrated for writing.
+ * Non-enumerable so `{ ...doc }` in `toRow` and `Object.entries` in `sanitizeJson` never see it.
+ */
+const MODIFICATION_STATE = Symbol("akan.document.modificationState");
+
+interface ModificationState {
+  isNew: boolean;
+  original: Record<string, unknown>;
+}
+
 export class SqlDocumentStore {
   readonly schema: DocumentSchema;
   readonly table: string;
@@ -967,6 +978,7 @@ export class SqlDocumentStore {
   readonly updateCompiler: UpdateCompiler;
   #insertStmt: AkanSqlStatement | null = null;
   #readStmtCache = new Map<string, AkanSqlStatement>();
+  #docPrototype: object | null = null;
 
   constructor(
     private readonly owner: DocumentDatabaseOwner,
@@ -1133,14 +1145,14 @@ export class SqlDocumentStore {
       const rows = await this.prepareReadStmt(
         `SELECT ${this.projectionSql(projection)} FROM ${quoteIdent(this.table)}${join} WHERE ${where} ${order}${limit}${offset}`,
       ).all<ProjectedSqliteDocumentRow>(...args);
-      return rows.map((row) => this.hydrate(this.fromProjectedRow(row, projection)));
+      return rows.map((row) => this.hydrate(this.fromProjectedRow(row, projection), undefined, { track: false }));
     }
 
     const star = joins.length ? `${quoteIdent(this.table)}.*` : "*";
     const rows = await this.prepareReadStmt(
       `SELECT ${star} FROM ${quoteIdent(this.table)}${join} WHERE ${where} ${order}${limit}${offset}`,
     ).all<SqliteDocumentRow>(...args);
-    return rows.map((row) => this.hydrate(this.fromRow(row)));
+    return rows.map((row) => this.hydrate(this.fromRow(row), undefined, { track: false }));
   }
 
   async findIds(
@@ -1588,49 +1600,82 @@ export class SqlDocumentStore {
     return result;
   }
 
-  hydrate(data: DocumentRecord, originalData: DocumentRecord = data) {
-    const store = this;
-    const original = JSON.parse(JSON.stringify(sanitizeJson(originalData) ?? {})) as Record<string, unknown>;
+  /**
+   * `track` buys `isModified()` and costs a deep clone of the row, so it is decided per call site rather than
+   * paid everywhere. Only the read paths (`find`, and the projected read behind it) opt out — that clone was 42%
+   * of a list query, and a listed document is never the one a save hook runs on. Everything else keeps it, so an
+   * external caller of `hydrate` sees no change.
+   */
+  hydrate(data: DocumentRecord, originalData: DocumentRecord = data, { track = true }: { track?: boolean } = {}) {
     const isNew = !originalData.id;
     const hydratedData = isNew ? this.prepareDocument(data) : data;
-    const doc = Object.assign(Object.create(this.database.doc.prototype), hydratedData);
-    Object.defineProperties(doc, {
+    const doc = Object.assign(Object.create(this.#documentPrototype()), hydratedData);
+    if (!track) return doc;
+    Object.defineProperty(doc, MODIFICATION_STATE, {
+      value: {
+        isNew,
+
+        original: JSON.parse(JSON.stringify(sanitizeJson(originalData) ?? {})) as Record<string, unknown>,
+      } satisfies ModificationState,
+    });
+    return doc;
+  }
+
+  /**
+   * One prototype per store instead of six closures per document. It extends the model's own document prototype,
+   * so declared chain methods and `instanceof` are unaffected, and every method here is non-enumerable exactly as
+   * the previous per-document `defineProperties` made them.
+   */
+  #documentPrototype() {
+    if (this.#docPrototype) return this.#docPrototype;
+    const store = this;
+    this.#docPrototype = Object.create(this.database.doc.prototype, {
       set: {
-        value(patch: DocumentRecord) {
+        value(this: DocumentRecord, patch: DocumentRecord) {
           Object.assign(this, patch);
           return this;
         },
       },
       save: {
-        async value() {
-          return this.id ? store.update(this.id, this) : store.create(this);
+        async value(this: DocumentRecord) {
+          return this.id ? store.update(this.id as string, this) : store.create(this);
         },
       },
       refresh: {
-        async value() {
-          Object.assign(this, await store.pickById(this.id));
+        async value(this: DocumentRecord) {
+          Object.assign(this, await store.pickById(this.id as string));
           return this;
         },
       },
       isModified: {
-        value(field?: string) {
-          if (isNew) return true;
-          if (!field) return JSON.stringify(sanitizeJson(this)) !== JSON.stringify(original);
-          return JSON.stringify(sanitizeJson(this[field])) !== JSON.stringify(original[field]);
+        value(this: DocumentRecord & { [MODIFICATION_STATE]?: ModificationState }, field?: string) {
+          const state = this[MODIFICATION_STATE];
+          if (!state) throw new Error(SqlDocumentStore.#untrackedModificationMessage(store.table));
+          if (state.isNew) return true;
+          if (!field) return JSON.stringify(sanitizeJson(this)) !== JSON.stringify(state.original);
+          return JSON.stringify(sanitizeJson(this[field])) !== JSON.stringify(state.original[field]);
         },
       },
       toJSON: {
-        value() {
+        value(this: DocumentRecord) {
           return sanitizeJson(this);
         },
       },
       toObject: {
-        value() {
+        value(this: DocumentRecord) {
           return sanitizeJson(this);
         },
       },
-    });
-    return doc;
+    }) as object;
+    return this.#docPrototype;
+  }
+
+  static #untrackedModificationMessage(table: string) {
+    return (
+      `isModified() is unavailable on this ${table} document: it was loaded through a read query, which does not ` +
+      `snapshot the row. Call it inside a save hook, or re-load the document through the write path (\`save()\`, ` +
+      `\`update()\`) before comparing.`
+    );
   }
 
   private async runHooks(

package/signal/middleware.ts

@@ -1,4 +1,5 @@
 import type { BaseEnv, Cls, PromiseOrObject } from "akanjs/base";
+import { Logger } from "akanjs/common";
 import { type CacheAdaptor, CacheAdaptorRole } from "akanjs/service";
 import dayjs from "dayjs";
 import type { SignalContext } from "./signalContext";
@@ -25,11 +26,14 @@ export class Logging extends middleware("logging") {
   override async use() {
     return async (context: SignalContext, next: () => Promise<unknown>) => {
       const start = Date.now();
-      context.adaptor.logger.debug(`Before ${context.endpointInfo.type}-${context.key} / ${start}`);
+
+      const debug = Logger.shouldLog("debug");
+      if (debug) context.adaptor.logger.debug(`Before ${context.endpointInfo.type}-${context.key} / ${start}`);
       try {
         const result = await next();
-        const duration = Date.now() - start;
-        context.adaptor.logger.debug(`After ${context.endpointInfo.type}-${context.key} / ${duration}ms`);
+        if (debug) {
+          context.adaptor.logger.debug(`After ${context.endpointInfo.type}-${context.key} / ${Date.now() - start}ms`);
+        }
         return result;
       } catch (error) {
         const duration = Date.now() - start;

package/signal/signalContext.ts

@@ -18,6 +18,7 @@ import type { Adaptor, AdaptorCls, DatabaseService, InjectRegistry, LiveRegistry
 import type { Internal, InternalCls, InternalInfo, MiddlewareCls } from ".";
 import type { EndpointInfo } from "./endpointInfo";
 import { Exception } from "./exception";
+import type { Guard, GuardCls } from "./guard";
 import { isTraceEnabled, runWithTrace, SignalTrace, traceSpan } from "./trace";
 
 export type SignalTransportType = "http" | "websocket";
@@ -28,6 +29,7 @@ interface WebSocketRequest {
   eventType: WebSocketEventType;
 }
 type RuntimeRecord = Record<string, unknown>;
+type MiddlewareHandler = (context: SignalContext, next: () => Promise<unknown>) => PromiseOrObject<unknown>;
 
 interface ExceptionLike {
   statusCode: number;
@@ -114,13 +116,25 @@ export class SignalContext<
     }
     return this;
   }
+  /**
+   * Guards read everything from the context they are handed and are already required to be side-effect free and
+   * safe to re-run — `SignalResolver.revalidateWsRooms` re-runs them outside of any request — so one instance per
+   * class serves every call instead of one per guard per request.
+   */
+  static #guards = new WeakMap<GuardCls, Guard>();
+  static #getGuard(GuardCls: GuardCls): Guard {
+    const cached = SignalContext.#guards.get(GuardCls);
+    if (cached) return cached;
+    const guard = new GuardCls();
+    SignalContext.#guards.set(GuardCls, guard);
+    return guard;
+  }
   async #checkGuards() {
     const guards = this.endpointInfo.signalOption.guards ?? [];
     if (guards.length === 0) return;
     await Promise.all(
       guards.map(async (GuardCls) => {
-        const guard = new GuardCls();
-        const canPass = await guard.canPass(this);
+        const canPass = await SignalContext.#getGuard(GuardCls).canPass(this);
         if (!canPass) throw new Exception.Forbidden(`Access denied by guard: ${GuardCls.name}`);
       }),
     );
@@ -151,12 +165,34 @@ export class SignalContext<
     for (let i = middlewares.length - 1; i >= 0; i--) {
       const MiddlewareCls = middlewares[i];
       if (!MiddlewareCls) continue;
-      const middleware = new MiddlewareCls();
       const currentNext = next;
-      next = async () => await (await middleware.use(this.getEnv()))(this, currentNext);
+      next = async () =>
+        await (await SignalContext.#getMiddlewareHandler(MiddlewareCls, this.getEnv()))(this, currentNext);
     }
     return next;
   }
+  /**
+   * `use(env)` takes no context, so the instance and the handler it returns are a function of `(class, env)` and
+   * hold for the life of the process. Building both per request cost an instance, a handler and a closure on every
+   * call for every registered middleware — and `Logging` is registered by default.
+   */
+  static #middlewareHandlers = new WeakMap<MiddlewareCls, WeakMap<object, Promise<MiddlewareHandler>>>();
+  static #getMiddlewareHandler(MiddlewareCls: MiddlewareCls, env: BaseEnv): Promise<MiddlewareHandler> {
+    const byEnv =
+      SignalContext.#middlewareHandlers.get(MiddlewareCls) ?? new WeakMap<object, Promise<MiddlewareHandler>>();
+    SignalContext.#middlewareHandlers.set(MiddlewareCls, byEnv);
+    const cached = byEnv.get(env);
+    if (cached) return cached;
+
+    const handler = Promise.resolve(new MiddlewareCls().use(env) as PromiseOrObject<MiddlewareHandler>).catch(
+      (error: unknown) => {
+        byEnv.delete(env);
+        throw error;
+      },
+    );
+    byEnv.set(env, handler);
+    return handler;
+  }
   async exec() {
     if (!this.trace) return await this.#exec();
     return await runWithTrace(this.trace, async () => {

package/types/common/Logger.d.ts

@@ -17,6 +17,8 @@ export declare class Logger {
     static removeSink(sink: LoggerSink): void;
     static setFileLevel(level: LogLevel): void;
     static isVerbose(): boolean;
+    /** For hot-path callers that would otherwise build a message the level is about to discard. */
+    static shouldLog(logLevel: LogLevel): boolean;
     name?: string;
     constructor(name?: string);
     trace(msg: string, context?: string, name?: string): void;

package/types/constant/fieldInfo.d.ts

@@ -114,6 +114,7 @@ export type FieldInfoObjectToFieldObject<Obj extends FieldInfoObject> = {
 export declare class ConstantField<FieldType extends ConstantFieldKind = ConstantFieldKind, Value extends ConstantFieldTypeInput | null = any, FieldValue = any, MapValue = any, Nullable extends boolean = boolean, IsRelation extends boolean = boolean, IsEnum extends boolean = boolean, IsPrimitive extends boolean = boolean, IsScalar extends boolean = boolean, IsHidden extends boolean = boolean, IsSecret extends boolean = boolean, IsMap extends boolean = boolean, Metadata = {
     [key: string]: any;
 }> implements ConstantFieldBuildProps<FieldType, FieldValue, MapValue, Metadata> {
+    #private;
     static getBaseModelField(): FieldObject;
     static getBaseInsightField(): FieldObject;
     readonly nullable: Nullable;

package/types/constant/getDefault.d.ts

@@ -1,3 +1,8 @@
 import type { FieldObject } from ".";
 import type { DefaultOf } from "./types.d.ts";
+/**
+ * The split is what keeps this faithful: `default: () => dayjs()` still means "now" on every call, and an array
+ * or nested-scalar default is still a fresh object, so two documents filled from the same model never end up
+ * sharing one. Only values that were already shared before this cache existed live in `shared`.
+ */
 export declare const getDefault: <T>(fieldObj: FieldObject) => DefaultOf<T>;

package/types/server/artifact/routeClientCache.d.ts

@@ -35,6 +35,12 @@ export declare class RouteClientCache {
     #private;
     merged: MergedManifest;
     constructor({ buildRoute, onMerge }: RouteClientCacheOptions);
+    /**
+     * Bumped on every mutation of `merged`, including a delta merge that leaves `generation` where it was. It lets a
+     * consumer memoize work derived from the manifest — merging the runtime manifest over it, say — without having to
+     * copy the manifest to find out whether anything changed. In production nothing after `seed` moves it at all.
+     */
+    get revision(): number;
     seed(manifest: RoutesManifest): void;
     ensure(routeId: string, seeds: string[]): Promise<MergedManifest>;
     snapshot(): MergedManifest;

package/types/server/assetEncoding.d.ts

@@ -0,0 +1,7 @@
+export interface EncodedSidecar {
+    bytes: ArrayBuffer;
+    encoding: string;
+}
+export declare const isCompressibleContentType: (contentType: string) => boolean;
+/** Picks the best precompressed sidecar the caller accepts, or null to serve the file as-is. */
+export declare const resolveEncodedSidecar: (req: Request, filePath: string, contentType: string) => Promise<EncodedSidecar | null>;

package/types/server/index.d.ts

@@ -9,8 +9,6 @@ export * from "./devtools.d.ts";
 export type { ChangeBatch, ChangeKind } from "./hmr/changeBatch.d.ts";
 export * from "./processMetricsCollector.d.ts";
 export * from "./proxy.d.ts";
-export * from "./routeElementComposer.d.ts";
-export * from "./routeTreeBuilder.d.ts";
 export * from "./sitemap.d.ts";
 export type { SsrManifest, SsrManifestEntry } from "./ssrTypes.d.ts";
 export * from "./types.d.ts";

package/types/service/predefinedAdaptor/database.adaptor.d.ts

@@ -97,7 +97,9 @@ export interface DocumentStore {
     exists(query?: DocumentQuery): Promise<string | null>;
     count(query?: DocumentQuery): Promise<number>;
     insight(query?: DocumentQuery): Promise<any>;
-    hydrate(data: DocumentRecord, originalData?: DocumentRecord): any;
+    hydrate(data: DocumentRecord, originalData?: DocumentRecord, options?: {
+        track?: boolean;
+    }): any;
 }
 export interface SqlResultRows<Row = Record<string, unknown>> {
     rows: Row[];
@@ -384,7 +386,15 @@ export declare class SqlDocumentStore {
     private decodeNestedValue;
     private normalizeWriteValue;
     private fillScalarDefaults;
-    hydrate(data: DocumentRecord, originalData?: DocumentRecord): any;
+    /**
+     * `track` buys `isModified()` and costs a deep clone of the row, so it is decided per call site rather than
+     * paid everywhere. Only the read paths (`find`, and the projected read behind it) opt out — that clone was 42%
+     * of a list query, and a listed document is never the one a save hook runs on. Everything else keeps it, so an
+     * external caller of `hydrate` sees no change.
+     */
+    hydrate(data: DocumentRecord, originalData?: DocumentRecord, { track }?: {
+        track?: boolean;
+    }): any;
     private runHooks;
     private insertStmt;
     private prepareReadStmt;

package/ui/Field.tsx

@@ -733,7 +733,7 @@ const Date = <Nullable extends boolean>({
   return (
     <div className={cn("flex flex-col", className)}>
       {label ? <Label className={labelClassName} nullable={nullable} label={label} desc={desc} /> : null}
-      {/* //! daysi UI datetime-local 컴포넌트에 max 값 넣으면 오른쪽 끝 짤리는 버그 있음.*/}
+      {/* FIXME: daysi UI datetime-local 컴포넌트에 max 값 넣으면 오른쪽 끝 짤리는 버그 있음.*/}
       <input
         type={showTime ? "datetime-local" : "date"}
         className={cn(