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

package/webkit/useCsrValues.ts

@@ -13,6 +13,7 @@ import {
   type NavigationIntent,
   normalizeDeepLinkHref,
   type PageState,
+  type PageTransition,
   type PathRoute,
   type RouteGuide,
   type RouteOptions,
@@ -23,13 +24,14 @@ import {
 } from "akanjs/client";
 import { loadCapacitorApp } from "akanjs/client/capacitor";
 import { parseAkanI18nEnv, parseBasePaths } from "akanjs/common";
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import {
   createFrameSnapshot,
   createTransitionPlan,
   FRAME_Z_INDEX,
   getFramePlatformProfile,
   getFrameSlotsForSnapshot,
+  hasBottomAnchoredKeyboardSlot,
   hasKeyboardStickySlot,
   isPendingFrameReady,
   PENDING_FRAME_READY_TIMEOUT_MS,
@@ -492,7 +494,6 @@ const useStackTrans = (routeState: RouteState): UseCsrTransition => {
         gestureIntent.current = "pending";
         stackBackConfigRef.current = null;
         unlockPageScroll();
-        void Device.getDevice().hideKeyboard();
       }
       if (ix > initThreshold) {
         gestureIntent.current = "scroll";
@@ -511,6 +512,7 @@ const useStackTrans = (routeState: RouteState): UseCsrTransition => {
         if (absX < GESTURE_INTENT_THRESHOLD || absX <= absY * GESTURE_AXIS_LOCK_RATIO) return;
         gestureIntent.current = "gesture";
         lockPageScroll();
+        void Device.getDevice().hideKeyboard();
       }
       if (gestureIntent.current !== "gesture") {
         cancel();
@@ -668,11 +670,11 @@ const useBottomUpTrans = (routeState: RouteState): UseCsrTransition => {
 
   const pageBind = useDrag(
     ({ first, last, movement: [, my], initial: [, iy], cancel }) => {
-      if (first) void Device.getDevice().hideKeyboard();
       if (iy > initThreshold) {
         cancel();
         return;
       }
+      if (first) void Device.getDevice().hideKeyboard();
       if (my < transUnitRange[1]) void transUnit.start(transUnitRange[1], { immediate: true });
       else if (my > transUnitRange[0]) void transUnit.start(transUnitRange[0], { immediate: true });
       else if (!last) void transUnit.start(my, { immediate: true });
@@ -864,6 +866,7 @@ export const useCsrValues = (rootRouteGuide: RouteGuide, pathRoutes: PathRoute[]
   const resolvedPendingLocation = resolveLocationWithFrameState(pendingLocation, resolvedPathRouteMap);
   const platformProfile = getFramePlatformProfile();
   const accessoryHeight = resolveKeyboardAccessoryHeight(resolvedLocation.pathRoute.path, frameSlots);
+  const shouldAnchorContentBottom = hasBottomAnchoredKeyboardSlot(resolvedLocation.pathRoute.path, frameSlots);
   const keyboardFrame = useKeyboardFrame({
     bottomSafeArea: resolvedLocation.pathRoute.pageState.bottomSafeArea,
     sticky: hasKeyboardStickySlot(resolvedLocation.pathRoute.path, frameSlots),
@@ -881,6 +884,103 @@ export const useCsrValues = (rootRouteGuide: RouteGuide, pathRoutes: PathRoute[]
       }),
     [viewport, keyboardFrame, accessoryHeight, resolvedLocation.pathRoute.pageState.bottomSafeArea],
   );
+  const contentBottomAnchorRef = useRef<{
+    path: string;
+    contentViewportHeight: number;
+    bottomDistance: number;
+  } | null>(null);
+  const contentBottomAnchorRafRef = useRef<number | null>(null);
+  useLayoutEffect(() => {
+    const element = pageContentRef.current;
+    const path = resolvedLocation.pathRoute.path;
+    if (!element || !shouldAnchorContentBottom || !keyboardFrame.sticky) {
+      contentBottomAnchorRef.current = null;
+      if (contentBottomAnchorRafRef.current !== null) {
+        cancelAnimationFrame(contentBottomAnchorRafRef.current);
+        contentBottomAnchorRafRef.current = null;
+      }
+      return;
+    }
+
+    const previous = contentBottomAnchorRef.current;
+    const currentBottomDistance = Math.max(0, element.scrollHeight - element.scrollTop - element.clientHeight);
+    if (!previous || previous.path !== path) {
+      contentBottomAnchorRef.current = {
+        path,
+        contentViewportHeight: keyboardLayout.contentViewport.height,
+        bottomDistance: currentBottomDistance,
+      };
+      return;
+    }
+
+    const shouldRestoreBottom = previous.contentViewportHeight !== keyboardLayout.contentViewport.height;
+    const bottomDistance = previous.bottomDistance;
+    if (shouldRestoreBottom) {
+      const nextScrollTop = Math.max(0, element.scrollHeight - element.clientHeight - bottomDistance);
+      if (Math.abs(element.scrollTop - nextScrollTop) > 1) {
+        debugFrame("keyboard.contentAnchor", {
+          path,
+          from: element.scrollTop,
+          to: nextScrollTop,
+          bottomDistance,
+          contentViewportHeight: keyboardLayout.contentViewport.height,
+        });
+        element.scrollTop = nextScrollTop;
+      }
+      const startedAt = performance.now();
+      const duration = (keyboardFrame.animationDuration ?? 0) + 50;
+      const keepBottomAnchored = () => {
+        const scrollTop = Math.max(0, element.scrollHeight - element.clientHeight - bottomDistance);
+        if (Math.abs(element.scrollTop - scrollTop) > 1) element.scrollTop = scrollTop;
+        if (performance.now() - startedAt < duration) {
+          contentBottomAnchorRafRef.current = requestAnimationFrame(keepBottomAnchored);
+        } else {
+          contentBottomAnchorRafRef.current = null;
+        }
+      };
+      if (contentBottomAnchorRafRef.current !== null) cancelAnimationFrame(contentBottomAnchorRafRef.current);
+      contentBottomAnchorRafRef.current = requestAnimationFrame(keepBottomAnchored);
+    }
+
+    contentBottomAnchorRef.current = {
+      path,
+      contentViewportHeight: keyboardLayout.contentViewport.height,
+      bottomDistance: Math.max(0, element.scrollHeight - element.scrollTop - element.clientHeight),
+    };
+    return () => {
+      if (contentBottomAnchorRafRef.current !== null) {
+        cancelAnimationFrame(contentBottomAnchorRafRef.current);
+        contentBottomAnchorRafRef.current = null;
+      }
+    };
+  }, [
+    pageContentRef,
+    resolvedLocation.pathRoute.path,
+    shouldAnchorContentBottom,
+    keyboardFrame.sticky,
+    keyboardFrame.animationDuration,
+    keyboardLayout.contentViewport.height,
+  ]);
+  useEffect(() => {
+    const element = pageContentRef.current;
+    const path = resolvedLocation.pathRoute.path;
+    if (!element || !shouldAnchorContentBottom || !keyboardFrame.sticky) return;
+    const updateBottomDistance = () => {
+      contentBottomAnchorRef.current = {
+        path,
+        contentViewportHeight: keyboardLayout.contentViewport.height,
+        bottomDistance: Math.max(0, element.scrollHeight - element.scrollTop - element.clientHeight),
+      };
+    };
+    element.addEventListener("scroll", updateBottomDistance, { passive: true });
+    return () => element.removeEventListener("scroll", updateBottomDistance);
+  }, [
+    pageContentRef,
+    resolvedLocation.pathRoute.path,
+    shouldAnchorContentBottom,
+    keyboardFrame.sticky,
+    keyboardLayout.contentViewport.height,
+  ]);
   useFrameRuntimeResync({ updateViewport });
   const shouldPrepareFrameTransition = useCallback(
     (nextHref?: string) => {
@@ -1245,6 +1345,7 @@ export const useCsrValues = (rootRouteGuide: RouteGuide, pathRoutes: PathRoute[]
       keyboard: keyboardFrame,
       contentViewport: keyboardLayout.contentViewport,
       keyboardAccessory: keyboardLayout.keyboardAccessory,
+      contentAnchor: shouldAnchorContentBottom ? "bottom" : undefined,
       platformProfile,
       zIndex: FRAME_Z_INDEX,
       pageStateByPath: effectivePageStateByPath,
@@ -1262,6 +1363,21 @@ export const useCsrValues = (rootRouteGuide: RouteGuide, pathRoutes: PathRoute[]
     bottomUp: useBottomUpTransition,
     scaleOut: useScaleOutTransition,
   };
+
+  const contentResizeStyle = useMemo(() => {
+    if (!shouldAnchorContentBottom || !keyboardFrame.sticky) return null;
+    const duration = keyboardFrame.animationDuration ?? 420;
+    const easing = keyboardFrame.animationEasing ?? "cubic-bezier(0.16, 1, 0.3, 1)";
+    return {
+      transition: `height ${duration}ms ${easing}, padding-bottom ${duration}ms ${easing}`,
+      willChange: "height, padding-bottom",
+    };
+  }, [shouldAnchorContentBottom, keyboardFrame.sticky, keyboardFrame.animationDuration, keyboardFrame.animationEasing]);
+  const csrTransition = useCsrTransitionMap[resolvedLocation.pathRoute.pageState.transition];
+  const page: PageTransition | null =
+    contentResizeStyle && csrTransition.page
+      ? { ...csrTransition.page, contentStyle: { ...csrTransition.page.contentStyle, ...contentResizeStyle } }
+      : csrTransition.page;
   const nativeBackStateRef = useRef({
     path: resolvedLocation.pathRoute.path,
     keyboardHeight: keyboardFrame.height,
@@ -1409,6 +1525,7 @@ export const useCsrValues = (rootRouteGuide: RouteGuide, pathRoutes: PathRoute[]
 
   return {
     ...routeState,
-    ...useCsrTransitionMap[resolvedLocation.pathRoute.pageState.transition],
+    ...csrTransition,
+    page,
   } satisfies CsrContextType;
 };

package/webkit/useFrameRuntime.ts

@@ -25,7 +25,10 @@ export type FrameSlotBucket = "active" | "pending";
 export type FrameSlotMapByBucket = Record<FrameSlotBucket, FrameSlotMap>;
 export const PENDING_FRAME_READY_TIMEOUT_MS = 80;
 export const PENDING_FRAME_READY_MAX_TIMEOUT_MS = 120;
-export const KEYBOARD_FALLBACK_ANIMATION_DURATION_MS = 285;
+export const KEYBOARD_SHOW_ANIMATION_DURATION_MS = 420;
+export const KEYBOARD_HIDE_ANIMATION_DURATION_MS = 90;
+export const KEYBOARD_SHOW_ANIMATION_EASING = "cubic-bezier(0.16, 1, 0.3, 1)";
+export const KEYBOARD_HIDE_ANIMATION_EASING = "cubic-bezier(0.7, 0, 0.84, 0)";
 
 export const FRAME_Z_INDEX = {
   page: 10,
@@ -207,9 +210,14 @@ export function useFrameViewport() {
   const updateViewport = useCallback((reason = "viewport.change") => {
     const visualViewport = window.visualViewport;
     const platform = getCurrentPlatform();
+    const usesAkanKeyboardResize = platform === "ios" || platform === "android";
+    const width = Math.round(visualViewport?.width ?? window.innerWidth);
+    const currentHeight = Math.round(window.innerHeight);
+    const stableHeight =
+      usesAkanKeyboardResize && width === viewport.width ? Math.max(viewport.height, currentHeight) : currentHeight;
     const nextViewport = {
-      width: Math.round(visualViewport?.width ?? window.innerWidth),
-      height: Math.round(platform === "ios" ? window.innerHeight : (visualViewport?.height ?? window.innerHeight)),
+      width,
+      height: usesAkanKeyboardResize ? stableHeight : Math.round(visualViewport?.height ?? window.innerHeight),
       visualWidth: Math.round(visualViewport?.width ?? window.innerWidth),
       visualHeight: Math.round(visualViewport?.height ?? window.innerHeight),
       visualOffsetTop: Math.round(visualViewport?.offsetTop ?? 0),
@@ -226,7 +234,7 @@ export function useFrameViewport() {
       debugFrame(reason, { from: prev, to: nextViewport, platform });
       return nextViewport;
     });
-  }, []);
+  }, [viewport.height]);
 
   useEffect(() => {
     updateViewport("viewport.init");
@@ -259,6 +267,10 @@ export function hasKeyboardStickySlot(path: string, frameSlots: FrameSlotMap) {
   return getKeyboardAccessorySlots(path, frameSlots).length > 0;
 }
 
+export function hasBottomAnchoredKeyboardSlot(path: string, frameSlots: FrameSlotMap) {
+  return getKeyboardAccessorySlots(path, frameSlots).some((slot) => slot.contentAnchor === "bottom");
+}
+
 export function resolveKeyboardFrame({
   keyboardHeight,
   bottomSafeArea,
@@ -274,22 +286,36 @@ export function resolveKeyboardFrame({
   sticky: boolean;
   freeze?: boolean;
 }): KeyboardFrameState {
+  const useVisualViewportHeight = platformProfile === "android" && visualViewportKeyboardHeight > 0;
   const visualFallbackHeight =
     keyboardHeight <= 0 && visualViewportKeyboardHeight > 0 ? visualViewportKeyboardHeight : 0;
-  const effectiveKeyboardHeight = keyboardHeight > 0 ? keyboardHeight : visualFallbackHeight;
-  const source = keyboardHeight > 0 ? "native" : visualFallbackHeight > 0 ? "visualViewport" : "fallback";
+  const effectiveKeyboardHeight = useVisualViewportHeight
+    ? visualViewportKeyboardHeight
+    : keyboardHeight > 0
+      ? keyboardHeight
+      : visualFallbackHeight;
+  const source = useVisualViewportHeight
+    ? "visualViewport"
+    : keyboardHeight > 0
+      ? "native"
+      : visualFallbackHeight > 0
+        ? "visualViewport"
+        : "fallback";
   const visualCompensation =
-    platformProfile === "ios" ? 0 : Math.min(visualViewportKeyboardHeight, effectiveKeyboardHeight);
+    platformProfile === "web" || platformProfile === "mobileWeb"
+      ? Math.min(visualViewportKeyboardHeight, effectiveKeyboardHeight)
+      : 0;
   const offset = sticky && !freeze ? Math.max(0, effectiveKeyboardHeight - visualCompensation) : 0;
+  const isShowing = effectiveKeyboardHeight > 0 && !freeze;
   return {
     height: effectiveKeyboardHeight,
     offset,
-    visible: effectiveKeyboardHeight > 0 && !freeze,
+    visible: isShowing,
     sticky,
     frozen: freeze,
     source,
-    animationDuration: KEYBOARD_FALLBACK_ANIMATION_DURATION_MS,
-    animationEasing: "ease-out",
+    animationDuration: isShowing ? KEYBOARD_SHOW_ANIMATION_DURATION_MS : KEYBOARD_HIDE_ANIMATION_DURATION_MS,
+    animationEasing: isShowing ? KEYBOARD_SHOW_ANIMATION_EASING : KEYBOARD_HIDE_ANIMATION_EASING,
   };
 }
 
@@ -344,14 +370,18 @@ export function useKeyboardFrame({
 }: {
   bottomSafeArea: number;
   sticky: boolean;
-  viewport: { visualHeight: number; visualOffsetTop: number };
+  viewport: { height: number; visualHeight: number; visualOffsetTop: number };
   platformProfile: FramePlatformProfile;
   freeze?: boolean;
 }) {
   const keyboardHeight = st.use.keyboardHeight();
+  const androidViewportKeyboardHeight =
+    platformProfile === "android" ? Math.max(0, Math.round(viewport.height - window.innerHeight)) : 0;
   const visualViewportKeyboardHeight = Math.max(
     0,
-    Math.round(window.innerHeight - viewport.visualHeight - viewport.visualOffsetTop),
+    androidViewportKeyboardHeight > 0
+      ? androidViewportKeyboardHeight
+      : Math.round(viewport.height - viewport.visualHeight - viewport.visualOffsetTop),
   );
   return useMemo(
     () =>

package/server/resolver/CascadeRunner.ts

@@ -1,201 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { LIBS_REMOVE_HOOK } from "akanjs/base";
-import { Logger } from "akanjs/common";
-import { type CascadeWithPath, type ConstantModel, ConstantRegistry } from "akanjs/constant";
-import { type DocumentSchema, documentQueryHelper } from "akanjs/document";
-import type { DatabaseService, ServiceCls } from "akanjs/service";
-
-/** A relation the removed document owns: the ids it holds name documents to remove. */
-interface RefEdge {
-  readonly key: string;
-  readonly refName: string;
-}
-
-/** A model that declared itself removable with this one: its rows name the removed document as their owner. */
-interface WithEdge {
-  readonly refName: string;
-  readonly key: string;
-  readonly typeKey: string | null;
-}
-
-interface CascadeModule {
-  readonly constant: ConstantModel;
-  readonly schema: DocumentSchema;
-  readonly srvRef: ServiceCls;
-}
-
-interface CascadePlan {
-  readonly refEdges: RefEdge[];
-  readonly withEdges: WithEdge[];
-}
-
-/** One cascade in flight. Shared down the chain so a cycle is caught wherever it closes. */
-interface CascadeContext {
-  readonly seen: Set<string>;
-  readonly depth: number;
-}
-
-/** How deep one removal may cascade before the chain is treated as runaway and abandoned. */
-const maxDepth = 16;
-/** Ids taken per query while draining children one document at a time. */
-const drainSize = 200;
-
-export class CascadeRunner {
-  readonly #modules = new Map<string, CascadeModule>();
-  readonly #plans = new Map<string, CascadePlan>();
-  readonly #bulk = new Set<string>();
-  readonly #context = new AsyncLocalStorage<CascadeContext>();
-  readonly #logger = new Logger("Cascade");
-  #getService: ((refName: string) => DatabaseService) | null = null;
-
-  register(constant: ConstantModel, schema: DocumentSchema, srvRef: ServiceCls) {
-    this.#modules.set(constant.refName, { constant, schema, srvRef });
-  }
-
-  /**
-   * Called once every service is live. A `_postRemove` and a `listenPost("remove")` registered during boot both
-   * count against bulk removal, so the strategy cannot be decided before the last service has initialized.
-   */
-  seal(getService: (refName: string) => DatabaseService) {
-    this.#getService = getService;
-    for (const [refName, mod] of this.#modules) {
-      this.#plans.set(refName, { refEdges: this.#collectRefEdges(refName, mod), withEdges: [] });
-    }
-    for (const [refName, mod] of this.#modules) this.#collectWithEdges(refName, mod);
-    for (const refName of this.#modules.keys()) {
-      if (this.#hasRemoveSideEffect(refName)) continue;
-      this.#bulk.add(refName);
-    }
-    this.#report();
-  }
-
-  async run(refName: string, doc: Record<string, unknown>) {
-    const plan = this.#plans.get(refName);
-    if (!plan?.refEdges.length && !plan?.withEdges.length) return;
-    const parent = this.#context.getStore();
-    const seen = parent?.seen ?? new Set<string>();
-    const depth = (parent?.depth ?? 0) + 1;
-    const id = typeof doc.id === "string" ? doc.id : null;
-    if (id) seen.add(`${refName}:${id}`);
-    if (depth > maxDepth) {
-      this.#logger.error(`Cascade from ${refName} exceeded depth ${maxDepth} and was abandoned`);
-      return;
-    }
-    await this.#context.run({ seen, depth }, async () => {
-      for (const edge of plan.refEdges) await this.#removeRef(edge, doc, seen);
-      if (id) for (const edge of plan.withEdges) await this.#removeWith(edge, refName, id, seen);
-    });
-  }
-
-  async #removeRef(edge: RefEdge, doc: Record<string, unknown>, seen: Set<string>) {
-    const value = doc[edge.key];
-    const ids = (Array.isArray(value) ? value : [value]).filter(
-      (item): item is string => typeof item === "string" && !seen.has(`${edge.refName}:${item}`),
-    );
-    if (!ids.length) return;
-    const service = this.#service(edge.refName);
-    if (this.#bulk.has(edge.refName)) {
-      await service.__removeMany({ id: documentQueryHelper.oneOf(ids) });
-      return;
-    }
-
-    for (const id of ids) await service.__remove(id);
-  }
-
-  async #removeWith(edge: WithEdge, ownerRef: string, ownerId: string, seen: Set<string>) {
-    const service = this.#service(edge.refName);
-    const query = edge.typeKey ? { [edge.key]: ownerId, [edge.typeKey]: ownerRef } : { [edge.key]: ownerId };
-    if (this.#bulk.has(edge.refName)) {
-      await service.__removeMany(query);
-      return;
-    }
-
-    for (;;) {
-      const ids = await service.__listIds(query, { limit: drainSize });
-      if (!ids.length) return;
-      let removed = 0;
-      for (const id of ids) {
-        if (seen.has(`${edge.refName}:${id}`)) continue;
-        await service.__remove(id);
-        removed += 1;
-      }
-      if (!removed) return;
-    }
-  }
-
-  #collectRefEdges(refName: string, mod: CascadeModule) {
-    return [...mod.constant.full.cascade.removeRef].map(([key, modelRef]) => {
-      const target = ConstantRegistry.getRefName(modelRef);
-
-      if (!this.#modules.has(target)) {
-        throw new Error(`Cascade field "${refName}.${key}" removes "${target}", which this app does not mount`);
-      }
-      return { key, refName: target };
-    });
-  }
-
-  #collectWithEdges(childRef: string, mod: CascadeModule) {
-    for (const [key, path] of mod.constant.full.cascade.removeWith) {
-      for (const owner of this.#resolveOwners(childRef, key, path)) {
-        this.#plans.get(owner)?.withEdges.push({ refName: childRef, key, typeKey: path.typeKey });
-      }
-    }
-  }
-
-  #resolveOwners(childRef: string, key: string, path: CascadeWithPath) {
-    if (path.typeValues.length) {
-
-      const mounted = path.typeValues.filter((owner) => this.#modules.has(owner));
-      for (const owner of path.typeValues) {
-        if (mounted.includes(owner)) continue;
-        this.#logger.warn(`Cascade field "${childRef}.${key}" names owner "${owner}", which this app does not mount`);
-      }
-      return mounted;
-    }
-    const owner = path.refName ?? ConstantRegistry.getRefName(path.modelRef as never);
-    if (!this.#modules.has(owner)) {
-      throw new Error(`Cascade field "${childRef}.${key}" is owned by "${owner}", which this app does not mount`);
-    }
-    return [owner];
-  }
-
-  /** Everything a bulk `removeMany` would skip. All of it absent means the two paths leave the same rows behind. */
-  #hasRemoveSideEffect(refName: string) {
-    const mod = this.#modules.get(refName);
-    if (!mod) return true;
-    if (mod.schema.preHooks.get("remove")?.length || mod.schema.postHooks.get("remove")?.length) return true;
-    if ((mod.srvRef as unknown as { [LIBS_REMOVE_HOOK]?: boolean })[LIBS_REMOVE_HOOK]) return true;
-    const proto = mod.srvRef.prototype as { _preRemove?: unknown; _postRemove?: unknown };
-    if (typeof proto._preRemove === "function" || typeof proto._postRemove === "function") return true;
-    const plan = this.#plans.get(refName);
-    return !!plan?.refEdges.length || !!plan?.withEdges.length;
-  }
-
-  /** Neither the strategy nor the edge list is visible from the source, and adding a `_postRemove` to a target
-   * silently flips it from one query back to one per document. A quiet cascade is the one nobody can explain. */
-  #report() {
-    const lines: string[] = [];
-    for (const [refName, plan] of this.#plans) {
-      for (const edge of plan.refEdges) {
-        lines.push(`${refName}.${edge.key} removeRef ${edge.refName} (${this.#strategy(edge.refName)})`);
-      }
-      for (const edge of plan.withEdges) {
-        const path = edge.typeKey ? `${edge.key}+${edge.typeKey}` : edge.key;
-        lines.push(`${refName} removeWith ${edge.refName}.${path} (${this.#strategy(edge.refName)})`);
-      }
-    }
-    if (!lines.length) return;
-    const bulk = lines.filter((line) => line.endsWith("(bulk)")).length;
-    this.#logger.info(`${lines.length} cascade edge(s), ${bulk} in one query`);
-    for (const line of lines) this.#logger.verbose(line);
-  }
-
-  #strategy(refName: string) {
-    return this.#bulk.has(refName) ? "bulk" : "per document";
-  }
-
-  #service(refName: string) {
-    if (!this.#getService) throw new Error(`Cascade ran before the plan was sealed: ${refName}`);
-    return this.#getService(refName);
-  }
-}

package/types/server/resolver/CascadeRunner.d.ts

@@ -1,13 +0,0 @@
-import { type ConstantModel } from "akanjs/constant";
-import { type DocumentSchema } from "akanjs/document";
-import type { DatabaseService, ServiceCls } from "akanjs/service";
-export declare class CascadeRunner {
-    #private;
-    register(constant: ConstantModel, schema: DocumentSchema, srvRef: ServiceCls): void;
-    /**
-     * Called once every service is live. A `_postRemove` and a `listenPost("remove")` registered during boot both
-     * count against bulk removal, so the strategy cannot be decided before the last service has initialized.
-     */
-    seal(getService: (refName: string) => DatabaseService): void;
-    run(refName: string, doc: Record<string, unknown>): Promise<void>;
-}