akanjs 3.0.0-alpha.1 → 3.0.0-alpha.10

package/base/symbols.ts

@@ -3,6 +3,7 @@ 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/clientRuntime.ts

@@ -75,6 +75,13 @@ globalWithRuntime[CLIENT_RUNTIME_KEY] = state;
 const missingRuntimeError = () =>
   new Error("Akan client runtime is not registered. Import the generated app client first.");
 
+const applyRuntimeErrorConstructor = (runtime: ClientRuntime) => {
+  const instance = (runtime.fetch as RuntimeFetch | undefined)?.instance as
+    | { setErrorConstructor?: (Err: unknown) => void }
+    | undefined;
+  if (typeof instance?.setErrorConstructor === "function") instance.setErrorConstructor(runtime.Err);
+};
+
 export const registerClientRuntime = <Runtime>(
   runtime: Runtime,
   { scope = "app" }: { scope?: RuntimeScope } = {},
@@ -82,6 +89,7 @@ export const registerClientRuntime = <Runtime>(
   if (state.scope === "app" && scope === "lib") return runtime;
   state.runtime = runtime as ClientRuntime;
   state.scope = scope;
+  applyRuntimeErrorConstructor(state.runtime);
   return runtime;
 };
 

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/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/common/deepObjectify.ts

@@ -1,9 +1,16 @@
 import { isDayjs } from "./isDayjs";
 
-export const deepObjectify = <T = unknown>(
-  obj: T | null | undefined,
-  option: { serializable?: boolean; convertDate?: "string" | "number" } = {},
-): T => {
+interface DeepObjectifyOption {
+  serializable?: boolean;
+  convertDate?: "string" | "number";
+}
+
+const objectifyChild = (value: unknown, option: DeepObjectifyOption): unknown => {
+  const modelValue = value as { __ModelType__?: string } | null | undefined;
+  return modelValue?.__ModelType__ && !option.serializable ? value : deepObjectify(value, option);
+};
+
+export const deepObjectify = <T = unknown>(obj: T | null | undefined, option: DeepObjectifyOption = {}): T => {
   if (isDayjs(obj) || obj?.constructor === Date) {
     if (!option.serializable && !option.convertDate) return obj as T;
     if (option.convertDate === "string") return obj.toISOString() as T;
@@ -12,13 +19,20 @@ export const deepObjectify = <T = unknown>(
     else return (isDayjs(obj) ? obj.toDate() : obj) as T;
   } else if (Array.isArray(obj)) {
     return obj.map((o: unknown) => deepObjectify(o, option)) as T;
+  } else if (obj instanceof Map) {
+    
+    const entries = [...obj.entries()].map(
+      ([key, value]: [string, unknown]) => [key, objectifyChild(value, option)] as const,
+    );
+    return (option.serializable ? Object.fromEntries(entries) : new Map(entries)) as T;
+  } else if (obj instanceof Set) {
+    const values = [...obj.values()].map((value: unknown) => objectifyChild(value, option));
+    return (option.serializable ? values : new Set(values)) as T;
   } else if (obj && typeof obj === "object") {
     const val: Record<string, unknown> = {};
     const objRecord = obj as Record<string, unknown>;
     Object.keys(obj).forEach((key) => {
-      const fieldValue = objRecord[key] as { __ModelType__: string } | null | undefined;
-      if (fieldValue?.__ModelType__ && !option.serializable) val[key] = fieldValue;
-      else if (typeof objRecord[key] !== "function") val[key] = deepObjectify(fieldValue, option);
+      if (typeof objRecord[key] !== "function") val[key] = objectifyChild(objRecord[key], option);
     });
     return val as T;
   } else {

package/common/index.ts

@@ -36,12 +36,17 @@ export { randomPicks } from "./randomPicks";
 export {
   assertUniqueRoutePatterns,
   compareRouteSpecificity,
+  getRouteExports,
   isRouteSourceFile,
   isSpecialRouteLeaf,
+  LAYOUT_ROUTE_EXPORTS,
   matchRoutePattern,
   normalizeRoutePattern,
+  PAGE_ROUTE_EXPORTS,
   type ParsedRouteModuleKey,
   parseRouteModuleKey,
+  RESERVED_ROUTE_CONFIG_EXPORTS,
+  ROOT_LAYOUT_ROUTE_EXPORTS,
   type RouteModuleKind,
   routeSegmentToPatternPart,
   routeSegmentToTreePath,

package/common/pathSet.ts

@@ -1,16 +1,28 @@
 type MutableIndexable = Record<string | number, unknown>;
 type PathSegment = string | number;
+type Container = MutableIndexable | Map<PathSegment, unknown>;
 
 const toPathSegments = (path: string | readonly PathSegment[]) =>
   Array.isArray(path) ? [...path] : path.toString().match(/[^.[\]]+/g) || [];
 
+const readChild = (container: Container, key: PathSegment) =>
+  container instanceof Map ? container.get(key) : container[key];
+
+const writeChild = (container: Container, key: PathSegment, value: unknown) => {
+  if (container instanceof Map) container.set(key, value);
+  else container[key] = value;
+};
+
 export const pathSet = <T>(obj: T, path: string | readonly PathSegment[], value: unknown): T => {
   if (Object(obj) !== obj) return obj;
   const pathSegments = toPathSegments(path);
-  pathSegments.slice(0, -1).reduce<MutableIndexable>((a, c, i) => {
-    if (Object(a[c]) === a[c]) return a[c] as MutableIndexable;
-    a[c] = Math.abs(Number(pathSegments[i + 1])) >> 0 === +pathSegments[i + 1] ? [] : {};
-    return a[c] as MutableIndexable;
-  }, obj as MutableIndexable)[pathSegments[pathSegments.length - 1]] = value;
+  const parent = pathSegments.slice(0, -1).reduce<Container>((a, c, i) => {
+    const child = readChild(a, c);
+    if (Object(child) === child) return child as Container;
+    const created = Math.abs(Number(pathSegments[i + 1])) >> 0 === +pathSegments[i + 1] ? [] : {};
+    writeChild(a, c, created);
+    return created as unknown as Container;
+  }, obj as Container);
+  writeChild(parent, pathSegments[pathSegments.length - 1], value);
   return obj;
 };

package/common/routeConvention.ts

@@ -9,6 +9,36 @@ const DIRECTORY_SCOPED_LEAVES = new Set(["_layout", "_index", "_overrides"]);
 
 export type RouteModuleKind = "page" | "layout" | "overrides";
 
+export const PAGE_ROUTE_EXPORTS: ReadonlySet<string> = new Set([
+  "default",
+  "pageConfig",
+  "head",
+  "metadata",
+  "generateHead",
+  "generateMetadata",
+  "Loading",
+]);
+export const LAYOUT_ROUTE_EXPORTS: ReadonlySet<string> = new Set([...PAGE_ROUTE_EXPORTS, "NotFound", "Error"]);
+export const ROOT_LAYOUT_ROUTE_EXPORTS: ReadonlySet<string> = new Set([
+  ...LAYOUT_ROUTE_EXPORTS,
+  "fonts",
+  "manifest",
+  "theme",
+  "reconnect",
+  "wsConnect",
+  "layoutStyle",
+  "gaTrackingId",
+]);
+/** Root-layout exports that are plain config rather than components, so a PascalCase check cannot allow them. */
+export const RESERVED_ROUTE_CONFIG_EXPORTS: ReadonlySet<string> = new Set(
+  [...ROOT_LAYOUT_ROUTE_EXPORTS].filter((name) => name !== "default" && !/^[A-Z]/.test(name)),
+);
+
+export function getRouteExports(kind: "page" | "layout", { rootLayout = false } = {}): ReadonlySet<string> {
+  if (kind === "page") return PAGE_ROUTE_EXPORTS;
+  return rootLayout ? ROOT_LAYOUT_ROUTE_EXPORTS : LAYOUT_ROUTE_EXPORTS;
+}
+
 export interface ParsedRouteModuleKey {
   key: string;
   kind: RouteModuleKind;

package/constant/cascadePaths.ts

@@ -1,32 +1,103 @@
+import { type Cls, PrimitiveRegistry, type PrimitiveScalar } from "akanjs/base";
 import type { ConstantField, FieldObject } from "./fieldInfo";
 import type { ConstantModelRef } from "./via";
 
-/** What happens to the documents a relation field points at when the owner is removed. */
-export const cascadeActions = ["remove"] as const;
+/**
+ * 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;
 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. Resolved to a refName later: the target may not be registered yet. */
-  readonly remove = new Map<string, ConstantModelRef>();
+  /** 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>();
 
   collect(fieldMap: FieldObject) {
     for (const [key, field] of Object.entries(fieldMap)) {
       if (!field.cascade) continue;
-      this.#assertCascadable(key, field.cascade, field);
-      this.remove.set(key, field.modelRef);
+      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));
     }
     return this;
   }
 
-  #assertCascadable(key: string, action: CascadeAction, field: ConstantField) {
-    
+  #assertKnownAction(key: string, action: CascadeAction) {
+
     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/constant/crystalize.ts

@@ -30,8 +30,10 @@ export const crystalize = (field: FieldProps, value: unknown): unknown => {
       isArray: false,
       arrDepth: 0,
     };
+    
+    const entries = value instanceof Map ? [...value.entries()] : Object.entries(value as Record<string, unknown>);
     return new Map(
-      Object.entries(value as Record<string, unknown>).map(([key, val]) => [
+      entries.map(([key, val]: [string, unknown]) => [
         key,
         field.of
           ? applyFnToArrayObjects(val, (v: never) => crystalize(mapValueField, v))

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/document/database.ts

@@ -3,8 +3,9 @@ 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 } from "./into";
+import type { CRUDEventType, Mdl, SaveEventType, UpdateResult } from "./into";
 import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types";
 
 export class CacheDatabase<T = unknown> {
@@ -25,6 +26,15 @@ 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,
@@ -53,6 +63,14 @@ 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
@@ -105,6 +123,10 @@ 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: ConstantCls<Insight>;
+  insight: DatabaseCls<Insight>;
   _Input: Input;
   _Doc: Doc;
   _Model: Model;
@@ -92,7 +92,7 @@ export class DatabaseRegistry {
     doc: DatabaseCls<Doc>,
     model: ModelCls<Model>,
     obj: ConstantCls<Obj>,
-    insight: ConstantCls<Insight>,
+    insight: DatabaseCls<Insight>,
     filter: FilterCls<Filter>,
   ): DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter, _Query, _Sort> {
     const dbInfo = {

package/document/filterMeta.ts

@@ -98,6 +98,13 @@ 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,22 +77,29 @@ 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>;
-  countDocuments(query: _RawQuery): Promise<number>;
+  count(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>;
-  deleteMany(query: _RawQuery): Promise<UpdateResult>;
+  removeOne(query: _RawQuery): Promise<UpdateResult>;
+  removeMany(query: _RawQuery): Promise<UpdateResult>;
+  updateById(id: string, update: DocumentUpdateInput<_RawDoc>, options?: DocumentUpdateOptions): Promise<UpdateResult>;
+  removeById(id: string): 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> {
+interface IntoConstantModel<T extends string, _CapitalizedRefName extends string, Raw, Insight> {
   refName: T;
   _CapitalizedRefName: _CapitalizedRefName;
   _Full: Raw;
+  _Insight: Insight;
 }
 type NoInferType<T> = [T][T extends unknown ? 0 : never];
 type IntoModelActions<
@@ -100,6 +107,8 @@ type IntoModelActions<
   _CapitalizedRefName extends string,
   Doc,
   Raw,
+  
+  Insight,
   _Query,
   _Sort,
   _QueryOfDoc = QueryOf<Doc>,
@@ -121,13 +130,14 @@ 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, unknown, unknown, unknown, _QueryOfDoc>;
+} & QueryMethodPart<_Query, _Sort, Raw, Doc, DocumentModel<Insight>, unknown, unknown, _QueryOfDoc>;
 
 export const into = <
   Doc,
   FilterRef extends FilterCls,
   T extends string,
   Raw,
+  Insight,
   AddDbModels extends ModelCls[],
   _CapitalizedRefName extends string,
   _QueryOfDoc = QueryOf<Doc>,
@@ -137,11 +147,11 @@ export const into = <
 >(
   docRef: Cls<Doc>,
   filterRef: FilterRef,
-  cnst: IntoConstantModel<T, _CapitalizedRefName, Raw>,
+  cnst: IntoConstantModel<T, _CapitalizedRefName, Raw, Insight>,
   loaderBuilder: _LoaderBuilder,
   ...addMdls: [...AddDbModels]
 ): ModelCls<
-  IntoModelActions<T, _CapitalizedRefName, Doc, Raw, _Query, _Sort, _QueryOfDoc>,
+  IntoModelActions<T, _CapitalizedRefName, Doc, Raw, Insight, _Query, _Sort, _QueryOfDoc>,
   ReturnType<_LoaderBuilder>
 > => {
   const loaderInfoMap = loaderBuilder(makeLoaderBuilder<Doc>());
@@ -162,7 +172,7 @@ export const into = <
     });
   });
   return DefaultModel as unknown as ModelCls<
-    IntoModelActions<T, _CapitalizedRefName, Doc, Raw, _Query, _Sort, _QueryOfDoc>,
+    IntoModelActions<T, _CapitalizedRefName, Doc, Raw, Insight, _Query, _Sort, _QueryOfDoc>,
     ReturnType<_LoaderBuilder>
   >;
 };

package/fetch/client/fetchClient.ts

@@ -37,6 +37,16 @@ export type FetchProxy<
   FetchClient &
   FetchType & { slice: SliceMetaObj; instance: FetchClient; _FetchType: FetchType; _SliceMetaObj: SliceMetaObj };
 
+interface SharedClientState {
+  proxy: FetchProxy | null;
+  origin: string | null;
+}
+
+const SHARED_CLIENT_KEY = Symbol.for("akanjs.fetch.sharedClient");
+const globalWithSharedClient = globalThis as typeof globalThis & { [SHARED_CLIENT_KEY]?: SharedClientState };
+const sharedClientState: SharedClientState = globalWithSharedClient[SHARED_CLIENT_KEY] ?? { proxy: null, origin: null };
+globalWithSharedClient[SHARED_CLIENT_KEY] = sharedClientState;
+
 type ClientSignalMap<SigType extends { fetch: any }> = {
   [K in keyof SigType as SigType[K] extends DatabaseSignal<any, any, any, any>
     ? K
@@ -80,6 +90,19 @@ export class FetchClient {
     FetchClient.#sharedSerializedSignal = {};
     FetchClient.#sharedRegistryVersion++;
   }
+  static resetSharedClient() {
+    sharedClientState.proxy = null;
+    sharedClientState.origin = null;
+  }
+  static #resolveSharedClientProxy(origin: string, Err?: ErrorConstructor) {
+    if (typeof window === "undefined") return null;
+    
+    if (sharedClientState.proxy) return sharedClientState.origin === origin ? sharedClientState.proxy : null;
+    const proxy = FetchClient.#makeProxy<unknown, Record<string, SliceMeta>>(new FetchClient(origin, {}, {}, Err));
+    sharedClientState.proxy = proxy;
+    sharedClientState.origin = origin;
+    return proxy;
+  }
   static #mergeSerializedSignalInto(
     serializedSignal: { [key: string]: SerializedSignal },
     refName: string,
@@ -700,10 +723,11 @@ export class FetchClient {
     sig: ClientSignalMap<SigType>;
     fetch: SigType["fetch"];
   } {
-    if (base) base.instance.applySignal(serializedSignal);
+    const shared = base ?? FetchClient.#resolveSharedClientProxy(origin, Err);
+    if (shared) shared.instance.applySignal(serializedSignal);
     if (base && Err) base.instance.setErrorConstructor(Err);
     const proxy =
-      base ??
+      shared ??
       FetchClient.#makeProxy<unknown, Record<string, SliceMeta>>(new FetchClient(origin, {}, serializedSignal, Err));
     if (connect) proxy.instance.connect();
     const sig = {} as any;