akanjs 2.3.5-rc.8 → 2.3.5

package/signal/endpointInfo.ts

@@ -18,7 +18,7 @@ import type {
 } from "akanjs/constant";
 import type { ServiceModel } from "akanjs/service";
 import type { InternalArgCls } from "./internalArg";
-import type { ArgType, SignalOption } from "./types";
+import type { ArgType, SignalOption, SrvMap } from "./types";
 
 export type EndpointType = "query" | "mutation" | "pubsub" | "message";
 
@@ -328,19 +328,19 @@ export type BuildEndpoint<SrvModule extends ServiceModel = ServiceModel> = {
   query: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(
     returnRef: Returns,
     signalOption?: SignalOption<Returns, Nullable>,
-  ) => EndpointInfo<"query", SrvModule["srvMap"], [], [], [], [], Returns, never, never, Nullable>;
+  ) => EndpointInfo<"query", SrvMap<SrvModule>, [], [], [], [], Returns, never, never, Nullable>;
   mutation: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(
     returnRef: Returns,
     signalOption?: SignalOption<Returns, Nullable>,
-  ) => EndpointInfo<"mutation", SrvModule["srvMap"], [], [], [], [], Returns, never, never, Nullable>;
+  ) => EndpointInfo<"mutation", SrvMap<SrvModule>, [], [], [], [], Returns, never, never, Nullable>;
   pubsub: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(
     returnRef: Returns,
     signalOption?: SignalOption<Returns, Nullable>,
-  ) => EndpointInfo<"pubsub", SrvModule["srvMap"], [], [], [], [], Returns, never, never, Nullable>;
+  ) => EndpointInfo<"pubsub", SrvMap<SrvModule>, [], [], [], [], Returns, never, never, Nullable>;
   message: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(
     returnRef: Returns,
     signalOption?: SignalOption<Returns, Nullable>,
-  ) => EndpointInfo<"message", SrvModule["srvMap"], [], [], [], [], Returns, never, never, Nullable>;
+  ) => EndpointInfo<"message", SrvMap<SrvModule>, [], [], [], [], Returns, never, never, Nullable>;
 };
 
 export const buildEndpoint = {
@@ -354,21 +354,51 @@ export type EndpointBuilder<SrvModule extends ServiceModel = ServiceModel> = (bu
   [key: string]: EndpointInfo;
 };
 
-export type EndpInfoReqType<E> =
-  E extends EndpointInfo<infer T, any, any, any, any, any, any, any, any, any> ? T : never;
-export type EndpInfoSrvs<E> = E extends EndpointInfo<any, infer S, any, any, any, any, any, any, any, any> ? S : never;
-export type EndpInfoArgNames<E> =
-  E extends EndpointInfo<any, any, infer N, any, any, any, any, any, any, any> ? N : never;
-export type EndpInfoArgs<E> = E extends EndpointInfo<any, any, any, infer A, any, any, any, any, any, any> ? A : never;
-export type EndpInfoInternalArgs<E> =
-  E extends EndpointInfo<any, any, any, any, infer I, any, any, any, any, any> ? I : never;
-export type EndpInfoServerArgs<E> =
-  E extends EndpointInfo<any, any, any, any, any, infer S, any, any, any, any> ? S : never;
-export type EndpInfoReturnRef<E> =
-  E extends EndpointInfo<any, any, any, any, any, any, infer R, any, any, any> ? R : never;
-export type EndpInfoClientReturns<E> =
-  E extends EndpointInfo<any, any, any, any, any, any, any, infer R, any, any> ? R : never;
-export type EndpInfoServerReturns<E> =
-  E extends EndpointInfo<any, any, any, any, any, any, any, any, infer R, any> ? R : never;
-export type EndpInfoNullable<E> =
-  E extends EndpointInfo<any, any, any, any, any, any, any, any, any, infer N> ? N : never;
+type EndpointInfoEmptyParts = {
+  reqType: never;
+  srvs: never;
+  argNames: never;
+  args: never;
+  internalArgs: never;
+  serverArgs: never;
+  returnRef: never;
+  clientReturns: never;
+  serverReturns: never;
+  nullable: never;
+};
+export type EndpointInfoParts<E> =
+  E extends EndpointInfo<
+    infer ReqType,
+    infer Srvs,
+    infer ArgNames,
+    infer Args,
+    infer InternalArgs,
+    infer ServerArgs,
+    infer Returns,
+    infer ClientReturns,
+    infer ServerReturns,
+    infer Nullable
+  >
+    ? {
+        reqType: ReqType;
+        srvs: Srvs;
+        argNames: ArgNames;
+        args: Args;
+        internalArgs: InternalArgs;
+        serverArgs: ServerArgs;
+        returnRef: Returns;
+        clientReturns: ClientReturns;
+        serverReturns: ServerReturns;
+        nullable: Nullable;
+      }
+    : EndpointInfoEmptyParts;
+export type EndpInfoReqType<E> = EndpointInfoParts<E>["reqType"];
+export type EndpInfoSrvs<E> = EndpointInfoParts<E>["srvs"];
+export type EndpInfoArgNames<E> = EndpointInfoParts<E>["argNames"];
+export type EndpInfoArgs<E> = EndpointInfoParts<E>["args"];
+export type EndpInfoInternalArgs<E> = EndpointInfoParts<E>["internalArgs"];
+export type EndpInfoServerArgs<E> = EndpointInfoParts<E>["serverArgs"];
+export type EndpInfoReturnRef<E> = EndpointInfoParts<E>["returnRef"];
+export type EndpInfoClientReturns<E> = EndpointInfoParts<E>["clientReturns"];
+export type EndpInfoServerReturns<E> = EndpointInfoParts<E>["serverReturns"];
+export type EndpInfoNullable<E> = EndpointInfoParts<E>["nullable"];

package/signal/internal.ts

@@ -11,6 +11,7 @@ import {
   type ServiceModel,
 } from "akanjs/service";
 import { type BuildInternal, buildInternal, type InternalBuilder, type InternalInfo } from "./internalInfo";
+import type { SrvRefName } from "./types";
 
 export interface Internal extends Adaptor {
   schedule: ScheduleAdaptor;
@@ -20,7 +21,7 @@ export interface Internal extends Adaptor {
 export type InternalCls<
   SrvModule extends ServiceModel = ServiceModel,
   InternalInfoMap extends { [key: string]: InternalInfo } = { [key: string]: InternalInfo },
-> = AdaptorCls & { refName: SrvModule["srv"]["refName"]; srv: SrvModule; [INTERNAL_META]: InternalInfoMap };
+> = AdaptorCls & { refName: SrvRefName<SrvModule>; srv: SrvModule; [INTERNAL_META]: InternalInfoMap };
 
 /** Builds an internal adaptor for schedules, queues, processes, and server-only jobs. */
 export function internal<

package/signal/internalInfo.ts

@@ -11,7 +11,7 @@ import type {
 import type { AkanJob, ServiceModel } from "akanjs/service";
 import { type ArgInfo, EndpointInfo, type InternalArgInfo, type ReturnInfo } from "./endpointInfo";
 import type { InternalArgCls } from "./internalArg";
-import type { SignalOption } from "./types";
+import type { CnstOf, DbDoc, SignalOption, SrvMap } from "./types";
 
 type InternalType = "resolveField" | "interval" | "cron" | "timeout" | "init" | "destroy" | "process";
 
@@ -108,57 +108,105 @@ export class InternalInfo<
   }
 }
 
-export type BuildInternal<SrvModule extends ServiceModel, ParentDoc = SrvModule["db"]["_Doc"]> = {
+type InternalInfoEmptyParts = {
+  reqType: never;
+  srvs: never;
+  args: never;
+  internalArgs: never;
+  defaultArgs: never;
+  returns: never;
+  serverReturns: never;
+  nullable: never;
+};
+export type InternalInfoParts<I> =
+  I extends InternalInfo<
+    infer ReqType,
+    infer Srvs,
+    infer Args,
+    infer InternalArgs,
+    infer DefaultArgs,
+    infer Returns,
+    infer ServerReturns,
+    infer Nullable
+  >
+    ? {
+        reqType: ReqType;
+        srvs: Srvs;
+        args: Args;
+        internalArgs: InternalArgs;
+        defaultArgs: DefaultArgs;
+        returns: Returns;
+        serverReturns: ServerReturns;
+        nullable: Nullable;
+      }
+    : InternalInfoEmptyParts;
+export type InternalInfoReqType<I> = InternalInfoParts<I>["reqType"];
+export type InternalInfoSrvs<I> = InternalInfoParts<I>["srvs"];
+export type InternalInfoServerArgs<I> = InternalInfoParts<I>["args"];
+export type InternalInfoInternalArgs<I> = InternalInfoParts<I>["internalArgs"];
+export type InternalInfoDefaultArgs<I> = InternalInfoParts<I>["defaultArgs"];
+export type InternalInfoReturns<I> = InternalInfoParts<I>["returns"];
+export type InternalInfoServerReturns<I> = InternalInfoParts<I>["serverReturns"];
+export type InternalInfoNullable<I> = InternalInfoParts<I>["nullable"];
+
+export type BuildInternal<SrvModule extends ServiceModel, ParentDoc = DbDoc<SrvModule>> = {
   resolveField: <Returns extends ConstantFieldTypeInput, Nullable extends boolean = false>(
     returnRef: Returns,
     signalOption?: Pick<SignalOption<Returns, Nullable>, "nullable">,
-  ) => InternalInfo<"resolveField", SrvModule["srvMap"], [], [], [ParentDoc], Returns, never, Nullable>;
+  ) => InternalInfo<"resolveField", SrvMap<SrvModule>, [], [], [ParentDoc], Returns, never, Nullable>;
   interval: <Nullable extends boolean = false>(
     scheduleTime: number,
     signalOption?: SignalOption<typeof Any, Nullable>,
-  ) => InternalInfo<"interval", SrvModule["srvMap"], [], [], [], typeof Any, never, Nullable>;
+  ) => InternalInfo<"interval", SrvMap<SrvModule>, [], [], [], typeof Any, never, Nullable>;
   cron: <Nullable extends boolean = false>(
     scheduleCron: string,
     signalOption?: SignalOption<typeof Any, Nullable>,
-  ) => InternalInfo<"cron", SrvModule["srvMap"], [], [], [], typeof Any, never, Nullable>;
+  ) => InternalInfo<"cron", SrvMap<SrvModule>, [], [], [], typeof Any, never, Nullable>;
   timeout: <Nullable extends boolean = false>(
     timeout: number,
     signalOption?: SignalOption<typeof Any, Nullable>,
-  ) => InternalInfo<"timeout", SrvModule["srvMap"], [], [], [], typeof Any, never, Nullable>;
+  ) => InternalInfo<"timeout", SrvMap<SrvModule>, [], [], [], typeof Any, never, Nullable>;
   initialize: <Nullable extends boolean = false>(
     signalOption?: SignalOption<typeof Any, Nullable>,
-  ) => InternalInfo<"init", SrvModule["srvMap"], [], [], [], typeof Any, never, Nullable>;
+  ) => InternalInfo<"init", SrvMap<SrvModule>, [], [], [], typeof Any, never, Nullable>;
   destroy: <Nullable extends boolean = false>(
     signalOption?: SignalOption<typeof Any, Nullable>,
-  ) => InternalInfo<"destroy", SrvModule["srvMap"], [], [], [], typeof Any, never, Nullable>;
+  ) => InternalInfo<"destroy", SrvMap<SrvModule>, [], [], [], typeof Any, never, Nullable>;
   process: <Returns extends ConstantFieldTypeInput, Nullable extends boolean = false>(
     returnRef: Returns,
     signalOption?: SignalOption<Returns, Nullable>,
-  ) => InternalInfo<"process", SrvModule["srvMap"], [], [], [AkanJob], Returns, never, Nullable>;
+  ) => InternalInfo<"process", SrvMap<SrvModule>, [], [], [AkanJob], Returns, never, Nullable>;
 };
 
 export type InternalBuilder<
   SrvModule extends ServiceModel,
-  _FullCls extends ConstantCls = SrvModule["cnst"]["full"],
+  _Cnst = CnstOf<SrvModule>,
+  _FullCls extends ConstantCls = [_Cnst] extends [never]
+    ? never
+    : _Cnst extends { full: infer Full extends ConstantCls }
+      ? Full
+      : never,
   _FieldObj extends FieldObject = _FullCls[typeof FIELD_META],
   _ResolveFieldObj extends FieldObject = {
     [K in keyof _FieldObj as _FieldObj[K] extends ConstantField<"resolve", any, any, any, any, any>
       ? K
       : never]: _FieldObj[K];
   },
-> = (builder: BuildInternal<SrvModule>) => SrvModule["cnst"] extends never
-  ? { [key: string]: InternalInfo<Exclude<InternalType, "resolveField">> }
-  : {
-      [K in keyof _ResolveFieldObj]: _ResolveFieldObj[K] extends ConstantField<
-        "resolve",
-        infer Value,
-        any,
-        any,
-        infer Nullable
-      >
-        ? InternalInfo<"resolveField", any, any, any, any, NonNullable<Value>, Nullable>
-        : InternalInfo<Exclude<InternalType, "resolveField">>;
-    };
+> = (builder: BuildInternal<SrvModule>) => [_Cnst] extends [never]
+  ? { [key: string]: InternalInfo<InternalType> }
+  : [_FullCls] extends [never]
+    ? { [key: string]: InternalInfo<InternalType> }
+    : {
+        [K in keyof _ResolveFieldObj]: _ResolveFieldObj[K] extends ConstantField<
+          "resolve",
+          infer Value,
+          any,
+          any,
+          infer Nullable
+        >
+          ? InternalInfo<"resolveField", any, any, any, any, NonNullable<Value>, Nullable>
+          : InternalInfo<Exclude<InternalType, "resolveField">>;
+      } & { [key: string]: InternalInfo<InternalType> };
 
 export const buildInternal = {
   resolveField: (returnRef: Cls, signalOption?: SignalOption) =>

package/signal/serverSignal.ts

@@ -11,82 +11,48 @@ import {
 } from "akanjs/service";
 import type { ServerWebSocket } from "bun";
 import type { EndpointCls } from "./endpoint";
-import type { EndpointInfo } from "./endpointInfo";
+import type { EndpInfoClientReturns, EndpInfoReqType, EndpInfoServerArgs, EndpointInfo } from "./endpointInfo";
 import type { InternalCls } from "./internal";
-import type { InternalInfo } from "./internalInfo";
+import type { InternalInfo, InternalInfoReqType, InternalInfoServerArgs } from "./internalInfo";
+
+type EndpointPubsubPayload<E> = EndpInfoClientReturns<E> | DocumentModel<EndpInfoClientReturns<E>>;
 
 export interface ServerSignal extends Adaptor {
   readonly websocket: ServerWebSocket;
   readonly queue: QueueAdaptor;
 }
 
-type EndpointServerSignalMethods<EnpCls> = EnpCls extends { [ENDPOINT_META]: infer EndpointInfoObj }
+type EndpointServerSignalMethods<EnpCls> = [EnpCls] extends [{ [ENDPOINT_META]: infer EndpointInfoObj }]
   ? {
-      [K in keyof EndpointInfoObj as EndpointInfoObj[K] extends EndpointInfo<
-        "pubsub",
-        any,
-        any,
-        any,
-        any,
-        any,
-        any,
-        any,
-        any
-      >
-        ? K
-        : never]: EndpointInfoObj[K] extends EndpointInfo<
-        any,
-        any,
-        any,
-        any,
-        any,
-        infer ServerArgs,
-        any,
-        infer ClientReturns,
-        any,
-        any
-      >
-        ? (...args: [...ServerArgs, data: DocumentModel<ClientReturns>]) => void
-        : never;
+      [K in keyof EndpointInfoObj as EndpInfoReqType<EndpointInfoObj[K]> extends "pubsub" ? K : never]: (
+        ...args: [...EndpInfoServerArgs<EndpointInfoObj[K]>, data: EndpointPubsubPayload<EndpointInfoObj[K]>]
+      ) => void;
     }
-  : never;
+  : Record<never, never>;
 
-type InternalServerSignalMethods<IntCls> = IntCls extends { [INTERNAL_META]: infer InternalInfoObj }
+type InternalServerSignalMethods<IntCls> = [IntCls] extends [{ [INTERNAL_META]: infer InternalInfoObj }]
   ? {
-      [K in keyof InternalInfoObj as InternalInfoObj[K] extends InternalInfo<
-        "process",
-        any,
-        any,
-        any,
-        any,
-        any,
-        any,
-        any
-      >
-        ? K
-        : never]: InternalInfoObj[K] extends InternalInfo<
-        any,
-        any,
-        infer ServerArgs,
-        any,
-        any,
-        any,
-        infer ServerReturns
-      >
-        ? (...args: [...args: ServerArgs, jobOptions?: AkanJobOptions]) => Promise<AkanJob<any, ServerReturns>>
-        : never;
+      [K in keyof InternalInfoObj as InternalInfoReqType<InternalInfoObj[K]> extends "process" ? K : never]: (
+        ...args: [...args: InternalInfoServerArgs<InternalInfoObj[K]>, jobOptions?: AkanJobOptions]
+      ) => Promise<AkanJob<unknown, unknown>>;
     }
-  : never;
+  : Record<never, never>;
 
-type ServerSignalClsStatics = {
+export type ServerSignalClsStatics = {
   readonly refName: string;
   readonly [INJECT_META]: { queue: QueueAdaptor };
   readonly [ENDPOINT_META]: { [key: string]: EndpointInfo };
   readonly [INTERNAL_META]: { [key: string]: InternalInfo };
 };
 
-export type ServerSignalCls<EnpCls = any, IntCls = any> = AdaptorCls<
-  EndpointServerSignalMethods<EnpCls> & InternalServerSignalMethods<IntCls> & ServerSignal
+export type ServerSignalMethods<EnpCls, IntCls> = EndpointServerSignalMethods<EnpCls> &
+  InternalServerSignalMethods<IntCls>;
+
+export type TypedServerSignalCls<EnpCls, IntCls> = AdaptorCls<ServerSignalMethods<EnpCls, IntCls> & ServerSignal> &
+  ServerSignalClsStatics;
+
+export type ServerSignalCls<EnpCls = unknown, IntCls = unknown> = AdaptorCls<
+  ServerSignalMethods<EnpCls, IntCls> & ServerSignal
 > &
   ServerSignalClsStatics;
 

package/signal/slice.ts

@@ -4,7 +4,17 @@ import type { DocumentModel, QueryOf } from "akanjs/constant";
 import type { FilterInstance } from "akanjs/document";
 import { type Adaptor, type AdaptorCls, dangerouslyAdapt, type ServiceModel } from "akanjs/service";
 import type { Guard, GuardCls } from "./guard";
-import { buildSlice, type SliceBuilder, type SliceInfo } from "./sliceInfo";
+import {
+  buildSlice,
+  type SliceBuilder,
+  type SliceInfo,
+  type SliceInfoArgNames,
+  type SliceInfoArgs,
+  type SliceInfoInternalArgs,
+  type SliceInfoServerArgs,
+  type SliceInfoSrvs,
+} from "./sliceInfo";
+import type { CnstFull, CnstInput, CnstInsight, CnstLight, DbFilter, SrvMap, SrvRefName } from "./types";
 
 export interface Slice extends Adaptor {}
 
@@ -12,7 +22,7 @@ export type SliceCls<
   SrvModule extends ServiceModel = ServiceModel,
   SliceInfoObj extends { [key: string]: SliceInfo } = { [key: string]: SliceInfo },
 > = AdaptorCls & {
-  baseName: SrvModule["srv"]["refName"];
+  baseName: SrvRefName<SrvModule>;
   srv: SrvModule;
   [SLICE_META]: SliceInfoObj;
   getGuards: GuardCls[];
@@ -28,41 +38,31 @@ interface RootSliceOption {
   prefix?: string;
 }
 
+type RootSliceQuery<SrvModule extends ServiceModel, Full = CnstFull<SrvModule>> = QueryOf<DocumentModel<Full>>;
+
 type ExtendSliceInfoObj<
   SrvModule extends ServiceModel,
   LibSlices extends SliceCls[],
-  _Input = NonNullable<SrvModule["cnst"]>["_Input"],
-  _Full = NonNullable<SrvModule["cnst"]>["_Full"],
-  _Light = NonNullable<SrvModule["cnst"]>["_Light"],
-  _Insight = NonNullable<SrvModule["cnst"]>["_Insight"],
-  _Filter extends FilterInstance = any,
+  _Input = CnstInput<SrvModule>,
+  _Full = CnstFull<SrvModule>,
+  _Light = CnstLight<SrvModule>,
+  _Insight = CnstInsight<SrvModule>,
+  _Filter extends FilterInstance = DbFilter<SrvModule>,
   _Merged = MergeAllKeyOfObjects<LibSlices, typeof SLICE_META>,
 > = {
-  [K in keyof _Merged]: _Merged[K] extends SliceInfo<
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    infer Srvs,
-    infer ArgNames,
-    infer Args,
-    infer InternalArgs,
-    infer ServerArgs
-  >
+  [K in keyof _Merged]: _Merged[K] extends SliceInfo
     ? SliceInfo<
-        SrvModule["srv"]["refName"],
+        SrvRefName<SrvModule>,
         _Input,
         _Full,
         _Light,
         _Insight,
         _Filter,
-        Srvs,
-        ArgNames,
-        Args,
-        InternalArgs,
-        ServerArgs
+        SliceInfoSrvs<_Merged[K]>,
+        SliceInfoArgNames<_Merged[K]>,
+        SliceInfoArgs<_Merged[K]>,
+        SliceInfoInternalArgs<_Merged[K]>,
+        SliceInfoServerArgs<_Merged[K]>
       >
     : never;
 };
@@ -72,12 +72,12 @@ export function slice<
   SrvModule extends ServiceModel,
   BuildSlice extends SliceBuilder<SrvModule>,
   LibSlices extends SliceCls[],
-  _Input = NonNullable<SrvModule["cnst"]>["_Input"],
-  _Full = NonNullable<SrvModule["cnst"]>["_Full"],
-  _Light = NonNullable<SrvModule["cnst"]>["_Light"],
-  _Insight = NonNullable<SrvModule["cnst"]>["_Insight"],
-  _Filter extends FilterInstance = NonNullable<SrvModule["db"]>["_Filter"],
-  _Query = QueryOf<DocumentModel<_Full>>,
+  _Input = CnstInput<SrvModule>,
+  _Full = CnstFull<SrvModule>,
+  _Light = CnstLight<SrvModule>,
+  _Insight = CnstInsight<SrvModule>,
+  _Filter extends FilterInstance = DbFilter<SrvModule>,
+  _Query = RootSliceQuery<SrvModule, _Full>,
 >(
   srv: SrvModule,
   option: RootSliceOption,
@@ -90,13 +90,13 @@ export function slice<
     LibSlices extends []
       ? {
           [""]: SliceInfo<
-            SrvModule["srv"]["refName"],
+            SrvRefName<SrvModule>,
             _Input,
             _Full,
             _Light,
             _Insight,
             _Filter,
-            SrvModule["srvMap"],
+            SrvMap<SrvModule>,
             ["query"],
             [_Query],
             [],
@@ -146,7 +146,7 @@ export function slice<
           .search<"query", object>("query", Any)
           .exec((query) => query ?? {}),
       },
-      sliceBuilder(init),
+      sliceBuilder(init as Parameters<BuildSlice>[0]),
     );
   };
   libSlices.forEach((libSlice) => {

package/signal/sliceInfo.ts

@@ -10,7 +10,7 @@ import type {
   PurifiedModel,
   QueryOf,
 } from "akanjs/constant";
-import type { ExtractSort, FilterCls, FilterInstance } from "akanjs/document";
+import type { FilterCls, FilterInstance } from "akanjs/document";
 import type { ServiceModel } from "akanjs/service";
 import {
   type ArgInfo,
@@ -20,7 +20,7 @@ import {
   type InternalArgProps,
 } from "./endpointInfo";
 import type { InternalArgCls } from "./internalArg";
-import type { SignalOption } from "./types";
+import type { CnstFull, CnstInput, CnstInsight, CnstLight, DbFilter, SignalOption, SrvMap, SrvRefName } from "./types";
 
 export class SliceInfo<
   RefName extends string = string,
@@ -192,7 +192,7 @@ export const buildSlice =
     filter: FilterCls<Filter>,
   ) =>
   (signalOption?: SignalOption) =>
-    new SliceInfo<T, Input, Full, Light, Insight, Filter, SrvModule["srvMap"], [], [], [], []>(
+    new SliceInfo<T, Input, Full, Light, Insight, Filter, SrvMap<SrvModule>, [], [], [], []>(
       refName,
       input,
       full,
@@ -202,53 +202,69 @@ export const buildSlice =
       signalOption,
     );
 
-export type SliceInfoRefName<S> =
-  S extends SliceInfo<infer R, any, any, any, any, any, any, any, any, any, any> ? R : never;
-export type SliceInfoInput<S> =
-  S extends SliceInfo<any, infer I, any, any, any, any, any, any, any, any, any> ? I : never;
-export type SliceInfoFull<S> =
-  S extends SliceInfo<any, any, infer F, any, any, any, any, any, any, any, any> ? F : never;
-export type SliceInfoLight<S> =
-  S extends SliceInfo<any, any, any, infer L, any, any, any, any, any, any, any> ? L : never;
-export type SliceInfoInsight<S> =
-  S extends SliceInfo<any, any, any, any, infer I, any, any, any, any, any, any> ? I : never;
-export type SliceInfoFilter<S> =
-  S extends SliceInfo<any, any, any, any, any, infer F, any, any, any, any, any> ? F : never;
-export type SliceInfoSrvs<S> =
-  S extends SliceInfo<any, any, any, any, any, any, infer S2, any, any, any, any> ? S2 : never;
-export type SliceInfoArgNames<S> =
-  S extends SliceInfo<any, any, any, any, any, any, any, infer N, any, any, any> ? N : never;
-export type SliceInfoArgs<S> =
-  S extends SliceInfo<any, any, any, any, any, any, any, any, infer A, any, any> ? A : never;
-export type SliceInfoInternalArgs<S> =
-  S extends SliceInfo<any, any, any, any, any, any, any, any, any, infer I, any> ? I : never;
-export type SliceInfoServerArgs<S> =
-  S extends SliceInfo<any, any, any, any, any, any, any, any, any, any, infer S2> ? S2 : never;
+type SliceInfoEmptyParts = {
+  refName: never;
+  input: never;
+  full: never;
+  light: never;
+  insight: never;
+  filter: never;
+  srvs: never;
+  argNames: never;
+  args: never;
+  internalArgs: never;
+  serverArgs: never;
+};
+export type SliceInfoParts<S> =
+  S extends SliceInfo<
+    infer RefName,
+    infer Input,
+    infer Full,
+    infer Light,
+    infer Insight,
+    infer Filter,
+    infer Srvs,
+    infer ArgNames,
+    infer Args,
+    infer InternalArgs,
+    infer ServerArgs
+  >
+    ? {
+        refName: RefName;
+        input: Input;
+        full: Full;
+        light: Light;
+        insight: Insight;
+        filter: Filter;
+        srvs: Srvs;
+        argNames: ArgNames;
+        args: Args;
+        internalArgs: InternalArgs;
+        serverArgs: ServerArgs;
+      }
+    : SliceInfoEmptyParts;
+export type SliceInfoRefName<S> = SliceInfoParts<S>["refName"];
+export type SliceInfoInput<S> = SliceInfoParts<S>["input"];
+export type SliceInfoFull<S> = SliceInfoParts<S>["full"];
+export type SliceInfoLight<S> = SliceInfoParts<S>["light"];
+export type SliceInfoInsight<S> = SliceInfoParts<S>["insight"];
+export type SliceInfoFilter<S> = SliceInfoParts<S>["filter"];
+export type SliceInfoSrvs<S> = SliceInfoParts<S>["srvs"];
+export type SliceInfoArgNames<S> = SliceInfoParts<S>["argNames"];
+export type SliceInfoArgs<S> = SliceInfoParts<S>["args"];
+export type SliceInfoInternalArgs<S> = SliceInfoParts<S>["internalArgs"];
+export type SliceInfoServerArgs<S> = SliceInfoParts<S>["serverArgs"];
 
 export type SliceBuilder<
   SrvModule extends ServiceModel,
-  _Input = NonNullable<SrvModule["cnst"]>["_Input"],
-  _Full = NonNullable<SrvModule["cnst"]>["_Full"],
-  _Light = NonNullable<SrvModule["cnst"]>["_Light"],
-  _Insight = NonNullable<SrvModule["cnst"]>["_Insight"],
-  _Filter extends FilterInstance = NonNullable<SrvModule["db"]>["_Filter"],
-  _Sort = ExtractSort<_Filter>,
+  _Input = CnstInput<SrvModule>,
+  _Full = CnstFull<SrvModule>,
+  _Light = CnstLight<SrvModule>,
+  _Insight = CnstInsight<SrvModule>,
+  _Filter extends FilterInstance = DbFilter<SrvModule>,
+  _SliceInfo = SliceInfo<SrvRefName<SrvModule>, _Input, _Full, _Light, _Insight, _Filter, SrvMap<SrvModule>>,
 > = (
   init: (
     signalOption?: SignalOption,
-  ) => SliceInfo<
-    SrvModule["srv"]["refName"],
-    _Input,
-    _Full,
-    _Light,
-    _Insight,
-    _Filter,
-    SrvModule["srvMap"],
-    [],
-    [],
-    [],
-    []
-  >,
-) => {
-  [key: string]: SliceInfo<SrvModule["srv"]["refName"], _Input, _Full, _Light, _Insight, _Filter, SrvModule["srvMap"]>;
-};
+  ) => SliceInfo<SrvRefName<SrvModule>, _Input, _Full, _Light, _Insight, _Filter, SrvMap<SrvModule>, [], [], [], []>,
+) => Record<string, _SliceInfo>;