akanjs 3.0.0-alpha.2 → 3.0.0-alpha.4

package/server/resolver/service.resolver.ts

@@ -1,6 +1,6 @@
 import type { PromiseOrObject } from "akanjs/base";
 import { capitalize } from "akanjs/common";
-import type { QueryOf } from "akanjs/constant";
+import { type ConstantModel, ConstantRegistry, type QueryOf } from "akanjs/constant";
 import {
   type CRUDEventType,
   type DatabaseModel,
@@ -15,10 +15,13 @@ import {
   type SaveEventType,
 } from "akanjs/document";
 import type { DatabaseService, ServiceCls } from "akanjs/service";
-import type { CascadeRunner } from "./CascadeRunner";
 
 export class ServiceResolver {
-  static #getDefaultDbServiceMethods(refName: string, className: string, cascade: CascadeRunner) {
+  static #getDefaultDbServiceMethods(
+    className: string,
+    cascades: [string, string][],
+    getService: (refName: string) => DatabaseService,
+  ) {
     const dbServiceMethods = {
       async __get(this: DatabaseService, id: string) {
         return await this.__databaseModel.__get(id);
@@ -96,24 +99,37 @@ export class ServiceResolver {
         return this.__update(id, data);
       },
       async __remove(this: DatabaseService, id: string): Promise<Doc> {
+
+        const targets = cascades.map(([key, refName]) => [key, getService(refName)] as const);
         await this.__libsPreRemove(id);
         const doc = await this.__databaseModel.__remove(id);
         const removed = await this.__libsPostRemove(doc);
-        await cascade.run(refName, removed as Record<string, unknown>);
+        for (const [key, target] of targets) {
+          const value = (removed as Record<string, unknown>)[key];
+          const ids = (Array.isArray(value) ? value : [value]).filter((v): v is string => typeof v === "string");
+
+          for (const targetId of ids) await target.__remove(targetId);
+        }
         return removed;
       },
       async [`remove${className}`](this: DatabaseService, id: string): Promise<Doc> {
         return this.__remove(id);
       },
-      async __removeMany(this: DatabaseService, query: QueryOf<any>) {
-        return await this.__databaseModel.__removeMany(query);
-      },
     };
     return dbServiceMethods;
   }
-  static resolveDatabaseService(database: DatabaseModel, srvRef: ServiceCls, cascade: CascadeRunner): ServiceCls {
+  static resolveDatabaseService(
+    constant: ConstantModel,
+    database: DatabaseModel,
+    srvRef: ServiceCls,
+    getService: (refName: string) => DatabaseService,
+  ): ServiceCls {
     const className = capitalize(database.refName);
-    Object.assign(srvRef.prototype, ServiceResolver.#getDefaultDbServiceMethods(database.refName, className, cascade));
+
+    const cascades = [...constant.full.cascade.remove].map(
+      ([key, modelRef]) => [key, ConstantRegistry.getRefName(modelRef)] as [string, string],
+    );
+    Object.assign(srvRef.prototype, ServiceResolver.#getDefaultDbServiceMethods(className, cascades, getService));
     const getQueryDataFromKey = (queryKey: string, args: any): { query: any; queryOption: any } => {
       const lastArg = args.at(-1);
       const hasQueryOption =

package/server/rscWorker.tsx

@@ -24,7 +24,6 @@ import { renderToReadableStream } from "react-server-dom-webpack/server.node";
 import type { ClientManifest } from "./artifact";
 import {
   LruTtlCache,
-  type LruTtlCacheOptions,
   parsePositiveInt,
   type RouteCacheEntry,
   type RouteCacheInvalidation,
@@ -123,9 +122,6 @@ interface FlightRenderResult {
   cancelled: boolean;
 }
 
-/** Well above any sensible TTL: this reclaims a cache nobody is reading, not tracks expiry closely. */
-const RESULT_CACHE_SWEEP_INTERVAL_MS = 60_000;
-
 function hashRscTraceCacheKey(cacheKey: string): string {
   let hash = 5381;
   for (let index = 0; index < cacheKey.length; index += 1) hash = (hash * 33) ^ cacheKey.charCodeAt(index);
@@ -201,14 +197,11 @@ export class RscRenderer {
     pagesBundleBuildId: 0,
   };
   readonly #routeStats = new Map<string, RouteRenderStats>();
-
   #resultCache = new LruTtlCache<CachedRscResult>(
     parsePositiveInt(process.env.AKAN_RSC_RESULT_CACHE_MAX_ENTRIES) ?? 100,
-    RscRenderer.#resultCacheOptions(),
   );
   #patchResultCache = new LruTtlCache<CachedRscResult>(
     parsePositiveInt(process.env.AKAN_RSC_RESULT_CACHE_MAX_ENTRIES) ?? 100,
-    RscRenderer.#resultCacheOptions(),
   );
   readonly #activeRenderReaders = new Map<string, ReadableStreamDefaultReader<Uint8Array>>();
   readonly #cancelledRenderRequests = new Set<string>();
@@ -825,11 +818,7 @@ export class RscRenderer {
       rscLoadedRouteModuleKeys: routeStats.loadedModuleKeys,
       rscTopRoutesByRenderCount: this.#topRoutes((route) => route.count),
       rscTopRoutesByFlightBytes: this.#topRoutes((route) => route.flightBytes),
-
-      rscResultCacheEntries: this.#resultCache.size,
-      rscResultCacheBytes: this.#resultCache.byteSize,
-      rscPatchResultCacheEntries: this.#patchResultCache.size,
-      rscPatchResultCacheBytes: this.#patchResultCache.byteSize,
+      rscResultCacheEntries: this.#resultCache.size + this.#patchResultCache.size,
       rscResultCacheHits: this.#resultCacheHits,
       rscResultCacheMisses: this.#resultCacheMisses,
       rscResultCacheBypass: this.#resultCacheBypass,
@@ -910,7 +899,7 @@ export class RscRenderer {
       });
     };
     try {
-      for (;;) {
+      while (true) {
         if (options.requestId && this.#cancelledRenderRequests.has(options.requestId)) {
           await reader.cancel();
           return { chunks, bytes, chunksCount, control: null, lateControlSent, cancelled: true };
@@ -1136,15 +1125,6 @@ export class RscRenderer {
     return decision;
   }
 
-  static #resultCacheOptions(): LruTtlCacheOptions<CachedRscResult> {
-    return {
-      sizeOf: (result) => result.bytes,
-      maxBytes: LruTtlCache.parseByteCeiling(process.env.AKAN_RSC_RESULT_CACHE_MAX_BYTES),
-      maxEntryBytes: LruTtlCache.parseByteCeiling(process.env.AKAN_RSC_RESULT_CACHE_MAX_BODY_BYTES),
-      sweepIntervalMs: RESULT_CACHE_SWEEP_INTERVAL_MS,
-    };
-  }
-
   #getCachedResult(cacheKey: string): CachedRscResult | null {
     const cached = this.#resultCache.get(cacheKey);
     if (!cached) {
@@ -1166,19 +1146,11 @@ export class RscRenderer {
   }
 
   #setCachedResult(cacheKey: string, result: CachedRscResult, ttl: number): void {
-    this.#logRejectedStore("full", result, this.#resultCache.set(cacheKey, result, ttl));
+    this.#resultCache.set(cacheKey, result, ttl);
   }
 
   #setCachedPatchResult(cacheKey: string, result: CachedRscResult, ttl: number): void {
-    this.#logRejectedStore("patch", result, this.#patchResultCache.set(cacheKey, result, ttl));
-  }
-
-  /** A silently dropped store looks identical to a cache miss; say which route is too big to cache. */
-  #logRejectedStore(kind: string, result: CachedRscResult, stored: boolean): void {
-    if (stored) return;
-    this.#logger.verbose(
-      `${kind} result cache store skipped pathname=${result.pathname} bytes=${result.bytes} reason=body-too-large`,
-    );
+    this.#patchResultCache.set(cacheKey, result, ttl);
   }
 
   #runWithRequest<T>(request: Request, fn: () => Promise<T>): Promise<T> {

package/server/rscWorkerHost.ts

@@ -89,66 +89,6 @@ export function createRscWorkerInvalidateCacheMessage(
   };
 }
 
-/**
- * The RSC worker samples its own process with the same `ProcessMetricsCollector.collect` its host
- * replica uses, so its report carries `pid` / `rssBytes` / `role` / … under the identical names.
- * `AkanServer` spreads the host's report into its own `collect({ role, ...webRouter.getMetrics() })`
- * and `collect` spreads `extra` last (`processMetricsCollector.ts:122`) — so passing these through
- * unprefixed silently overwrote the replica's own process fields, and the replica's RSS was reported
- * nowhere. Rename them onto `rscWorker*`; the `rsc*` render counters, which only the worker
- * produces, pass through untouched.
- *
- * XXX A new process-level field in `ProcessMetricsCollector.collect` must be added here too, or it
- * starts shadowing the replica again.
- */
-export function projectRscWorkerProcessMetrics(metrics: AkanMetricsReport): AkanMetricsReport {
-  const {
-    role: _role,
-    pid: _pid,
-    trace: _trace,
-    reportedAt,
-    rssBytes,
-    heapTotalBytes,
-    heapUsedBytes,
-    externalBytes,
-    arrayBuffersBytes,
-    cpuUserMicros,
-    cpuSystemMicros,
-    maxRssKb,
-    jscHeapSizeBytes,
-    jscHeapCapacityBytes,
-    jscExtraMemorySizeBytes,
-    jscObjectCount,
-    jscProtectedObjectCount,
-    eventLoopLagMeanMs,
-    eventLoopLagP99Ms,
-    eventLoopLagMaxMs,
-    gcDurationMs,
-    ...renderMetrics
-  } = metrics;
-  return {
-    ...renderMetrics,
-    rscWorkerReportedAt: reportedAt,
-    rscWorkerRssBytes: rssBytes,
-    rscWorkerHeapTotalBytes: heapTotalBytes,
-    rscWorkerHeapUsedBytes: heapUsedBytes,
-    rscWorkerExternalBytes: externalBytes,
-    rscWorkerArrayBuffersBytes: arrayBuffersBytes,
-    rscWorkerCpuUserMicros: cpuUserMicros,
-    rscWorkerCpuSystemMicros: cpuSystemMicros,
-    rscWorkerMaxRssKb: maxRssKb,
-    rscWorkerJscHeapSizeBytes: jscHeapSizeBytes,
-    rscWorkerJscHeapCapacityBytes: jscHeapCapacityBytes,
-    rscWorkerJscExtraMemorySizeBytes: jscExtraMemorySizeBytes,
-    rscWorkerJscObjectCount: jscObjectCount,
-    rscWorkerJscProtectedObjectCount: jscProtectedObjectCount,
-    rscWorkerEventLoopLagMeanMs: eventLoopLagMeanMs,
-    rscWorkerEventLoopLagP99Ms: eventLoopLagP99Ms,
-    rscWorkerEventLoopLagMaxMs: eventLoopLagMaxMs,
-    rscWorkerGcDurationMs: gcDurationMs,
-  };
-}
-
 export function createRscHostRenderStream(input: {
   setPending: (pending: RscPending) => void;
   deletePending: () => void;
@@ -524,7 +464,18 @@ export class RscWorker {
   }
 
   getMetrics(): AkanMetricsReport {
-    return Object.assign(projectRscWorkerProcessMetrics(this.#lastWorkerMetrics), {
+    const {
+      rscWorkerPid: _rscWorkerPid,
+      rscWorkerStatus: _rscWorkerStatus,
+      rscWorkerRestartCount: _rscWorkerRestartCount,
+      rscWorkerRecycleCount: _rscWorkerRecycleCount,
+      rscWorkerLastRecycleReason: _rscWorkerLastRecycleReason,
+      rscPendingRenderCount: _rscPendingRenderCount,
+      rscQueuedSendCount: _rscQueuedSendCount,
+      rscHostPendingChunkOverflowCount: _rscHostPendingChunkOverflowCount,
+      ...workerMetrics
+    } = this.#lastWorkerMetrics;
+    return Object.assign(workerMetrics, {
       rscWorkerPid: this.#proc.pid,
       rscWorkerStatus: this.#status,
       rscWorkerRestartCount: this.#restartCount,

package/server/ssrFromRscRenderer.tsx

@@ -411,7 +411,7 @@ export function interleaveRscScriptsWithHtml(
       const pumpRscScripts = async () => {
         rscReader = rscClientStream.getReader();
         try {
-          for (;;) {
+          while (true) {
             const { value, done } = await rscReader.read();
             if (done || errored) break;
             await waitForRscQueueDrain();
@@ -446,7 +446,7 @@ export function interleaveRscScriptsWithHtml(
 
         htmlReader = htmlStream.getReader();
         try {
-          for (;;) {
+          while (true) {
             const { value, done } = await htmlReader.read();
             if (done || errored) break;
             controller.enqueue(value);

package/server/webRouter.ts

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { pathToFileURL } from "node:url";
 import { getEnv } from "akanjs/base";
 import {
   type AkanI18nConfig,
@@ -56,10 +57,20 @@ import type { BaseBuildArtifact, HttpRoutes, RenderState } from "./types";
 
 const CLIENT_CLOSED_REQUEST_STATUS = 499;
 export const DEFAULT_HTML_RESULT_CACHE_MAX_BODY_BYTES = 2 * 1024 * 1024;
-/** Well above any sensible TTL: this only has to reclaim a cache nobody is reading, not track expiry closely. */
-const ROUTE_CACHE_SWEEP_INTERVAL_MS = 60_000;
 const APPLE_APP_SITE_ASSOCIATION_PATH = "/.well-known/apple-app-site-association";
 const ANDROID_ASSET_LINKS_PATH = "/.well-known/assetlinks.json";
+const FIREBASE_MESSAGING_SW_PATH = "/firebase-messaging-sw.js";
+const FIREBASE_WEB_SDK_VERSION = "12.13.0";
+
+interface FirebaseClientEnvConfig {
+  apiKey: string;
+  authDomain?: string;
+  projectId: string;
+  storageBucket?: string;
+  messagingSenderId: string;
+  appId: string;
+  vapidKey?: string;
+}
 
 export function createRscRedirectResponse(
   location: string,
@@ -288,11 +299,6 @@ export class WebRouter {
   };
   readonly #htmlCache = new LruTtlCache<CachedHtmlResult>(
     parsePositiveInt(process.env.AKAN_HTML_RESULT_CACHE_MAX_ENTRIES) ?? 100,
-    {
-      sizeOf: (result) => result.html.length,
-      maxBytes: LruTtlCache.parseByteCeiling(process.env.AKAN_HTML_RESULT_CACHE_MAX_BYTES),
-      sweepIntervalMs: ROUTE_CACHE_SWEEP_INTERVAL_MS,
-    },
   );
   #htmlCacheHits = 0;
   #htmlCacheMisses = 0;
@@ -486,6 +492,16 @@ export class WebRouter {
         WebRouter.#deepLinkAssociationResponse(ANDROID_ASSET_LINKS_PATH, this.#artifact, {
           cacheControl: this.#prodMode ? "public, max-age=3600" : "no-store",
         }) ?? new Response("Not Found", { status: 404 }),
+      [FIREBASE_MESSAGING_SW_PATH]: async () => {
+        this.#requestStats.staticAsset += 1;
+        const firebaseConfig = await WebRouter.#resolveFirebaseClientConfig();
+        return new Response(WebRouter.#createFirebaseMessagingServiceWorker(firebaseConfig), {
+          headers: {
+            "Content-Type": "application/javascript; charset=utf-8",
+            "Cache-Control": "no-store",
+          },
+        });
+      },
       "/*": async (req) => {
         const url = new URL(req.url);
         if (WebRouter.#isImageOptimizerPath(url.pathname)) {
@@ -676,7 +692,6 @@ export class WebRouter {
     this.#devHmr?.dispose();
     this.#devHmr = null;
     this.#builderRpc = null;
-    this.#htmlCache.dispose();
     this.#rsc.kill();
     this.#hub = null;
   }
@@ -694,7 +709,6 @@ export class WebRouter {
       httpCsrCount: this.#requestStats.csr,
       httpImageCount: this.#requestStats.image,
       httpHtmlCacheEntries: this.#htmlCache.size,
-      httpHtmlCacheBytes: this.#htmlCache.byteSize,
       httpHtmlCacheHits: this.#htmlCacheHits,
       httpHtmlCacheMisses: this.#htmlCacheMisses,
       httpHtmlCacheBypass: this.#htmlCacheBypass,
@@ -994,6 +1008,79 @@ export class WebRouter {
     return process.env.AKAN_APP_DIR ?? path.dirname(Bun.main);
   }
 
+  static async #resolveFirebaseClientConfig(): Promise<FirebaseClientEnvConfig | null> {
+    const envPath = path.join(WebRouter.#resolveAppDir(), "env", "env.client.ts");
+    if (!fs.existsSync(envPath)) return null;
+    try {
+      const envUrl = pathToFileURL(envPath);
+      envUrl.searchParams.set("t", String(Date.now()));
+      const envModule = (await import(envUrl.href)) as { env?: { firebase?: unknown } };
+      return WebRouter.#normalizeFirebaseClientConfig(envModule.env?.firebase);
+    } catch {
+      return null;
+    }
+  }
+
+  static #normalizeFirebaseClientConfig(config: unknown): FirebaseClientEnvConfig | null {
+    if (!config || typeof config !== "object") return null;
+    const value = config as Partial<Record<keyof FirebaseClientEnvConfig, unknown>>;
+    if (
+      typeof value.apiKey !== "string" ||
+      typeof value.projectId !== "string" ||
+      typeof value.messagingSenderId !== "string" ||
+      typeof value.appId !== "string"
+    ) {
+      return null;
+    }
+    return {
+      apiKey: value.apiKey,
+      ...(typeof value.authDomain === "string" ? { authDomain: value.authDomain } : {}),
+      projectId: value.projectId,
+      ...(typeof value.storageBucket === "string" ? { storageBucket: value.storageBucket } : {}),
+      messagingSenderId: value.messagingSenderId,
+      appId: value.appId,
+    };
+  }
+
+  static #createFirebaseMessagingServiceWorker(config: FirebaseClientEnvConfig | null): string {
+    const configJson = JSON.stringify(config);
+    return `/* Generated by Akan.js. Do not edit. */
+const firebaseConfig = ${configJson};
+
+if (firebaseConfig) {
+  importScripts("https://www.gstatic.com/firebasejs/${FIREBASE_WEB_SDK_VERSION}/firebase-app-compat.js");
+  importScripts("https://www.gstatic.com/firebasejs/${FIREBASE_WEB_SDK_VERSION}/firebase-messaging-compat.js");
+
+  firebase.initializeApp(firebaseConfig);
+  const messaging = firebase.messaging();
+
+  const notificationUrl = (payload) =>
+    payload?.data?.url || payload?.fcmOptions?.link || payload?.notification?.click_action;
+
+  messaging.onBackgroundMessage((payload) => {
+    const title = payload?.notification?.title || "";
+    const options = {
+      body: payload?.notification?.body,
+      icon: payload?.notification?.icon,
+      image: payload?.notification?.image,
+      data: {
+        url: notificationUrl(payload),
+        FCM_MSG: payload,
+      },
+    };
+    self.registration.showNotification(title, options);
+  });
+}
+
+self.addEventListener("notificationclick", (event) => {
+  const url = event.notification?.data?.url || event.notification?.data?.FCM_MSG?.data?.url;
+  event.notification?.close();
+  if (!url) return;
+  event.waitUntil(clients.openWindow(url));
+});
+`;
+  }
+
   static #normalizeArtifact(artifact: BaseBuildArtifact, artifactDir: string): BaseBuildArtifact {
     const normalizedArtifactDir = path.resolve(artifactDir);
     const pagesBundlePath = WebRouter.#resolveArtifactPath(artifact.pagesBundlePath, normalizedArtifactDir);

package/service/ipcTypes.ts

@@ -55,26 +55,6 @@ export interface AkanMetricsReport {
   rscWorkerRestartCount?: number;
   rscWorkerRecycleCount?: number;
   rscWorkerLastRecycleReason?: string;
-
-  rscWorkerReportedAt?: number;
-  rscWorkerRssBytes?: number;
-  rscWorkerHeapTotalBytes?: number;
-  rscWorkerHeapUsedBytes?: number;
-  rscWorkerExternalBytes?: number;
-  rscWorkerArrayBuffersBytes?: number;
-  rscWorkerCpuUserMicros?: number;
-  rscWorkerCpuSystemMicros?: number;
-  rscWorkerMaxRssKb?: number;
-  rscWorkerJscHeapSizeBytes?: number;
-  rscWorkerJscHeapCapacityBytes?: number;
-  /** Off-heap bytes JSC attributes to JS objects — typed-array backing stores, i.e. cached Flight chunks. */
-  rscWorkerJscExtraMemorySizeBytes?: number;
-  rscWorkerJscObjectCount?: number;
-  rscWorkerJscProtectedObjectCount?: number;
-  rscWorkerEventLoopLagMeanMs?: number;
-  rscWorkerEventLoopLagP99Ms?: number;
-  rscWorkerEventLoopLagMaxMs?: number;
-  rscWorkerGcDurationMs?: number;
   rscPendingRenderCount?: number;
   rscQueuedSendCount?: number;
   rscHostPendingChunkOverflowCount?: number;
@@ -100,13 +80,9 @@ export interface AkanMetricsReport {
   rscLastRenderLoadedModuleDelta?: number;
   rscLastRenderLoadedModules?: string[];
   rscResultCacheEntries?: number;
-  rscResultCacheBytes?: number;
-  rscPatchResultCacheEntries?: number;
-  rscPatchResultCacheBytes?: number;
   rscResultCacheHits?: number;
   rscResultCacheMisses?: number;
   rscResultCacheBypass?: number;
-  /** Keys the SSR chunk registry tracks — NOT a memory bound; the modules stay in Bun's ESM registry. */
   ssrChunkRegistrySize?: number;
   ssrChunkLoadCount?: number;
   ssrChunkCacheHitCount?: number;
@@ -117,7 +93,6 @@ export interface AkanMetricsReport {
   httpCsrCount?: number;
   httpImageCount?: number;
   httpHtmlCacheEntries?: number;
-  httpHtmlCacheBytes?: number;
   httpHtmlCacheHits?: number;
   httpHtmlCacheMisses?: number;
   httpHtmlCacheBypass?: number;

package/service/predefinedAdaptor/database.adaptor.ts

@@ -95,7 +95,7 @@ export interface DocumentStore {
     query: DocumentQuery,
     update: DocumentUpdateInput,
   ): Promise<{ acknowledged: boolean; matchedCount: number; modifiedCount: number }>;
-  removeManyByQuery(
+  deleteManyByQuery(
     query: DocumentQuery,
   ): Promise<{ acknowledged: boolean; matchedCount: number; modifiedCount: number }>;
   bulkWrite(
@@ -1081,8 +1081,8 @@ export class SqlDocumentStore {
     return { acknowledged: true, matchedCount: changes, modifiedCount: changes };
   }
 
-  async removeManyByQuery(query: DocumentQuery) {
-
+  async deleteManyByQuery(query: DocumentQuery) {
+    
     return this.updateManyByQuery(query, { removedAt: dayjs() });
   }
 

package/service/serve.ts

@@ -1,4 +1,4 @@
-import { type Cls, INJECT_META, LIBS_REMOVE_HOOK } from "akanjs/base";
+import { type Cls, INJECT_META } from "akanjs/base";
 import { applyMixins, capitalize, Logger, lowerlize } from "akanjs/common";
 import type { DatabaseModel } from "akanjs/document";
 
@@ -146,10 +146,6 @@ export function serve(
     const postUpdateFns = extSrvs.map((srv) => srv.prototype._postUpdate);
     const preRemoveFns = extSrvs.map((srv) => srv.prototype._preRemove);
     const postRemoveFns = extSrvs.map((srv) => srv.prototype._postRemove);
-
-    Object.assign(srvRef, {
-      [LIBS_REMOVE_HOOK]: preRemoveFns.some(Boolean) || postRemoveFns.some(Boolean),
-    });
     Object.assign(srvRef.prototype, {
       async __libsPreCreate(this: DatabaseService, data: DatabaseServiceData) {
         let result = data;

package/service/types.ts

@@ -11,7 +11,6 @@ import type {
   ListQueryOption,
   QueryMethodPart,
   SaveEventType,
-  UpdateResult,
 } from "akanjs/document";
 
 type ServiceMixinOmitKey =
@@ -102,7 +101,6 @@ export type DatabaseService<
   __create: (data: _DataInputOfDoc) => Promise<Doc>;
   __update: (id: string, data: Partial<Doc>) => Promise<Doc>;
   __remove: (id: string) => Promise<Doc>;
-  __removeMany: (query: _QueryOfDoc) => 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/types/base/symbols.d.ts

@@ -3,7 +3,6 @@ export declare const SLICE_META: unique symbol;
 export declare const FILTER_META: unique symbol;
 export declare const LOADER_META: unique symbol;
 export declare const INJECT_META: unique symbol;
-export declare const LIBS_REMOVE_HOOK: unique symbol;
 export declare const ENDPOINT_META: unique symbol;
 export declare const ENDPOINT_DICT_SHAPE: unique symbol;
 export declare const SLICE_DICT_SHAPE: unique symbol;

package/types/client/cn.d.ts

@@ -6,6 +6,11 @@ import { type ClassNameValue } from "tailwind-merge";
  * `cn("bg-primary", "bg-open")` correctly resolves to `"bg-open"` instead of keeping both.
  */
 export declare const colorTokens: string[];
+/**
+ * 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 declare const radiusTokens: string[];
 /** The one class-combining function: joins strings/arrays/conditional parts (`cond && "x"`) and
  *  resolves Tailwind conflicts with a shared tailwind-merge instance that knows Akan's semantic
  *  color tokens. clsx-style object syntax (`{ x: cond }`) is not supported — write `cond && "x"`. */

package/types/client/csrTypes.d.ts

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

package/types/constant/cascadePaths.d.ts

@@ -1,29 +1,11 @@
 import type { FieldObject } from "./fieldInfo.d.ts";
 import type { ConstantModelRef } from "./via.d.ts";
-/**
- * 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 declare const cascadeActions: readonly ["removeRef", "removeWith"];
+/** What happens to the documents a relation field points at when the owner is removed. */
+export declare const cascadeActions: readonly ["remove"];
 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[];
-}
 export declare class CascadePaths {
     #private;
-    /** Field key → the model its ids point at, removed when this document is. */
-    readonly removeRef: Map<string, ConstantModelRef>;
-    /** Field key → the owner whose removal removes this document. */
-    readonly removeWith: 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: Map<string, ConstantModelRef>;
     collect(fieldMap: FieldObject): this;
 }

package/types/document/database.d.ts

@@ -4,7 +4,7 @@ import type { DocumentModel, QueryOf } from "akanjs/constant";
 import type { CacheAdaptor, CacheSetOptions } from "akanjs/service";
 import type { DataLoader } from "./dataLoader.d.ts";
 import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta.d.ts";
-import type { CRUDEventType, Mdl, SaveEventType, UpdateResult } from "./into.d.ts";
+import type { CRUDEventType, Mdl, SaveEventType } from "./into.d.ts";
 import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types.d.ts";
 export declare class CacheDatabase<T = unknown> {
     private readonly refName;
@@ -57,7 +57,6 @@ type DatabaseModelWithQuerySort<T extends string, Input, Doc, Obj, Insight, Quer
     __create: (data: _DataInput) => Promise<Doc>;
     __update: (id: string, data: Partial<Doc>) => Promise<Doc>;
     __remove: (id: string) => Promise<Doc>;
-    __removeMany: (query: _QueryOfDoc) => 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/types/document/databaseRegistry.d.ts

@@ -8,7 +8,7 @@ export interface DatabaseModel<T extends string = string, Input = any, Doc = any
     model: ModelCls<Model>;
     filter: FilterCls<Filter>;
     obj: ConstantCls<Obj>;
-    insight: DatabaseCls<Insight>;
+    insight: ConstantCls<Insight>;
     _Input: Input;
     _Doc: Doc;
     _Model: Model;
@@ -32,6 +32,6 @@ export declare class DatabaseRegistry {
     static getScalar<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
         allowEmpty?: AllowEmpty;
     }): AllowEmpty extends true ? DatabaseCls | undefined : DatabaseCls;
-    static buildModel<T extends string, Input, Doc, Model, Obj, Insight, Filter extends FilterInstance, _Query extends ExtractQuery<Filter> = ExtractQuery<Filter>, _Sort extends ExtractSort<Filter> = ExtractSort<Filter>>(refName: T, input: DatabaseCls<Input>, doc: DatabaseCls<Doc>, model: ModelCls<Model>, obj: ConstantCls<Obj>, insight: DatabaseCls<Insight>, filter: FilterCls<Filter>): DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter, _Query, _Sort>;
+    static buildModel<T extends string, Input, Doc, Model, Obj, Insight, Filter extends FilterInstance, _Query extends ExtractQuery<Filter> = ExtractQuery<Filter>, _Sort extends ExtractSort<Filter> = ExtractSort<Filter>>(refName: T, input: DatabaseCls<Input>, doc: DatabaseCls<Doc>, model: ModelCls<Model>, obj: ConstantCls<Obj>, insight: ConstantCls<Insight>, filter: FilterCls<Filter>): DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter, _Query, _Sort>;
     static buildScalar<T extends string, Model>(refName: T, Model: DatabaseCls<Model>): DatabaseCls<Model>;
 }

package/types/document/into.d.ts

@@ -60,17 +60,16 @@ export type Mdl<Doc, Raw, _RawDoc = DocumentModel<Raw>, _RawQuery extends Docume
     exists(query: _RawQuery): Promise<string | null>;
     updateOne(query: _RawQuery, update: DocumentUpdateInput<_RawDoc>, options?: DocumentUpdateOptions): Promise<UpdateResult>;
     updateMany(query: _RawQuery, update: DocumentUpdateInput<_RawDoc>): Promise<UpdateResult>;
-    removeMany(query: _RawQuery): Promise<UpdateResult>;
+    deleteMany(query: _RawQuery): Promise<UpdateResult>;
     bulkWrite(operations: BulkWriteOperation<Raw, _RawDoc, _RawQuery>[]): Promise<UpdateResult>;
 };
-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<T extends string, _CapitalizedRefName extends string, Doc, Raw, Insight, _Query, _Sort, _QueryOfDoc = QueryOf<Doc>> = {
+type IntoModelActions<T extends string, _CapitalizedRefName extends string, Doc, Raw, _Query, _Sort, _QueryOfDoc = QueryOf<Doc>> = {
     [key in _CapitalizedRefName]: Mdl<Doc, Raw>;
 } & {
     [key in `${Uncapitalize<_CapitalizedRefName>}Loader`]: DataLoader<string, Doc, string>;
@@ -88,6 +87,6 @@ type IntoModelActions<T extends string, _CapitalizedRefName extends string, Doc,
     [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>;
-export declare const into: <Doc, FilterRef extends FilterCls, T extends string, Raw, Insight, AddDbModels extends ModelCls[], _CapitalizedRefName extends string, _QueryOfDoc = QueryOf<Doc>, _Query = FilterQueryOf<FilterRef>, _Sort = FilterSortOf<FilterRef>, _LoaderBuilder extends LoaderBuilder<NoInferType<Doc>> = LoaderBuilder<Doc>>(docRef: Cls<Doc>, filterRef: FilterRef, cnst: IntoConstantModel<T, _CapitalizedRefName, Raw, Insight>, loaderBuilder: _LoaderBuilder, ...addMdls: [...AddDbModels]) => ModelCls<IntoModelActions<T, _CapitalizedRefName, Doc, Raw, Insight, _Query, _Sort, _QueryOfDoc>, ReturnType<_LoaderBuilder>>;
+} & QueryMethodPart<_Query, _Sort, Raw, Doc, unknown, unknown, unknown, _QueryOfDoc>;
+export declare const into: <Doc, FilterRef extends FilterCls, T extends string, Raw, AddDbModels extends ModelCls[], _CapitalizedRefName extends string, _QueryOfDoc = QueryOf<Doc>, _Query = FilterQueryOf<FilterRef>, _Sort = FilterSortOf<FilterRef>, _LoaderBuilder extends LoaderBuilder<NoInferType<Doc>> = LoaderBuilder<Doc>>(docRef: Cls<Doc>, filterRef: FilterRef, cnst: IntoConstantModel<T, _CapitalizedRefName, Raw>, loaderBuilder: _LoaderBuilder, ...addMdls: [...AddDbModels]) => ModelCls<IntoModelActions<T, _CapitalizedRefName, Doc, Raw, _Query, _Sort, _QueryOfDoc>, ReturnType<_LoaderBuilder>>;
 export {};