akanjs 2.3.5-rc.6 → 2.3.5-rc.7

package/README.ko.md

@@ -2,12 +2,12 @@
 
 [English](https://unpkg.com/akanjs@latest/README.md) | [Docs](https://akanjs.com/docs) | [npm](https://www.npmjs.com/package/akanjs)
 
-**코드가 아니라, 비즈니스를 씁니다.**  
-**Write the business, not the plumbing.**
+**한 줄의 비즈니스 코드로 웹·iOS·Android·서버·DB를 한 번에.**  
+**One line of business code ships web, iOS, Android, server, and database together.**
 
-Akan.js는 비즈니스 정의가 곧 애플리케이션이 되도록 설계된 Bun-first 풀스택 TypeScript
-프레임워크입니다. 하나의 코드베이스에서 SEO 웹, iOS/Android 앱 화면, 서버, 데이터베이스 계약,
-인프라 산출물, 문서화까지 이어갑니다.
+프레임워크 조립, 중복 선언, 플랫폼별 재작성은 이제 그만. Akan.js는 비즈니스 의도를 한 곳에 쓰면
+SEO 웹, iOS/Android 앱 패키지, 서버, 데이터베이스 계약, 인프라 산출물, 문서화까지 함께 이어지는
+Bun-first 풀스택 TypeScript 프레임워크입니다.
 
 ```bash
 bunx create-akan-workspace@latest
@@ -15,14 +15,14 @@ bunx create-akan-workspace@latest
 
 ## 왜 Akan인가
 
-Akan은 기술 계층마다 같은 의도를 다시 쓰는 대신, 비즈니스가 무엇을 하는지 또렷하게 선언하도록
-돕습니다. 도메인을 한 번 정의하면 schema, API, fetch client, store, UI, server, deployment
-artifact, generated reference가 같은 의도에서 이어집니다.
+Akan은 기술 계층을 손으로 배선하는 대신 비즈니스를 먼저 출시하도록 돕습니다. 도메인을 한 번
+정의하면 schema, API, fetch client, store, UI, server, app packaging, deployment artifact,
+generated reference가 같은 의도에서 이어집니다.
 
-- **Agents write**: 비즈니스 정의가 코드의 원천입니다. 반복적인 프레임워크 코드는 생성과 규칙이 맡습니다.
-- **Keep it minimal**: 한 줄의 의도가 웹, 앱, 서버, 데이터베이스, 배포까지 이어집니다.
-- **Always readable**: 적은 파일, 엄격한 규칙, 예측 가능한 선언 방식으로 6개월 뒤에도 읽히는 코드를 만듭니다.
-- **Nice to review**: 군더더기 없는 도메인 변경은 확인하기 쉽고, 리뷰가 빠르며, 곧장 배포하기 좋습니다.
+- **웹 개발자**: 같은 비즈니스 코드가 SEO 웹과 네이티브 느낌의 iOS/Android 화면까지 이어집니다.
+- **앱 개발자**: Bun 서버, SQLite, API 계약, 검증이 손배선 없이 따라옵니다.
+- **1인 창업가 / 소규모 팀**: 풀스택 1명이 5개 표면을 책임집니다. 사람 한 명, 코드 1/4.
+- **AI 에이전트도 일관되게**: 엄격한 규칙이 파일 위치, 이름, 구조, 선언 방식을 읽기 좋게 유지합니다.
 
 ## 요구사항
 
@@ -104,12 +104,39 @@ flowchart LR
 하나의 모델과 하나의 계약이 DB, 서버, API, 상태관리, UI까지 이어지기 때문에 계층마다 의도를
 반복해서 작성할 필요가 줄어듭니다.
 
+## 8 in 1
+
+필드 하나. 8개 레이어가 따라옵니다.
+
+기존 풀스택 앱에서 비즈니스 필드 하나를 추가하려면 보통 이만큼을 직접 손으로 해야 합니다.
+
+1. DB 스키마 정의.
+2. 쿼리 필드 추가.
+3. 서비스 로직 추가.
+4. API 필드 추가.
+5. fetch 필드 추가.
+6. 클라이언트 타입 선언.
+7. 상태관리 선언.
+8. UI prop 선언.
+
+한 곳만 바뀌어도 8곳을 따라 고쳐야 하고, 한 곳을 빠뜨리면 타입이 깨지거나 런타임에서 터집니다.
+Akan에서는 비즈니스 필드가 코드의 원천입니다.
+
+```ts
+export class ProductInput extends via((field) => ({
+  name: field(String),
+})) {}
+```
+
+이 선언 하나로 스키마와 타입이 동시에 정의됩니다. 주변 레이어는 같은 의도에서 생성되므로 스택이
+흩어져 스파게티가 되는 일을 줄입니다.
+
 ## Akan이 만드는 것
 
 Akan은 보통 여러 프로젝트로 흩어지는 것들을 하나의 프레임워크로 묶습니다.
 
 - SEO에 최적화된 server-side rendered web surface.
-- 아름다운 페이지 전환을 가진 iOS/Android 친화 client-side rendered app surface.
+- 컴파일된 웹 surface를 앱으로 패키징한 iOS/Android surface와 네이티브 수준의 built-in 화면 전환.
 - Bun 기반 HTTP/WebSocket server.
 - SQLite-first 단순 서버 경로와 더 큰 시스템을 위한 Postgres/Redis 확장 경로.
 - Schema validation, error handling, security helper, middleware.
@@ -121,6 +148,10 @@ Akan은 보통 여러 프로젝트로 흩어지는 것들을 하나의 프레임
 배포와 문서 작성에 하루를 쓰고 있다면 뭔가 잘못된 것입니다. Akan은 schema와 endpoint 정의가
 table reference, runtime contract, API docs, testable endpoint reference가 되도록 설계됩니다.
 
+일반적인 앱 패키징은 감싼 웹사이트처럼 느껴지기 쉽습니다. Akan의 client runtime은 목록-상세 흐름,
+오버레이, 맥락 전환을 위한 transition preset을 제공하므로 별도 UI 재작성 없이도 앱 패키징된 웹에서
+네이티브 수준의 사용자 경험을 만들 수 있습니다.
+
 ## 하나의 패키지, 여러 경계
 
 Akan은 하나의 npm package인 `akanjs`로 배포됩니다.

package/README.md

@@ -2,11 +2,11 @@
 
 [한국어](https://unpkg.com/akanjs@latest/README.ko.md) | [Docs](https://akanjs.com/docs) | [npm](https://www.npmjs.com/package/akanjs)
 
-**Write the business, not the plumbing.**
+**One line of business code ships web, iOS, Android, server, and database together.**
 
-Akan.js is a Bun-first full-stack TypeScript framework for teams that want business definitions to be the
-application. One cohesive codebase can produce SEO web surfaces, iOS and Android app surfaces, servers,
-database contracts, infrastructure artifacts, and documentation.
+No more framework assembly, duplicated declarations, or per-platform rewrites. Akan.js is a Bun-first
+full-stack TypeScript framework where business intent is written once, then compiled into SEO web surfaces,
+iOS and Android app packages, servers, database contracts, infrastructure artifacts, and documentation.
 
 ```bash
 bunx create-akan-workspace@latest
@@ -14,14 +14,14 @@ bunx create-akan-workspace@latest
 
 ## Why Akan
 
-Akan is designed for teams and solo builders who would rather describe what the business does than keep
-rewriting the same intent for each technical layer. Define the domain once, then let the framework connect
-the schema, API, fetch client, store, UI, server, deployment artifacts, and generated references.
+Akan is designed for teams and solo builders who would rather ship the business than keep wiring technical
+layers by hand. Define the domain once, then let the framework connect schema, API, fetch client, store, UI,
+server, app packaging, deployment artifacts, and generated references.
 
-- **Agents write**: business definitions are the source of truth; generation handles repetitive framework code.
-- **Keep it minimal**: one line of intent can flow across web, app, server, database, and deployment.
-- **Always readable**: fewer files, strict conventions, and predictable declarations keep code clear months later.
-- **Nice to review**: focused domain changes are easier to inspect, approve, and ship.
+- **Web devs**: the same business code becomes SEO-ready web and native-feeling iOS/Android screens.
+- **App devs**: Bun server, SQLite, API contracts, and validation follow without hand-wiring.
+- **Solo and small teams**: one full-stack developer can own all five surfaces with a quarter of the code.
+- **Agents stay consistent**: strict conventions keep file paths, names, structures, and declarations readable.
 
 ## Requirements
 
@@ -102,12 +102,39 @@ flowchart LR
 This structure lets one model and one contract flow through the database, server, API, state management,
 and UI without duplicating intent across layers.
 
+## 8 in 1
+
+One field. Eight layers follow.
+
+Adding a single business field in a traditional full-stack app usually means changing all of this by hand:
+
+1. Define the DB schema.
+2. Add the query field.
+3. Add the service logic.
+4. Add the API field.
+5. Add the fetch field.
+6. Declare the client type.
+7. Declare the state management.
+8. Declare the UI prop.
+
+Change one place, chase eight. Miss one, and types break, or it fails at runtime. In Akan, the business field is
+the source of truth:
+
+```ts
+export class ProductInput extends via((field) => ({
+  name: field(String),
+})) {}
+```
+
+That one declaration defines schema and type together. The surrounding layers are generated from the same
+intent, so the stack stays connected instead of turning into spaghetti.
+
 ## What Akan Builds
 
 Akan is one framework for the pieces that normally become separate projects:
 
 - SEO-optimized server-side rendered web surfaces.
-- iOS and Android friendly client-side rendered app surfaces with page transitions.
+- iOS and Android app packages from compiled web surfaces, with native-level built-in screen transitions.
 - Bun-powered HTTP and WebSocket servers.
 - SQLite-first simple server paths, with Postgres and Redis expansion paths for larger systems.
 - Schema validation, error handling, security helpers, and middleware.
@@ -119,6 +146,10 @@ Akan is one framework for the pieces that normally become separate projects:
 Deployment and documentation should not consume a day of work. Akan is built so schema and endpoint
 definitions can also become table references, runtime contracts, API docs, and testable endpoint references.
 
+Unlike ordinary app packaging that can feel like a wrapped website, Akan's client runtime includes transition
+presets for list-detail flows, overlays, and context changes. Packaged web surfaces can deliver a native-level
+user experience without a separate UI rewrite.
+
 ## One Package, Many Boundaries
 
 Akan is published as a single npm package: `akanjs`.

package/constant/constantRegistry.ts

@@ -273,15 +273,26 @@ export class ConstantRegistry {
   }
 }
 
-export interface ConstantCore<
+export interface ConstantModel<
   T extends string = string,
-  Input = unknown,
-  Obj = unknown,
-  Full = unknown,
-  Light = unknown,
-  Insight = unknown,
+  Input = any,
+  Obj = any,
+  Full = any,
+  Light = any,
+  Insight = any,
   FullFieldObj extends FieldObject = FieldObject,
   _CapitalizedRefName extends string = Capitalize<T>,
+  _Default = DefaultOf<Full>,
+  _DefaultInput = DefaultOf<Input>,
+  _DefaultState = GetStateObject<Full>,
+  _DefaultStateInput = GetStateObject<Input>,
+  _DefaultInsight = DefaultOf<Insight>,
+  _PurifiedInput = PurifiedModel<Input>,
+  _Doc = DocumentModel<Full>,
+  _DocInput = DocumentModel<Input>,
+  _QueryOfDoc = QueryOf<_Doc>,
+  _StateLight = GetStateObject<Light>,
+  _StateInsight = GetStateObject<Insight>,
 > {
   refName: T;
   input: ConstantCls<Input>;
@@ -295,25 +306,6 @@ export interface ConstantCore<
   _Full: Full;
   _Light: Light;
   _Insight: Insight;
-}
-
-export interface ConstantDerived<
-  Input = unknown,
-  Full = unknown,
-  Light = unknown,
-  Insight = unknown,
-  _Default = DefaultOf<Full>,
-  _DefaultInput = DefaultOf<Input>,
-  _DefaultState = GetStateObject<Full>,
-  _DefaultStateInput = GetStateObject<Input>,
-  _DefaultInsight = DefaultOf<Insight>,
-  _PurifiedInput = PurifiedModel<Input>,
-  _Doc = DocumentModel<Full>,
-  _DocInput = DocumentModel<Input>,
-  _QueryOfDoc = QueryOf<_Doc>,
-  _StateLight = GetStateObject<Light>,
-  _StateInsight = GetStateObject<Insight>,
-> {
   _Default: _Default;
   _DefaultInput: _DefaultInput;
   _DefaultState: _DefaultState;
@@ -327,109 +319,6 @@ export interface ConstantDerived<
   _StateInsight: _StateInsight;
 }
 
-export interface ConstantModel<
-  T extends string = string,
-  Input = any,
-  Obj = any,
-  Full = any,
-  Light = any,
-  Insight = any,
-  FullFieldObj extends FieldObject = FieldObject,
-  _CapitalizedRefName extends string = Capitalize<T>,
-  _Default = DefaultOf<Full>,
-  _DefaultInput = DefaultOf<Input>,
-  _DefaultState = GetStateObject<Full>,
-  _DefaultStateInput = GetStateObject<Input>,
-  _DefaultInsight = DefaultOf<Insight>,
-  _PurifiedInput = PurifiedModel<Input>,
-  _Doc = DocumentModel<Full>,
-  _DocInput = DocumentModel<Input>,
-  _QueryOfDoc = QueryOf<_Doc>,
-  _StateLight = GetStateObject<Light>,
-  _StateInsight = GetStateObject<Insight>,
-> extends ConstantCore<T, Input, Obj, Full, Light, Insight, FullFieldObj, _CapitalizedRefName>,
-    ConstantDerived<
-      Input,
-      Full,
-      Light,
-      Insight,
-      _Default,
-      _DefaultInput,
-      _DefaultState,
-      _DefaultStateInput,
-      _DefaultInsight,
-      _PurifiedInput,
-      _Doc,
-      _DocInput,
-      _QueryOfDoc,
-      _StateLight,
-      _StateInsight
-    > {}
-
-export type ConstantReturnView<Full = unknown, Light = unknown, Insight = unknown> = {
-  full: Full;
-  light: Light;
-  insight: Insight;
-};
-
-export type ConstantReturnViewOf<Cnst> = Cnst extends {
-  _Full: infer Full;
-  _Light: infer Light;
-  _Insight: infer Insight;
-}
-  ? ConstantReturnView<Full, Light, Insight>
-  : never;
-
-export type ConstantFetchView<
-  RefName extends string = string,
-  CapRefName extends string = Capitalize<RefName>,
-  Input = unknown,
-  Full = unknown,
-  Light = unknown,
-  Insight = unknown,
-  PurifiedInput = unknown,
-  DefaultInput = unknown,
-  StateLight = unknown,
-  StateInsight = unknown,
-> = {
-  refName: RefName;
-  capRefName: CapRefName;
-  input: Input;
-  full: Full;
-  light: Light;
-  insight: Insight;
-  purifiedInput: PurifiedInput;
-  defaultInput: DefaultInput;
-  stateLight: StateLight;
-  stateInsight: StateInsight;
-};
-
-export type ConstantFetchViewOf<Cnst> = Cnst extends {
-  refName: infer RefName extends string;
-  _CapitalizedRefName: infer CapRefName extends string;
-  _Input: infer Input;
-  _Full: infer Full;
-  _Light: infer Light;
-  _Insight: infer Insight;
-  _PurifiedInput: infer PurifiedInput;
-  _DefaultInput: infer DefaultInput;
-  _StateLight: infer StateLight;
-  _StateInsight: infer StateInsight;
-}
-  ? ConstantFetchView<
-      RefName,
-      CapRefName,
-      Input,
-      Full,
-      Light,
-      Insight,
-      PurifiedInput,
-      DefaultInput,
-      StateLight,
-      StateInsight
-    >
-  : never;
-
 export interface ScalarConstantModel<
   T extends string = string,
   Model = any,

package/fetch/fetchType/buildFetch.type.ts

@@ -1,5 +1,4 @@
-import type { Assign } from "akanjs/base";
-import type { DatabaseSignal, SerializedSignal, ServiceSignal } from "akanjs/signal";
+import type { DatabaseSignal, EndpointCls, SerializedSignal, ServiceSignal, SliceCls } from "akanjs/signal";
 import type { FetchProxy } from "../client";
 import type { GetSliceMetaObjFromDatabaseSignals } from "../types";
 import type { SliceMeta } from "./appliedReturn.type";
@@ -18,31 +17,36 @@ export type FetchProxySignalInput<
 
 export type FetchSignalInput = FetchProxySignalInput | DatabaseSignal | ServiceSignal;
 
-export type IsAny<Type> = 0 extends 1 & Type ? true : false;
-export type SafeFetchPart<Type, Fallback = unknown> = IsAny<Type> extends true ? Fallback : Type;
-
-type MergeFetchParts<First, Second> = [First] extends [never]
-  ? Second
-  : [Second] extends [never]
-    ? First
-    : Assign<First, Second>;
-
 export type FetchTypeOfSignal<Signal extends FetchSignalInput> = Signal extends { _FetchType: infer FetchType }
   ? FetchType
-  : Signal extends DatabaseSignal<infer _IntlCls, infer EndpCls, infer SlceCls, infer _SrvrCls>
-    ? MergeFetchParts<GetFetchTypeFromEndpoint<EndpCls, SlceCls>, GetFetchTypeFromSlice<SlceCls>>
-    : Signal extends ServiceSignal<infer _IntlCls, infer EndpCls, infer _SrvrCls>
+  : Signal extends { endpoint: infer EndpCls extends EndpointCls; slice: infer SlceCls extends SliceCls }
+    ? GetFetchTypeFromEndpoint<EndpCls, SlceCls> & GetFetchTypeFromSlice<SlceCls>
+    : Signal extends { endpoint: infer EndpCls extends EndpointCls }
       ? GetFetchTypeFromEndpoint<EndpCls>
       : unknown;
 
-type MergeProxyFetchTypes<
+type FetchKeysOfProxySignal<Signal> = Signal extends { _FetchType: infer FetchType } ? keyof FetchType : never;
+type FetchKeysOfProxySignals<Signals extends readonly FetchSignalInput[]> = FetchKeysOfProxySignal<Signals[number]>;
+
+type LastProxyFetchValue<
   Signals extends readonly FetchSignalInput[],
-  Acc = Record<never, never>,
+  Key extends PropertyKey,
+  Current = never,
 > = Signals extends readonly [infer First extends FetchSignalInput, ...infer Rest extends readonly FetchSignalInput[]]
   ? First extends { _FetchType: infer FetchType }
-    ? MergeProxyFetchTypes<Rest, Assign<Acc, FetchType>>
-    : MergeProxyFetchTypes<Rest, Acc>
-  : Acc;
+    ? Key extends keyof FetchType
+      ? LastProxyFetchValue<Rest, Key, FetchType[Key]>
+      : LastProxyFetchValue<Rest, Key, Current>
+    : LastProxyFetchValue<Rest, Key, Current>
+  : Current;
+
+type MergeProxyFetchTypes<Signals extends readonly FetchSignalInput[]> = [FetchKeysOfProxySignals<Signals>] extends [
+  never,
+]
+  ? Record<never, never>
+  : {
+      [Key in FetchKeysOfProxySignals<Signals>]: LastProxyFetchValue<Signals, Key>;
+    };
 
 type MergeDirectFetchTypes<
   Signals extends readonly FetchSignalInput[],
@@ -50,13 +54,13 @@ type MergeDirectFetchTypes<
 > = Signals extends readonly [infer First extends FetchSignalInput, ...infer Rest extends readonly FetchSignalInput[]]
   ? First extends { _FetchType: unknown }
     ? MergeDirectFetchTypes<Rest, Acc>
-    : MergeDirectFetchTypes<Rest, MergeFetchParts<Acc, FetchTypeOfSignal<First>>>
+    : MergeDirectFetchTypes<Rest, Acc & FetchTypeOfSignal<First>>
   : Acc;
 
 export type MergeAllFetchTypes<Signals extends readonly FetchSignalInput[]> =
   MergeProxyFetchTypes<Signals> extends infer ProxyFetch
     ? MergeDirectFetchTypes<Signals> extends infer DirectFetch
-      ? Assign<ProxyFetch, DirectFetch>
+      ? Omit<ProxyFetch, keyof DirectFetch> & DirectFetch
       : never
     : never;
 

package/fetch/fetchType/endpointFetch.type.ts

@@ -1,6 +1,5 @@
 import type { ENDPOINT_META, PromiseOrObject } from "akanjs/base";
 import type { FetchPolicy } from "akanjs/common";
-import type { ConstantReturnViewOf } from "akanjs/constant";
 import type {
   EndpInfoArgs,
   EndpInfoClientReturns,
@@ -11,112 +10,81 @@ import type {
   SliceCls,
 } from "akanjs/signal";
 
-export type EndpointReturnContext<Full = unknown, Light = unknown, Insight = unknown> = {
-  full: Full;
-  light: Light;
-  insight: Insight;
-};
-
-type EndpointReturnContextOf<SlceCls extends SliceCls | never> = [SlceCls] extends [never]
-  ? never
-  : SlceCls extends SliceCls
-    ? ConstantReturnViewOf<SlceCls["srv"]["cnst"]>
-    : never;
-
-type ExtendedEndpointReturn<ClientReturns, Context> = ClientReturns extends (infer R)[]
-  ? ExtendedEndpointReturn<R, Context>[]
-  : Context extends EndpointReturnContext<infer Full, infer Light, infer Insight>
-    ? Full extends ClientReturns
-      ? Full
-      : Light extends ClientReturns
-        ? Light
-        : Insight extends ClientReturns
-          ? Insight
-          : ClientReturns
-    : ClientReturns;
-
-type EndpointClientReturns<E, Context> = [Context] extends [never]
+type ExtendedEndpointReturn<ClientReturns, Full, Light, Insight> = ClientReturns extends (infer R)[]
+  ? ExtendedEndpointReturn<R, Full, Light, Insight>[]
+  : Full extends ClientReturns
+    ? Full
+    : Light extends ClientReturns
+      ? Light
+      : Insight extends ClientReturns
+        ? Insight
+        : ClientReturns;
+
+type EndpointClientReturns<E, SlceCls extends SliceCls | never> = [SlceCls] extends [never]
   ? EndpInfoClientReturns<E>
-  : ExtendedEndpointReturn<EndpInfoClientReturns<E>, Context>;
-
-type EndpInfoReturns<E, Context> =
-  | EndpointClientReturns<E, Context>
+  : ExtendedEndpointReturn<
+      EndpInfoClientReturns<E>,
+      SlceCls["srv"]["cnst"]["_Full"],
+      SlceCls["srv"]["cnst"]["_Light"],
+      SlceCls["srv"]["cnst"]["_Insight"]
+    >;
+
+type EndpInfoReturns<E, SlceCls extends SliceCls | never> =
+  | EndpointClientReturns<E, SlceCls>
   | (EndpInfoNullable<E> extends true ? null : never);
 
-type QueryOrMutationFetchFn<E, Context> = (
+type QueryOrMutationFetchFn<E, SlceCls extends SliceCls | never> = (
   ...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]
-) => Promise<EndpInfoReturns<E, Context>>;
+) => Promise<EndpInfoReturns<E, SlceCls>>;
 
-type MessageEmitFn<E, Context> = (...args: EndpInfoArgs<E>) => EndpInfoReturns<E, Context>;
+type MessageEmitFn<E, SlceCls extends SliceCls | never> = (...args: EndpInfoArgs<E>) => EndpInfoReturns<E, SlceCls>;
 
-type MessageListenFn<E, Context> = (
-  handleEvent: (data: EndpInfoReturns<E, Context>) => PromiseOrObject<void>,
+type MessageListenFn<E, SlceCls extends SliceCls | never> = (
+  handleEvent: (data: EndpInfoReturns<E, SlceCls>) => PromiseOrObject<void>,
   options?: FetchPolicy,
 ) => () => void;
 
-type PubsubSubscribeFn<E, Context> = (
+type PubsubSubscribeFn<E, SlceCls extends SliceCls | never> = (
   ...args: [
     ...EndpInfoArgs<E>,
-    handleEvent: (data: EndpInfoReturns<E, Context>) => PromiseOrObject<void>,
+    handleEvent: (data: EndpInfoReturns<E, SlceCls>) => PromiseOrObject<void>,
     options?: FetchPolicy,
   ]
 ) => () => void;
 
-type PrimaryFetchFn<E, Context, ReqType = EndpInfoReqType<E>> = ReqType extends "query" | "mutation"
-  ? QueryOrMutationFetchFn<E, Context>
-  : ReqType extends "message"
-    ? MessageEmitFn<E, Context>
-    : never;
-
-type UploadLikeArg = FileList | File | File[];
-type HasUploadLikeArg<Args extends readonly unknown[]> =
-  Extract<Args[number], UploadLikeArg> extends never ? false : true;
-type RestApiArg<Arg> = Arg extends FileList ? FileList : Arg extends File | File[] ? FileList : Arg;
-type RestApiArgs<Args extends readonly unknown[]> = {
-  [K in keyof Args]: RestApiArg<Args[K]>;
-};
-type UploadRestApiFetchFn<E, Context> = (
-  ...args: [...RestApiArgs<EndpInfoArgs<E>>, fetchPolicy?: FetchPolicy]
-) => Promise<EndpInfoReturns<E, Context>>;
-
-type PrimaryFetchType<EInfoObj extends { [key: string]: EndpointInfo }, Context> = {
-  [K in keyof EInfoObj as Extract<EndpInfoReqType<EInfoObj[K]>, "query" | "mutation" | "message"> extends never
-    ? never
-    : K]: PrimaryFetchFn<EInfoObj[K], Context>;
-};
-
-type UploadRestApiFetchType<EInfoObj extends { [key: string]: EndpointInfo }, Context> = {
-  [K in keyof EInfoObj as Extract<EndpInfoReqType<EInfoObj[K]>, "mutation"> extends never
-    ? never
-    : HasUploadLikeArg<EndpInfoArgs<EInfoObj[K]>> extends true
-      ? K extends string
-        ? `${K}RestApi`
-        : never
-      : never]: UploadRestApiFetchFn<EInfoObj[K], Context>;
+type PrimaryFetchFn<E, SlceCls extends SliceCls | never> =
+  EndpInfoReqType<E> extends "query" | "mutation"
+    ? QueryOrMutationFetchFn<E, SlceCls>
+    : EndpInfoReqType<E> extends "message"
+      ? MessageEmitFn<E, SlceCls>
+      : never;
+
+type PrimaryFetchType<EInfoObj extends { [key: string]: EndpointInfo }, SlceCls extends SliceCls | never> = {
+  [K in keyof EInfoObj as EndpInfoReqType<EInfoObj[K]> extends "query" | "mutation" | "message"
+    ? K
+    : never]: PrimaryFetchFn<EInfoObj[K], SlceCls>;
 };
 
-type PubsubFetchType<EInfoObj extends { [key: string]: EndpointInfo }, Context> = {
-  [K in keyof EInfoObj as Extract<EndpInfoReqType<EInfoObj[K]>, "pubsub"> extends never
-    ? never
-    : K extends string
+type PubsubFetchType<EInfoObj extends { [key: string]: EndpointInfo }, SlceCls extends SliceCls | never> = {
+  [K in keyof EInfoObj as EndpInfoReqType<EInfoObj[K]> extends "pubsub"
+    ? K extends string
       ? `subscribe${Capitalize<K>}`
-      : never]: PubsubSubscribeFn<EInfoObj[K], Context>;
+      : never
+    : never]: PubsubSubscribeFn<EInfoObj[K], SlceCls>;
 };
 
-type MessageListenFetchType<EInfoObj extends { [key: string]: EndpointInfo }, Context> = {
-  [K in keyof EInfoObj as Extract<EndpInfoReqType<EInfoObj[K]>, "message"> extends never
-    ? never
-    : K extends string
+type MessageListenFetchType<EInfoObj extends { [key: string]: EndpointInfo }, SlceCls extends SliceCls | never> = {
+  [K in keyof EInfoObj as EndpInfoReqType<EInfoObj[K]> extends "message"
+    ? K extends string
       ? `listen${Capitalize<K>}`
-      : never]: MessageListenFn<EInfoObj[K], Context>;
+      : never
+    : never]: MessageListenFn<EInfoObj[K], SlceCls>;
 };
 
 export type GetFetchTypeFromEndpoint<
   EndpCls extends EndpointCls,
   SlceCls extends SliceCls | never = never,
   _EndpointInfoObj extends { [key: string]: EndpointInfo } = EndpCls[typeof ENDPOINT_META],
-  _ReturnContext = EndpointReturnContextOf<SlceCls>,
-> = PrimaryFetchType<_EndpointInfoObj, _ReturnContext> &
-  UploadRestApiFetchType<_EndpointInfoObj, _ReturnContext> &
-  PubsubFetchType<_EndpointInfoObj, _ReturnContext> &
-  MessageListenFetchType<_EndpointInfoObj, _ReturnContext>;
+> = PrimaryFetchType<_EndpointInfoObj, SlceCls> &
+  PubsubFetchType<_EndpointInfoObj, SlceCls> &
+  MessageListenFetchType<_EndpointInfoObj, SlceCls>;