akanjs 3.0.0-alpha.67 → 3.0.0-alpha.69

package/common/mcpExposure.ts

@@ -16,9 +16,13 @@ export interface McpExposureEndpoint {
   args: { name: string; refName: string; type: string; arrDepth?: number; nullable?: boolean }[];
   guards?: string[];
   fileUpload?: boolean;
+  mcp?: boolean;
 }
 
 export interface McpExposureOption {
+  /** The model the endpoint belongs to and the name it is published under: one rule reads the key, not the shape. */
+  refName: string;
+  key: string;
   /**
    * The read-only deployment valve, which is server configuration. The browser explorer cannot know it and so
    * badges what the code decided; the boot log is where a read-only deployment says what it dropped.
@@ -56,10 +60,19 @@ export const mcpHintsOf = (key: string, endpoint: { type: string }) => {
 };
 
 /** The sentence explaining why this endpoint is not in the catalogue, or `null` when it is. */
-export const mcpRefusalOf = (endpoint: McpExposureEndpoint, { readOnly }: McpExposureOption = {}): string | null => {
+export const mcpRefusalOf = (
+  endpoint: McpExposureEndpoint,
+  { refName, key, readOnly }: McpExposureOption,
+): string | null => {
+
+  if (endpoint.mcp === false)
+    return "it declares `mcp: false`, so it is deliberately off the agent shelf. HTTP still serves it.";
 
   if (!endpoint.guards?.length)
     return "it declares no guards, and exposure follows them — write `guards: [Public]` if anonymous access is the intent.";
+
+  if (key === `light${capitalize(refName)}`)
+    return `it reads the same document as \`${refName}\` in a smaller shape — call \`${refName}\` instead.`;
   if (endpoint.type === "prompt") return mcpPromptRefusalOf(endpoint);
   if (endpoint.type === "pubsub" || endpoint.type === "message")
     return `\`${endpoint.type}\` rides the websocket, and its internal arguments read a socket an MCP request does not have.`;

package/constant/crystalize.ts

@@ -11,6 +11,50 @@ import type { FieldProps } from ".";
 
 export type CrystalizeFunc<Model> = (self: GetStateObject<Model>, isChild?: boolean) => Model;
 
+/**
+ * The relation instances one hydration pass has already built, by model class and then document id.
+ *
+ * A listing hands the same relation to every row that references it — twenty users wearing one avatar — and
+ * each row would otherwise build its own copy of it, re-parsing every `Date` on the way. Sharing is safe
+ * because a constant model is `[immerable]`: a store write copies before it mutates.
+ *
+ * Module-scoped rather than passed down, because `crystalize` is reached through a model's own constructor,
+ * which has nowhere to carry it. A pass is wholly synchronous, so no other one can observe this mid-flight.
+ */
+let sharedInstances: Map<Cls, Map<string, object>> | null = null;
+
+/** Runs one hydration pass, sharing a relation instance across every value in it that names the same id. */
+export const withSharedInstances = <T>(hydrate: () => T): T => {
+  if (sharedInstances) return hydrate();
+  sharedInstances = new Map();
+  try {
+    return hydrate();
+  } finally {
+    sharedInstances = null;
+  }
+};
+
+type ModelCls = Cls<{ set: (obj: object) => object }>;
+
+const relationIdOf = (value: object): string | null => {
+  const id = (value as { id?: unknown }).id;
+  return typeof id === "string" && id ? id : null;
+};
+
+const crystalizeModel = (field: FieldProps, value: object): object => {
+  const modelRef = field.modelRef as ModelCls;
+
+  if (value instanceof modelRef) return value;
+
+  const id = field.isScalar ? null : relationIdOf(value);
+  if (!sharedInstances || !id) return new modelRef().set(value);
+  const byId = sharedInstances.get(modelRef) ?? new Map<string, object>();
+  if (!sharedInstances.has(modelRef)) sharedInstances.set(modelRef, byId);
+  const shared = byId.get(id) ?? new modelRef().set(value);
+  byId.set(id, shared);
+  return shared;
+};
+
 export const crystalize = (field: FieldProps, value: unknown): unknown => {
   if (value === undefined || value === null) return value as undefined | null;
   if (field.isArray && Array.isArray(value))
@@ -41,7 +85,7 @@ export const crystalize = (field: FieldProps, value: unknown): unknown => {
       ]),
     );
   }
-  if (field.isClass) return new (field.modelRef as Cls<{ set: (obj: object) => object }>)().set(value as object);
+  if (field.isClass) return crystalizeModel(field, value as object);
   if (field.modelRef === Date) return dayjs(value as Date);
   return crystalizeValue(value);
 };

package/constant/deserialize.ts

@@ -1,6 +1,6 @@
 import { Any, applyFnToArrayObjects, type Cls, FIELD_META, PrimitiveRegistry, type PrimitiveScalar } from "akanjs/base";
 
-import { type ConstantCls, type ConstantModelRef, ConstantRegistry, type FieldProps } from ".";
+import { type ConstantCls, type ConstantModelRef, ConstantRegistry, type FieldProps, withSharedInstances } from ".";
 
 const getDeserializeFn = (inputRef: ConstantModelRef | PrimitiveScalar) => {
   const deserializeFn = PrimitiveRegistry.has(inputRef as Cls)
@@ -66,5 +66,6 @@ export const deserialize = (
   if (nullable && (value === null || value === undefined)) return null;
   else if (!nullable && (value === null || value === undefined) && argRef !== Any)
     throw new Error(`Invalid Value (Nullable) in ${key} ${argRef} for value ${value}`);
-  return deserializeInput(value, argRef, arrDepth, convertFn) as object[];
+
+  return withSharedInstances(() => deserializeInput(value, argRef, arrDepth, convertFn)) as object[];
 };

package/constant/types.ts

@@ -30,7 +30,11 @@ export type DocumentModel<T> = unknown extends T
         : Docify<T>;
 
 export type FieldState<T> = T extends { id: string } ? T | null : T;
-export type DefaultOf<S> = GetStateObject<{ [K in keyof S]: FieldState<S[K]> }>;
+export type DefaultOf<S> = {
+  [K in keyof S as S[K] extends (...args: never[]) => unknown ? never : K extends "prototype" ? never : K]: FieldState<
+    S[K]
+  >;
+};
 
 export type DefaultOfSchema<Schema, RelationKey = never> = [RelationKey] extends [never]
   ? Schema

package/dictionary/base.dictionary.ts

@@ -27,6 +27,24 @@ export const baseDictionary = serviceDictionary(["en", "ko"])
       })),
     pubsubPing: fn(["Pubsub Ping", "Pubsub Ping"]),
   }))
+  .error({
+    serverUnreachable: [
+      "Cannot reach the server. Check your connection and try again.",
+      "서버에 연결할 수 없습니다. 네트워크 상태를 확인한 뒤 다시 시도해주세요.",
+    ],
+    serverUnavailable: [
+      "The server is restarting. Please try again in a moment.",
+      "서버가 재시작 중입니다. 잠시 후 다시 시도해주세요.",
+    ],
+    gatewayTimeout: [
+      "The server took too long to answer. Please try again in a moment.",
+      "서버 응답이 지연되고 있습니다. 잠시 후 다시 시도해주세요.",
+    ],
+    unexpectedResponse: [
+      "The server returned an unexpected response ({status}).",
+      "서버가 예상하지 못한 응답을 보냈습니다. ({status})",
+    ],
+  })
   .translate({
     somethingWrong: ["Something's wrong!", "문제가 생겼어요!"],
     connecting: ["Connecting...", "연결 중..."],

package/fetch/client/fetchClient.ts

@@ -1,6 +1,13 @@
 import { DataList, getEnv, PrimitiveRegistry, type PromiseOrObject } from "akanjs/base";
 import { capitalize, type FetchPolicy, fileUploadContract, Logger, resolveFileUploadCapability } from "akanjs/common";
-import { type BaseInsight, type BaseObject, ConstantRegistry, deserialize, serialize } from "akanjs/constant";
+import {
+  type BaseInsight,
+  type BaseObject,
+  ConstantRegistry,
+  deserialize,
+  serialize,
+  withSharedInstances,
+} from "akanjs/constant";
 import type {
   DatabaseSignal,
   SerializedArg,
@@ -436,6 +443,9 @@ export class FetchClient {
     const createGuards = signal.createGuards ?? signal.cruGuards;
     const updateGuards = signal.updateGuards ?? signal.cruGuards;
     const removeGuards = signal.removeGuards ?? signal.cruGuards;
+
+    const mcp = (verb: keyof NonNullable<SerializedSignal["mcp"]>) =>
+      signal.mcp?.[verb] === false ? { mcp: false as const } : {};
     const endpoint: { [key: string]: SerializedEndpoint } = {};
     if (signal.getGuards) {
       endpoint[names.model] = {
@@ -443,12 +453,14 @@ export class FetchClient {
         args: [{ type: "param", name: names.modelId, refName: "ID" }],
         returns: { refName, modelType: "full" },
         guards: signal.getGuards,
+        ...mcp("get"),
       };
       endpoint[names.lightModel] = {
         type: "query",
         args: [{ type: "param", name: names.modelId, refName: "ID" }],
         returns: { refName, modelType: "light" },
         guards: signal.getGuards,
+        ...mcp("get"),
       };
     }
     if (createGuards) {
@@ -457,6 +469,7 @@ export class FetchClient {
         args: [{ type: "body", name: "data", refName, modelType: "input" }],
         returns: { refName, modelType: "full" },
         guards: createGuards,
+        ...mcp("create"),
       };
     }
     if (updateGuards) {
@@ -468,6 +481,7 @@ export class FetchClient {
         ],
         returns: { refName, modelType: "full" },
         guards: updateGuards,
+        ...mcp("update"),
       };
     }
     if (removeGuards) {
@@ -476,6 +490,7 @@ export class FetchClient {
         args: [{ type: "param", name: names.modelId, refName: "ID" }],
         returns: { refName, modelType: "full" },
         guards: removeGuards,
+        ...mcp("remove"),
       };
     }
     return endpoint;
@@ -595,18 +610,22 @@ export class FetchClient {
       list: `${refName}List${capSuffix}`,
       insight: `${refName}Insight${capSuffix}`,
     };
+
+    const mcp = slice.mcp === false ? { mcp: false as const } : {};
     const endpoint: { [key: string]: SerializedEndpoint } = {
       [names.list]: {
         type: "query",
         args: [...slice.args, ...FetchClient.paginationArgs],
         returns: { refName, modelType: "light", arrDepth: 1 },
         guards: slice.guards,
+        ...mcp,
       },
       [names.insight]: {
         type: "query",
         args: [...slice.args],
         returns: { refName, modelType: "insight" },
         guards: slice.guards,
+        ...mcp,
       },
     };
     return endpoint;
@@ -646,7 +665,9 @@ export class FetchClient {
         listFn(...fetchQueryArgs, skip, limit, sort, { ...option, crystalize: false }),
         fetchInsight ? insightFn(...fetchQueryArgs, { ...option, crystalize: false }) : null,
       ])) as unknown as [BaseObject[], BaseInsight];
-      const modelList = new DataList(modelObjList.map((modelObj) => new cnst.light(modelObj)));
+      const modelList = new DataList(
+        withSharedInstances(() => modelObjList.map((modelObj) => new cnst.light(modelObj))),
+      );
       const modelInsight = new cnst.insight(modelObjInsight);
       const lastPage = modelObjInsight?.count
         ? Math.max(Math.floor((modelObjInsight.count - 1) / (limit || 20)) + 1, 1)

package/fetch/client/httpClient.ts

@@ -27,6 +27,19 @@ interface FetchOptions {
   baseUrl?: string;
 }
 
+const jsonContentType = /^application\/(?:[\w.+-]+\+)?json\b/i;
+
+const transportErrorKeyMap = {
+  408: "base.error.gatewayTimeout",
+  502: "base.error.serverUnavailable",
+  503: "base.error.serverUnavailable",
+  504: "base.error.gatewayTimeout",
+} as const;
+
+const serverUnreachableKey = "base.error.serverUnreachable";
+const unexpectedResponseKey = "base.error.unexpectedResponse";
+const transportDetailLimit = 200;
+
 export class HttpClient {
   readonly baseUrl: string;
   constructor(
@@ -42,11 +55,17 @@ export class HttpClient {
   #resolveBaseUrl(baseUrl?: string) {
     return (baseUrl ?? this.baseUrl).replace(/\/$/, "");
   }
+  #resolveUrl(url: string, options: FetchOptions) {
+    return `${this.#resolveBaseUrl(options.baseUrl)}${url}`;
+  }
+
+  static #makeHeaders(headers: Record<string, string>, options: FetchOptions) {
+    return { Accept: "application/json", ...headers, ...options.headers };
+  }
   async get<Returns = unknown>(url: string, options: FetchOptions = {}): Promise<Returns> {
-    const res = await fetch(`${this.#resolveBaseUrl(options.baseUrl)}${url}`, {
-      headers: { "Content-Type": "application/json", ...options.headers },
+    return await this.#request<Returns>(this.#resolveUrl(url, options), {
+      headers: HttpClient.#makeHeaders({ "Content-Type": "application/json" }, options),
     });
-    return await this.#readJsonResponse<Returns>(res);
   }
   #makeReqContent(data: FormData | Record<string, unknown>): { body: BodyInit; headers: Record<string, string> } {
 
@@ -60,12 +79,11 @@ export class HttpClient {
     options: FetchOptions = {},
   ): Promise<Returns> {
     const { body, headers } = this.#makeReqContent(data);
-    const res = await fetch(`${this.#resolveBaseUrl(options.baseUrl)}${url}`, {
+    return await this.#request<Returns>(this.#resolveUrl(url, options), {
       method,
       body,
-      headers: { ...headers, ...options.headers },
+      headers: HttpClient.#makeHeaders(headers, options),
     });
-    return await this.#readJsonResponse<Returns>(res);
   }
   async put<Returns = unknown>(
     url: string,
@@ -82,19 +100,69 @@ export class HttpClient {
     return await this.send<Returns>("POST", url, data, options);
   }
   async delete<Returns = unknown>(url: string, options: FetchOptions = {}): Promise<Returns> {
-    const res = await fetch(`${this.#resolveBaseUrl(options.baseUrl)}${url}`, {
+    return await this.#request<Returns>(this.#resolveUrl(url, options), {
       method: "DELETE",
-      headers: { "Content-Type": "application/json", ...options.headers },
+      headers: HttpClient.#makeHeaders({ "Content-Type": "application/json" }, options),
     });
+  }
+
+  async #request<Returns>(url: string, init: RequestInit): Promise<Returns> {
+    const res = await this.#fetch(url, init);
     return await this.#readJsonResponse<Returns>(res);
   }
 
+  /**
+   * `fetch` rejects only when no response arrived at all — a refused connection, a DNS failure, a socket
+   * dropped mid-flight. That is the server being unreachable, not an error this API reported, so it is
+   * restored as one rather than surfacing the runtime's own `TypeError: Failed to fetch`.
+   */
+  async #fetch(url: string, init: RequestInit) {
+    try {
+      return await fetch(url, init);
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") throw error;
+      throw this.#restoreError({ error: serverUnreachableKey, details: String(error) }, 503);
+    }
+  }
+
   async #readJsonResponse<Returns>(res: Response): Promise<Returns> {
-    const body = await res.json();
+    const body = await this.#readBody(res);
     if (res.ok) return body as Returns;
     throw this.#restoreError(body, res.status);
   }
 
+  /**
+   * A proxy answers a restarting upstream with a page of its own — nginx's `504 Gateway Time-out` HTML,
+   * the federation gateway's plain-text 503. That body is not this API's, so parsing it would surface the
+   * parser's complaint (`Unexpected token '<'`) instead of the fact that the server is down.
+   */
+  async #readBody(res: Response) {
+    if (jsonContentType.test(res.headers.get("content-type") ?? "")) {
+      try {
+        return (await res.json()) as unknown;
+      } catch (error) {
+        throw this.#transportError(res.status, String(error));
+      }
+    }
+    const raw = await res.text();
+    const parsed = HttpClient.#parseJson(raw);
+    if (parsed === undefined) throw this.#transportError(res.status, raw);
+    return parsed;
+  }
+
+  static #parseJson(raw: string): unknown {
+    try {
+      return JSON.parse(raw) as unknown;
+    } catch {
+      return undefined;
+    }
+  }
+
+  #transportError(status: number, detail: string): RestoredError {
+    const error = transportErrorKeyMap[status as keyof typeof transportErrorKeyMap] ?? unexpectedResponseKey;
+    return this.#restoreError({ error, data: { status }, details: detail.slice(0, transportDetailLimit) }, status);
+  }
+
   #restoreError(body: unknown, fallbackStatusCode: number): RestoredError {
     const payload =
       body && typeof body === "object" && "error" in body

package/fetch/fetchType/appliedReturn.type.ts

@@ -25,33 +25,45 @@ export interface QuerySetting {
   queryArgs?: unknown[] | (() => unknown[]);
 }
 
-export type ServerInit<
+type ServerInitShape<
   RefName extends string,
-  Light,
-  Insight = any,
-  QueryArgs = any,
-  Filter extends FilterInstance = any,
-  _CapitalizedRefName extends string = Capitalize<RefName>,
-  _LightObj = GetStateObject<Light>,
-  _InsightObj = GetStateObject<Insight>,
-  _Sort = ExtractSort<Filter>,
+  QueryArgs,
+  CapRefName extends string,
+  LightObj,
+  InsightObj,
+  Sort,
 > = SliceMeta & {
-  [K in `${RefName}ObjList`]: _LightObj[];
+  [K in `${RefName}ObjList`]: LightObj[];
 } & {
-  [K in `${RefName}ObjInsight`]: _InsightObj;
+  [K in `${RefName}ObjInsight`]: InsightObj;
 } & {
-  [K in `pageOf${_CapitalizedRefName}`]: number;
+  [K in `pageOf${CapRefName}`]: number;
 } & {
-  [K in `lastPageOf${_CapitalizedRefName}`]: number;
+  [K in `lastPageOf${CapRefName}`]: number;
 } & {
-  [K in `limitOf${_CapitalizedRefName}`]: number;
+  [K in `limitOf${CapRefName}`]: number;
 } & {
-  [K in `queryArgsOf${_CapitalizedRefName}`]: QueryArgs;
+  [K in `queryArgsOf${CapRefName}`]: QueryArgs;
 } & {
-  [K in `sortOf${_CapitalizedRefName}`]: _Sort;
+  [K in `sortOf${CapRefName}`]: Sort;
 } & {
   [K in `${RefName}InitAt`]: Date;
 };
+
+export type ServerInit<
+  RefName extends string,
+  Light,
+  Insight = any,
+  QueryArgs = any,
+  Filter extends FilterInstance = any,
+> = ServerInitShape<
+  RefName,
+  QueryArgs,
+  Capitalize<RefName>,
+  GetStateObject<Light>,
+  GetStateObject<Insight>,
+  ExtractSort<Filter>
+>;
 /** Client/server-friendly return type for initialized list and insight data. */
 export type ClientInit<
   RefName extends string,
@@ -59,13 +71,7 @@ export type ClientInit<
   Insight = any,
   QueryArgs = any,
   Filter extends FilterInstance = any,
-  _CapitalizedRefName extends string = Capitalize<RefName>,
-  _LightObj = GetStateObject<Light>,
-  _InsightObj = GetStateObject<Insight>,
-  _Sort = ExtractSort<Filter>,
-> = PromiseOrObject<
-  ServerInit<RefName, Light, Insight, QueryArgs, Filter, _CapitalizedRefName, _LightObj, _InsightObj, _Sort>
->;
+> = PromiseOrObject<ServerInit<RefName, Light, Insight, QueryArgs, Filter>>;
 
 export type ServerView<RefName extends string, Model> = { refName: RefName } & {
   [K in `${RefName}Obj`]: GetStateObject<Model>;
@@ -94,6 +100,18 @@ export type EditReturn<RefName extends string, Full> = {
   [K in `${RefName}Edit`]: ServerEdit<RefName, Full>;
 };
 
+type InitReturnShape<
+  RefName extends string,
+  CapSuffix extends string,
+  Init,
+  ListItem extends { id: string },
+  Insight,
+> = {
+  [K in `${RefName}Init${CapSuffix}`]: Init;
+} & {
+  [K in `${RefName}List${CapSuffix}`]: DataList<ListItem>;
+} & { [K in `${RefName}Insight${CapSuffix}`]: Insight };
+
 export type InitReturn<
   RefName extends string,
   Suffix extends string,
@@ -101,25 +119,11 @@ export type InitReturn<
   Insight,
   Args,
   Filter extends FilterInstance,
-  _CapitalizedRefName extends string = Capitalize<RefName>,
-  _CapitalizedSuffix extends string = Capitalize<Suffix>,
-  _Light extends { id: string } = Light extends { id: string } ? Light : { id: string },
-  _LightObj = GetStateObject<_Light>,
-  _InsightObj = GetStateObject<Insight>,
-  _Sort = ExtractSort<Filter>,
-> = {
-  [K in `${RefName}Init${_CapitalizedSuffix}`]: ServerInit<
-    RefName,
-    Light,
-    Insight,
-    Args,
-    Filter,
-    _CapitalizedRefName,
-    _LightObj,
-    _InsightObj,
-    _Sort
-  >;
-} & {
-  [K in `${RefName}List${_CapitalizedSuffix}`]: DataList<_Light>;
-} & { [K in `${RefName}Insight${_CapitalizedSuffix}`]: Insight };
+> = InitReturnShape<
+  RefName,
+  Capitalize<Suffix>,
+  ServerInit<RefName, Light, Insight, Args, Filter>,
+  Light extends { id: string } ? Light : { id: string },
+  Insight
+>;
 

package/fetch/fetchType/endpointFetch.type.ts

@@ -33,9 +33,12 @@ type EndpointClientReturns<E, SlceCls extends SliceCls | never> = [SlceCls] exte
       SlceCnstInsight<SlceCls>
     >;
 
-type EndpInfoReturns<E, SlceCls extends SliceCls | never> =
-  | EndpointClientReturns<E, SlceCls>
-  | (EndpInfoNullable<E> extends true ? null : never);
+type OrNull<T, Nullable> = Nullable extends true ? T | null : T;
+
+type EndpInfoReturns<E, SlceCls extends SliceCls | never> = OrNull<
+  EndpointClientReturns<E, SlceCls>,
+  EndpInfoNullable<E>
+>;
 
 type QueryOrMutationFetchFn<E, SlceCls extends SliceCls | never> = (
   ...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]

package/fetch/fetchType/sliceFetch.type.ts

@@ -1,10 +1,9 @@
-import type { GetStateObject, SLICE_META } from "akanjs/base";
+import type { SLICE_META } from "akanjs/base";
 import type { FetchPolicy } from "akanjs/common";
 import type { ConstantModel, DefaultOf, ProtoFile, PurifiedModel } from "akanjs/constant";
 import type { DatabaseModel, ExtractSort, FilterInstance } from "akanjs/document";
 import type {
   SlceCnstCapitalizedRefName,
-  SlceCnstDefaultInput,
   SlceCnstFull,
   SlceCnstInput,
   SlceCnstInsight,
@@ -26,11 +25,9 @@ type _Full<S extends SliceCls> = SlceCnstFull<S>;
 type _Light<S extends SliceCls> = SlceCnstLight<S>;
 type _Insight<S extends SliceCls> = SlceCnstInsight<S>;
 type _PurifiedInput<S extends SliceCls> = SlceCnstPurifiedInput<S>;
-type _DefaultInput<S extends SliceCls> = SlceCnstDefaultInput<S>;
 type _Filter<S extends SliceCls> = SlceDbFilter<S>;
 type _Sort<S extends SliceCls> = SlceDbSort<S>;
-type _LightWithId<S extends SliceCls> = _Light<S> extends { id: string } ? _Light<S> : { id: string };
-type _SliceFetchInitOption<S extends SliceCls> = FetchInitOption<_Input<S>, _Filter<S>, _DefaultInput<S>, _Sort<S>>;
+type SliceInitOption<S extends SliceCls> = FetchInitOption<_Input<S>, _Filter<S>>;
 
 type SliceListFetch<S extends SliceCls> = {
   [Suffix in keyof _SliceMap<S> as Suffix extends string ? `${_RefName<S>}List${Capitalize<Suffix>}` : never]: (
@@ -50,43 +47,33 @@ type SliceInsightFetch<S extends SliceCls> = {
   ) => Promise<_Insight<S>>;
 };
 
+type SliceInit<S extends SliceCls, Suffix extends keyof _SliceMap<S>> = InitReturn<
+  _RefName<S>,
+  Suffix & string,
+  _Light<S>,
+  _Insight<S>,
+  SliceInfoArgs<_SliceMap<S>[Suffix]>,
+  _Filter<S>
+>;
+
+type SliceServerInit<S extends SliceCls, Suffix extends keyof _SliceMap<S>> = ServerInit<
+  _RefName<S>,
+  _Light<S>,
+  _Insight<S>,
+  SliceInfoArgs<_SliceMap<S>[Suffix]>,
+  _Filter<S>
+>;
+
 type SliceInitFetch<S extends SliceCls> = {
   [Suffix in keyof _SliceMap<S> as Suffix extends string ? `init${_Cap<S>}${Capitalize<Suffix>}` : never]: (
-    ...args: [...SliceInfoArgs<_SliceMap<S>[Suffix]>, option?: _SliceFetchInitOption<S>]
-  ) => Promise<
-    InitReturn<
-      _RefName<S>,
-      Suffix & string,
-      _Light<S>,
-      _Insight<S>,
-      SliceInfoArgs<_SliceMap<S>[Suffix]>,
-      _Filter<S>,
-      _Cap<S>,
-      Suffix extends string ? Capitalize<Suffix> : never,
-      _LightWithId<S>,
-      GetStateObject<_LightWithId<S>>,
-      GetStateObject<_Insight<S>>,
-      _Sort<S>
-    >
-  >;
+    ...args: [...SliceInfoArgs<_SliceMap<S>[Suffix]>, option?: SliceInitOption<S>]
+  ) => Promise<SliceInit<S, Suffix>>;
 };
 
 type SliceGetInitFetch<S extends SliceCls> = {
   [Suffix in keyof _SliceMap<S> as Suffix extends string ? `get${_Cap<S>}Init${Capitalize<Suffix>}` : never]: (
-    ...args: [...SliceInfoArgs<_SliceMap<S>[Suffix]>, option?: _SliceFetchInitOption<S>]
-  ) => Promise<
-    ServerInit<
-      _RefName<S>,
-      _Light<S>,
-      _Insight<S>,
-      SliceInfoArgs<_SliceMap<S>[Suffix]>,
-      _Filter<S>,
-      _Cap<S>,
-      GetStateObject<_LightWithId<S>>,
-      GetStateObject<_Insight<S>>,
-      _Sort<S>
-    >
-  >;
+    ...args: [...SliceInfoArgs<_SliceMap<S>[Suffix]>, option?: SliceInitOption<S>]
+  ) => Promise<SliceServerInit<S, Suffix>>;
 };
 
 export type GetFetchTypeFromSlice<SlceCls extends SliceCls> = SlceCls["srv"]["cnst"] extends ConstantModel
@@ -164,23 +151,13 @@ type AppliedBaseSliceFetchType<
   ) => Promise<Full>;
 };
 
-export interface FetchInitForm<
-  Input,
-  Filter extends FilterInstance,
-  _DefaultInput = DefaultOf<Input>,
-  _Sort = ExtractSort<Filter>,
-> {
+export interface FetchInitForm<Input, Filter extends FilterInstance> {
   page?: number;
   limit?: number;
-  sort?: _Sort;
-  default?: Partial<_DefaultInput>;
+  sort?: ExtractSort<Filter>;
+  default?: Partial<DefaultOf<Input>>;
   invalidate?: boolean;
   insight?: boolean;
 }
 
-type FetchInitOption<
-  Input,
-  Filter extends FilterInstance,
-  _DefaultInput = DefaultOf<Input>,
-  _Sort = ExtractSort<Filter>,
-> = FetchPolicy & FetchInitForm<Input, Filter, _DefaultInput, _Sort>;
+type FetchInitOption<Input, Filter extends FilterInstance> = FetchPolicy & FetchInitForm<Input, Filter>;