akanjs 3.0.0-alpha.3 → 3.0.0-alpha.4

package/base/symbols.ts

@@ -3,7 +3,6 @@ export const SLICE_META = Symbol.for("akan.slice");
 export const FILTER_META = Symbol.for("akan.filter");
 export const LOADER_META = Symbol.for("akan.loader");
 export const INJECT_META = Symbol.for("akan.inject");
-export const LIBS_REMOVE_HOOK = Symbol.for("akan.service.libsRemoveHook");
 export const ENDPOINT_META = Symbol.for("akan.endpoint");
 export const ENDPOINT_DICT_SHAPE: unique symbol = Symbol.for("akan.endpoint.dictShape") as never;
 export const SLICE_DICT_SHAPE: unique symbol = Symbol.for("akan.slice.dictShape") as never;

package/client/cn.ts

@@ -38,10 +38,17 @@ export const colorTokens = [
   "ring",
 ];
 
+/**
+ * Akan's semantic radius tokens (`--radius-box` / `--radius-field` in ui/styles.css). Without them
+ * `cn("rounded-field", "rounded-full")` keeps both classes and stylesheet order decides the winner.
+ */
+export const radiusTokens = ["box", "field"];
+
 const twMerge = extendTailwindMerge({
   extend: {
     theme: {
       color: colorTokens,
+      radius: radiusTokens,
     },
   },
 });

package/client/csrTypes.ts

@@ -455,6 +455,7 @@ export interface FrameLayoutState {
   keyboard: KeyboardFrameState;
   contentViewport: FrameContentViewportState;
   keyboardAccessory: KeyboardAccessoryFrameState;
+  contentAnchor?: "bottom";
   platformProfile: FramePlatformProfile;
   zIndex: FrameLayerZIndex;
   pageStateByPath: Map<string, PageState>;
@@ -463,6 +464,7 @@ export interface FrameSlotRegistration {
   scope?: FrameSlotScope;
   type: FrameSlotType;
   role?: FrameSlotRole;
+  contentAnchor?: "bottom";
   height?: number;
   estimatedHeight?: number;
   source?: "navbar" | "topInset" | "bottomInset" | "bottomTab" | (string & {});

package/client/frameDebug.ts

@@ -20,9 +20,10 @@ const isFrameDebugEnabled = () => {
 export function debugFrame(event: string, payload: DebugPayload = {}) {
   if (!isFrameDebugEnabled()) return;
   debugSeq += 1;
-  console.info(`[akan:frame:${debugSessionId}:${debugSeq}] ${event}`, {
+  const details = {
     href: window.location.href,
     now: Math.round(performance.now()),
     ...payload,
-  });
+  };
+  console.info(`[akan:frame:${debugSessionId}:${debugSeq}] ${event}`, details, JSON.stringify(details));
 }

package/constant/cascadePaths.ts

@@ -1,103 +1,32 @@
-import { type Cls, PrimitiveRegistry, type PrimitiveScalar } from "akanjs/base";
 import type { ConstantField, FieldObject } from "./fieldInfo";
 import type { ConstantModelRef } from "./via";
 
-/**
- * Which end of a relation goes away with the other. `removeRef` removes what the field points at when this
- * document is removed; `removeWith` removes this document when what the field points at is removed. The two
- * read identically on a relation field, so the value has to name the direction — a mistake here is a data loss.
- */
-export const cascadeActions = ["removeRef", "removeWith"] as const;
+/** What happens to the documents a relation field points at when the owner is removed. */
+export const cascadeActions = ["remove"] as const;
 export type CascadeAction = (typeof cascadeActions)[number];
 
-/** How a `removeWith` field names the owner whose removal takes this document with it. */
-export interface CascadeWithPath {
-  readonly key: string;
-  /** Set when the field is a relation. Resolved to a refName later: the owner may not be registered yet. */
-  readonly modelRef: ConstantModelRef | null;
-  /** Set when the field declares `ref`, which names the owner at declaration. */
-  readonly refName: string | null;
-  /** Set when the field declares `refPath`: the sibling field holding the owner's refName. */
-  readonly typeKey: string | null;
-  /** The refNames `typeKey` may hold. Empty unless the field is polymorphic. */
-  readonly typeValues: readonly string[];
-}
-
-const idNames = new Set(["ID", "String"]);
-
 export class CascadePaths {
-  /** Field key → the model its ids point at, removed when this document is. */
-  readonly removeRef = new Map<string, ConstantModelRef>();
-  /** Field key → the owner whose removal removes this document. */
-  readonly removeWith = new Map<string, CascadeWithPath>();
+  /** Field key → the model its ids point at. Resolved to a refName later: the target may not be registered yet. */
+  readonly remove = new Map<string, ConstantModelRef>();
 
   collect(fieldMap: FieldObject) {
     for (const [key, field] of Object.entries(fieldMap)) {
       if (!field.cascade) continue;
-      this.#assertKnownAction(key, field.cascade);
-      if (field.cascade === "removeRef") this.removeRef.set(key, this.#readOwnedRelation(key, field));
-      else this.removeWith.set(key, this.#readOwnerPath(key, field, fieldMap));
+      this.#assertCascadable(key, field.cascade, field);
+      this.remove.set(key, field.modelRef);
     }
     return this;
   }
 
-  #assertKnownAction(key: string, action: CascadeAction) {
-
+  #assertCascadable(key: string, action: CascadeAction, field: ConstantField) {
+    
     if (!cascadeActions.includes(action)) {
       throw new Error(`Cascade field "${key}" declares cascade: "${action}", which is not one of ${cascadeActions}`);
     }
-  }
-
-  #readOwnedRelation(key: string, field: ConstantField) {
     
     if (!field.isClass || field.isScalar) {
       throw new Error(`Cascade field "${key}" is not a model reference and has no document to remove`);
     }
     if (field.arrDepth > 1) throw new Error(`Cascade field "${key}" is a nested array and cannot cascade`);
-    return field.modelRef;
-  }
-
-  #readOwnerPath(key: string, field: ConstantField, fieldMap: FieldObject): CascadeWithPath {
-
-    if (field.arrDepth > 0) throw new Error(`Cascade field "${key}" is an array and names more than one owner`);
-    if (field.isMap) throw new Error(`Cascade field "${key}" is a Map and names no owner`);
-    if (field.refPath) return this.#readPolymorphicOwner(key, field, fieldMap);
-    if (field.ref) {
-      this.#assertHoldsId(key, field);
-      return { key, modelRef: null, refName: field.ref, typeKey: null, typeValues: [] };
-    }
-    if (field.isClass && !field.isScalar) {
-      return { key, modelRef: field.modelRef, refName: null, typeKey: null, typeValues: [] };
-    }
-    throw new Error(
-      `Cascade field "${key}" declares cascade: "removeWith" but names no owner; make it a model reference, ` +
-        `or add ref: "<model>" / refPath: "<typeField>"`,
-    );
-  }
-
-  #readPolymorphicOwner(key: string, field: ConstantField, fieldMap: FieldObject): CascadeWithPath {
-    if (field.ref) throw new Error(`Cascade field "${key}" declares both ref and refPath; keep one`);
-    this.#assertHoldsId(key, field);
-    const typeKey = field.refPath as string;
-    const typeField = fieldMap[typeKey];
-    if (!typeField) throw new Error(`Cascade field "${key}" declares refPath: "${typeKey}", which is not a field`);
-
-    if (!typeField.enum) {
-      throw new Error(
-        `Cascade field "${key}" declares refPath: "${typeKey}", which must be an enumOf(...) naming the owner ` +
-          `refNames it may hold`,
-      );
-    }
-    const typeValues = typeField.enum.values.map((value) => String(value));
-    return { key, modelRef: null, refName: null, typeKey, typeValues };
-  }
-
-  #assertHoldsId(key: string, field: ConstantField) {
-    const modelRef = field.modelRef as unknown as Cls;
-    const refName = PrimitiveRegistry.has(modelRef)
-      ? PrimitiveRegistry.getName(modelRef as unknown as typeof PrimitiveScalar)
-      : null;
-    if (refName && idNames.has(refName)) return;
-    throw new Error(`Cascade field "${key}" declares ref or refPath and must hold an ID`);
   }
 }

package/document/database.ts

@@ -3,9 +3,8 @@ import { Logger } from "akanjs/common";
 import type { DocumentModel, QueryOf } from "akanjs/constant";
 import type { CacheAdaptor, CacheSetOptions } from "akanjs/service";
 import type { DataLoader } from "./dataLoader";
-import type { DocumentUpdateInput } from "./documentQuery";
 import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta";
-import type { CRUDEventType, Mdl, SaveEventType, UpdateResult } from "./into";
+import type { CRUDEventType, Mdl, SaveEventType } from "./into";
 import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types";
 
 export class CacheDatabase<T = unknown> {
@@ -26,15 +25,6 @@ export class CacheDatabase<T = unknown> {
     await this.cache.delete(this.refName, `${topic}:${key}`);
   }
 }
-/**
- * What `update<Filter>` returns. The patch cannot be a trailing parameter — a filter's own args may be optional,
- * and no tuple type puts a required element after those — and leading it reads backwards. So it lands here, on a
- * terminal `.set()` that mirrors the `UPDATE … SET …` it compiles to.
- */
-export interface UpdateChain<Doc = any> {
-  set(update: DocumentUpdateInput<Doc>): Promise<UpdateResult>;
-}
-
 type QueryMethodOfKey<
   CapitalizedK extends string,
   Doc,
@@ -63,14 +53,6 @@ type QueryMethodOfKey<
   [K in `insight${CapitalizedK}`]: (...args: _Args) => Promise<Insight>;
 } & {
   [K in `query${CapitalizedK}`]: (...args: _Args) => _QueryOfDoc;
-} & {
-  [K in `remove${CapitalizedK}`]: (...args: _Args) => Promise<UpdateResult>;
-} & {
-  [K in `removeOne${CapitalizedK}`]: (...args: _Args) => Promise<UpdateResult>;
-} & {
-  [K in `update${CapitalizedK}`]: (...args: _Args) => UpdateChain<Doc>;
-} & {
-  [K in `updateOne${CapitalizedK}`]: (...args: _Args) => UpdateChain<Doc>;
 };
 type QueryMethodMap<Query, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc> = {
   [K in keyof Query]: K extends string
@@ -123,10 +105,6 @@ type DatabaseModelWithQuerySort<
   __create: (data: _DataInput) => Promise<Doc>;
   __update: (id: string, data: Partial<Doc>) => Promise<Doc>;
   __remove: (id: string) => Promise<Doc>;
-  __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
-  __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
-  __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
-  __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
   __list(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;
   __listIds(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<string[]>;
   __find(query: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc | null>;

package/document/databaseRegistry.ts

@@ -19,7 +19,7 @@ export interface DatabaseModel<
   model: ModelCls<Model>;
   filter: FilterCls<Filter>;
   obj: ConstantCls<Obj>;
-  insight: DatabaseCls<Insight>;
+  insight: ConstantCls<Insight>;
   _Input: Input;
   _Doc: Doc;
   _Model: Model;
@@ -92,7 +92,7 @@ export class DatabaseRegistry {
     doc: DatabaseCls<Doc>,
     model: ModelCls<Model>,
     obj: ConstantCls<Obj>,
-    insight: DatabaseCls<Insight>,
+    insight: ConstantCls<Insight>,
     filter: FilterCls<Filter>,
   ): DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter, _Query, _Sort> {
     const dbInfo = {

package/document/filterMeta.ts

@@ -98,13 +98,6 @@ export const fillMissingFilterArgs = (filterInfo: FilterInfo, args: unknown[]) =
   return [...args, ...Array(filterInfo.args.length - args.length).fill(undefined)];
 };
 
-export const assertFilterFitsCrud = (refName: string, queryKey: string, className: string) => {
-  if (queryKey.toLowerCase() !== refName.toLowerCase()) return;
-  throw new Error(
-    `Filter "${queryKey}" on "${refName}" generates remove${className}/update${className}, which are the generated CRUD methods; rename the filter`,
-  );
-};
-
 export type BaseFilterSortKey = "latest" | "oldest" | "relevance";
 export type BaseFilterQueryKey = "any";
 export type BaseFilterKey = BaseFilterSortKey | BaseFilterQueryKey;

package/document/into.ts

@@ -77,27 +77,22 @@ export type Mdl<
   find(query: _RawQuery, projection?: _Projection): FindManyChain<Doc>;
   findOne(query: _RawQuery, projection?: _Projection): FindOneChain<Doc>;
   findById(id: string | undefined, projection?: _Projection): Promise<Doc | null>;
-  count(query: _RawQuery): Promise<number>;
+  countDocuments(query: _RawQuery): Promise<number>;
   exists(query: _RawQuery): Promise<string | null>;
-
   updateOne(
     query: _RawQuery,
     update: DocumentUpdateInput<_RawDoc>,
     options?: DocumentUpdateOptions,
   ): Promise<UpdateResult>;
   updateMany(query: _RawQuery, update: DocumentUpdateInput<_RawDoc>): Promise<UpdateResult>;
-  removeOne(query: _RawQuery): Promise<UpdateResult>;
-  removeMany(query: _RawQuery): Promise<UpdateResult>;
+  deleteMany(query: _RawQuery): Promise<UpdateResult>;
   bulkWrite(operations: BulkWriteOperation<Raw, _RawDoc, _RawQuery>[]): Promise<UpdateResult>;
-  /** @deprecated Renamed to `count`. */
-  countDocuments(query: _RawQuery): Promise<number>;
 };
 
-interface IntoConstantModel<T extends string, _CapitalizedRefName extends string, Raw, Insight> {
+interface IntoConstantModel<T extends string, _CapitalizedRefName extends string, Raw> {
   refName: T;
   _CapitalizedRefName: _CapitalizedRefName;
   _Full: Raw;
-  _Insight: Insight;
 }
 type NoInferType<T> = [T][T extends unknown ? 0 : never];
 type IntoModelActions<
@@ -105,8 +100,6 @@ type IntoModelActions<
   _CapitalizedRefName extends string,
   Doc,
   Raw,
-  
-  Insight,
   _Query,
   _Sort,
   _QueryOfDoc = QueryOf<Doc>,
@@ -128,14 +121,13 @@ type IntoModelActions<
   [K in `update${_CapitalizedRefName}`]: (id: string, data: Partial<Doc>) => Promise<Doc>;
 } & {
   [K in `remove${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
-} & QueryMethodPart<_Query, _Sort, Raw, Doc, DocumentModel<Insight>, unknown, unknown, _QueryOfDoc>;
+} & QueryMethodPart<_Query, _Sort, Raw, Doc, unknown, unknown, unknown, _QueryOfDoc>;
 
 export const into = <
   Doc,
   FilterRef extends FilterCls,
   T extends string,
   Raw,
-  Insight,
   AddDbModels extends ModelCls[],
   _CapitalizedRefName extends string,
   _QueryOfDoc = QueryOf<Doc>,
@@ -145,11 +137,11 @@ export const into = <
 >(
   docRef: Cls<Doc>,
   filterRef: FilterRef,
-  cnst: IntoConstantModel<T, _CapitalizedRefName, Raw, Insight>,
+  cnst: IntoConstantModel<T, _CapitalizedRefName, Raw>,
   loaderBuilder: _LoaderBuilder,
   ...addMdls: [...AddDbModels]
 ): ModelCls<
-  IntoModelActions<T, _CapitalizedRefName, Doc, Raw, Insight, _Query, _Sort, _QueryOfDoc>,
+  IntoModelActions<T, _CapitalizedRefName, Doc, Raw, _Query, _Sort, _QueryOfDoc>,
   ReturnType<_LoaderBuilder>
 > => {
   const loaderInfoMap = loaderBuilder(makeLoaderBuilder<Doc>());
@@ -170,7 +162,7 @@ export const into = <
     });
   });
   return DefaultModel as unknown as ModelCls<
-    IntoModelActions<T, _CapitalizedRefName, Doc, Raw, Insight, _Query, _Sort, _QueryOfDoc>,
+    IntoModelActions<T, _CapitalizedRefName, Doc, Raw, _Query, _Sort, _QueryOfDoc>,
     ReturnType<_LoaderBuilder>
   >;
 };

package/package.json

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

package/server/SSR_MEMORY_DIAGNOSIS.md

@@ -23,31 +23,14 @@ Read snapshots from:
 curl http://localhost:8080/_akan/app/metrics
 ```
 
-A replica and its RSC worker are separate processes and are reported separately. **`rssBytes` is the
-replica's own; the worker's is `rscWorkerRssBytes`.** Sum them for what the pod pays.
-
 Key fields:
 
-- `rssBytes`, `heapUsedBytes`, `jscHeapSizeBytes`: the replica. Distinguish RSS-only native retention from JS
-  heap retention.
-- `rscWorkerRssBytes`, `rscWorkerHeapUsedBytes`, `rscWorkerJscHeapSizeBytes`, `rscWorkerJscExtraMemorySizeBytes`:
-  the same for the worker. `jscExtra` is off-heap, mostly typed-array backing stores.
+- `rssBytes`, `heapUsedBytes`, `jscHeapSizeBytes`: distinguish RSS-only native retention from JS heap retention.
 - `rscRenderCount`, `rscInFlightRenderCount`: detect request lifecycle leaks.
 - `rscLoadedRouteModuleCount`, `rscRouteModuleCacheHits`, `rscRouteModuleCacheMisses`: detect route module warm-up.
-- `ssrChunkRegistrySize`, `ssrChunkLoadCount`: full-document SSR client chunk loading. **`…RegistrySize` counts
-  keys, not bytes** — evicting does not unload the module, so it can never fall on its own.
-- `httpHtmlCacheEntries` / `httpHtmlCacheBytes`, `rscResultCacheEntries` / `rscResultCacheBytes`,
-  `rscPatchResultCacheEntries` / `rscPatchResultCacheBytes`: what each cache actually holds. Entry count alone
-  says nothing when entries span three orders of magnitude.
+- `ssrChunkRegistrySize`, `ssrChunkLoadCount`: detect full-document SSR client chunk retention.
 - `httpFullSsrCount`, `httpRscNavigationCount`, `httpStaticAssetCount`, `httpImageCount`: separate request kinds.
 
-Two things measured on `apps/akan` that shape how to read all of the above:
-
-- **Growth converges; it is not a leak.** Ten passes over the same routes plateau by roughly the sixth, with a
-  flat JS heap throughout. Three passes is not enough to tell a plateau from a ratchet.
-- **Freeing JS objects does not lower RSS.** Emptying both result caches returns their bytes to the heap and
-  leaves RSS unchanged. Only not allocating, or restarting the process, reduces what the pod pays.
-
 ## Scenarios
 
 ### Same Route Repeated

package/server/cachePolicy.ts

@@ -234,62 +234,20 @@ export function shouldInvalidateRouteCacheEntry(
   return false;
 }
 
-export interface LruTtlCacheOptions<T> {
-  /**
-   * Measures one entry's payload. Entry count alone says nothing about a cache whose entries span
-   * three orders of magnitude, and a byte ceiling needs a running total to enforce. The default
-   * reports 0 rather than guessing, so `byteSize` stays honest about not knowing.
-   */
-  sizeOf?: (value: T) => number;
-  /** Total payload ceiling. 0 leaves the cache bounded only by `maxEntries`. */
-  maxBytes?: number;
-  /** An entry over this is not stored at all, rather than evicting everything else to fit it. */
-  maxEntryBytes?: number;
-  /**
-   * Cadence of the idle sweep. Without one a filled cache never shrinks: an entry is dropped only
-   * when its own key is fetched after expiry or when a write evicts it, so a pod that stops
-   * serving holds its peak forever — measured at 100 entries / 21.4 MiB still resident 310s after
-   * the last request, with a 30s TTL. 0 disables it.
-   */
-  sweepIntervalMs?: number;
-}
-
 export class LruTtlCache<T> {
-  readonly #entries = new Map<string, { value: T; expiresAt: number; byteLength: number }>();
-  #byteLength = 0;
-  #sweepTimer: ReturnType<typeof setInterval> | null = null;
-  readonly #sizeOf: (value: T) => number;
-  readonly #maxBytes: number;
-  readonly #maxEntryBytes: number;
-
-  constructor(
-    readonly maxEntries = 100,
-    options: LruTtlCacheOptions<T> = {},
-  ) {
-    this.#sizeOf = options.sizeOf ?? (() => 0);
-    this.#maxBytes = options.maxBytes ?? 0;
-    this.#maxEntryBytes = options.maxEntryBytes ?? 0;
-    const sweepIntervalMs = options.sweepIntervalMs ?? 0;
-    if (sweepIntervalMs > 0) {
-      this.#sweepTimer = setInterval(() => this.sweepExpired(), sweepIntervalMs);
-      
-      (this.#sweepTimer as { unref?: () => void }).unref?.();
-    }
-  }
+  readonly #entries = new Map<string, { value: T; expiresAt: number }>();
+
+  constructor(readonly maxEntries = 100) {}
 
   get size(): number {
     return this.#entries.size;
   }
 
-  get byteSize(): number {
-    return this.#byteLength;
-  }
-
   get(key: string): T | null {
     const entry = this.#entries.get(key);
     if (!entry) return null;
     if (entry.expiresAt <= Date.now()) {
-      this.#remove(key);
+      this.#entries.delete(key);
       return null;
     }
     this.#entries.delete(key);
@@ -297,56 +255,26 @@ export class LruTtlCache<T> {
     return entry.value;
   }
 
-  /** Returns whether the entry was stored; a payload over `maxEntryBytes` is rejected. */
-  set(key: string, value: T, ttlSeconds: number): boolean {
-    this.#remove(key);
-    const byteLength = LruTtlCache.#measure(this.#sizeOf, value);
-    if (this.#maxEntryBytes > 0 && byteLength > this.#maxEntryBytes) return false;
-    this.sweepExpired();
+  set(key: string, value: T, ttlSeconds: number): void {
+    this.#entries.delete(key);
     const maxEntries = this.maxEntries > 0 ? this.maxEntries : 100;
     while (this.#entries.size >= maxEntries) {
-      if (!this.#removeOldest()) break;
-    }
-    while (this.#maxBytes > 0 && this.#entries.size > 0 && this.#byteLength + byteLength > this.#maxBytes) {
-      if (!this.#removeOldest()) break;
+      const oldest = this.#entries.keys().next().value;
+      if (!oldest) break;
+      this.#entries.delete(oldest);
     }
-    this.#entries.set(key, { value, expiresAt: Date.now() + ttlSeconds * 1000, byteLength });
-    this.#byteLength += byteLength;
-    return true;
-  }
-
-  /**
-   * Drops every expired entry. Deliberately a full scan rather than a walk from the oldest that
-   * stops at the first live entry: insertion order is *LRU* order because `get` reinserts, and TTLs
-   * differ per entry, so expiry is not monotonic in map order and an early break would leave
-   * expired entries behind. The map is bounded by `maxEntries`, so the scan is cheap.
-   */
-  sweepExpired(now = Date.now()): number {
-    let removed = 0;
-    for (const [key, entry] of this.#entries) {
-      if (entry.expiresAt > now) continue;
-      this.#remove(key);
-      removed += 1;
-    }
-    return removed;
-  }
-
-  /** Stops the idle sweep. The cache stays usable; only the timer goes away. */
-  dispose(): void {
-    if (!this.#sweepTimer) return;
-    clearInterval(this.#sweepTimer);
-    this.#sweepTimer = null;
+    this.#entries.set(key, { value, expiresAt: Date.now() + ttlSeconds * 1000 });
   }
 
   delete(key: string): boolean {
-    return this.#remove(key);
+    return this.#entries.delete(key);
   }
 
   invalidate(predicate: (key: string, value: T) => boolean): number {
     let count = 0;
     for (const [key, entry] of this.#entries) {
       if (!predicate(key, entry.value)) continue;
-      this.#remove(key);
+      this.#entries.delete(key);
       count += 1;
     }
     return count;
@@ -354,35 +282,5 @@ export class LruTtlCache<T> {
 
   clear(): void {
     this.#entries.clear();
-    this.#byteLength = 0;
-  }
-
-  static parseByteCeiling(value: string | undefined | null, fallback = 0): number {
-    const parsed = Number.parseInt(value ?? "", 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-  }
-
-  #remove(key: string): boolean {
-    const entry = this.#entries.get(key);
-    if (!entry) return false;
-    this.#entries.delete(key);
-    this.#byteLength -= entry.byteLength;
-    return true;
-  }
-
-  #removeOldest(): boolean {
-    const oldest = this.#entries.keys().next().value;
-    if (!oldest) return false;
-    return this.#remove(oldest);
-  }
-
-  /** A measurement must never fail a cache write, and a bad measurement must never skew the total. */
-  static #measure<T>(sizeOf: (value: T) => number, value: T): number {
-    try {
-      const measured = sizeOf(value);
-      return Number.isFinite(measured) && measured > 0 ? measured : 0;
-    } catch {
-      return 0;
-    }
   }
 }

package/server/di/diLifecycle.ts

@@ -21,7 +21,7 @@ import { SignalRegistry } from "../../signal/signalRegistry";
 import type { AkanLib, DatabaseModule, ScalarModule, ServiceModule } from "../akanLib";
 import { createDefaultAkanOption } from "../akanOption";
 import type { WebProxyRegistration } from "../proxy";
-import { CascadeRunner, DatabaseResolver, ServiceResolver, SignalResolver } from "../resolver";
+import { DatabaseResolver, ServiceResolver, SignalResolver } from "../resolver";
 import type { SignalRoutes, WebsocketRoutes } from "../types";
 import { getPredefinedAdaptor, predefinedAdaptorRole } from "./predefinedAdaptor";
 import { collectAdaptors, resolveAdaptorHierarchy } from "./resolveAdaptorHierarchy";
@@ -63,7 +63,6 @@ export class DiLifecycle {
   readonly disabledModules = new Map<string, string>();
   readonly #predefinedAdaptor;
   readonly #predefinedAdaptorRole = predefinedAdaptorRole;
-  readonly #cascade = new CascadeRunner();
 
   /** Read-only view of the resolved module maps, for tooling that needs to describe the container. */
   get modules(): {
@@ -123,9 +122,8 @@ export class DiLifecycle {
       this.#service.set(refName, module as ServiceModule);
     });
     this.#database.forEach((mod) => {
-      const { adaptor, schema } = DatabaseResolver.resolveDatabase(mod.constant, mod.database);
-      this.#adaptor.set(adaptor.refName, adaptor);
-      this.#cascade.register(mod.constant, schema, mod.service.srv);
+      const databaseAdaptor = DatabaseResolver.resolveDatabase(mod.constant, mod.database);
+      this.#adaptor.set(databaseAdaptor.refName, databaseAdaptor);
     });
     const services = [
       ...[...this.#service.values()].map((mod) => mod.service.srv),
@@ -459,7 +457,13 @@ export class DiLifecycle {
             if (serviceCls.type === "database") {
               const databaseModule = this.#database.get(serviceCls.refName);
               if (!databaseModule) throw new Error(`Database "${serviceCls.refName}" is not registered`);
-              ServiceResolver.resolveDatabaseService(databaseModule.database, serviceCls, this.#cascade);
+              ServiceResolver.resolveDatabaseService(
+                databaseModule.constant,
+                databaseModule.database,
+                serviceCls,
+
+                (refName) => this.getService(refName),
+              );
             }
             const service = new serviceCls();
             await InjectInfo.resolveInjection(service, serviceCls, this.registry, this.#env);
@@ -472,8 +476,6 @@ export class DiLifecycle {
         })),
       );
     }
-
-    this.#cascade.seal((refName) => this.getService(refName));
   }
 
   async #initializeInternal() {

package/server/processMetricsCollector.ts

@@ -138,10 +138,6 @@ export class ProcessMetricsCollector {
       ...(metrics.jscHeapSizeBytes !== undefined
         ? [`jscHeap=${ProcessMetricsCollector.formatBytes(metrics.jscHeapSizeBytes)}`]
         : []),
-
-      ...(metrics.rscWorkerRssBytes !== undefined
-        ? [`rscWorkerRss=${ProcessMetricsCollector.formatBytes(metrics.rscWorkerRssBytes)}`]
-        : []),
       ...(metrics.eventLoopLagMeanMs !== undefined
         ? [`elLag=${metrics.eventLoopLagMeanMs}/${metrics.eventLoopLagP99Ms ?? 0}/${metrics.eventLoopLagMaxMs ?? 0}ms`]
         : []),