akanjs 2.3.5-rc.8 → 2.3.5

package/signal/types.ts

@@ -6,12 +6,15 @@ import type { SliceCls } from "./slice";
 
 export type CnstOf<S extends ServiceModel> = NonNullable<S["cnst"]>;
 export type DbOf<S extends ServiceModel> = NonNullable<S["db"]>;
+export type SrvOf<S extends ServiceModel> = S["srv"];
+export type SrvRefName<S extends ServiceModel> = SrvOf<S>["refName"];
+export type SrvMap<S extends ServiceModel> = S["srvMap"];
 
 export type CnstRefName<S extends ServiceModel> = CnstOf<S>["refName"];
 export type CnstInput<S extends ServiceModel> = CnstOf<S>["_Input"];
-export type CnstFull<S extends ServiceModel> = CnstOf<S>["_Full"];
-export type CnstLight<S extends ServiceModel> = CnstOf<S>["_Light"];
-export type CnstInsight<S extends ServiceModel> = CnstOf<S>["_Insight"];
+export type CnstFull<S extends ServiceModel> = UnCls<CnstOf<S>["full"]> & CnstOf<S>["_Full"];
+export type CnstLight<S extends ServiceModel> = UnCls<CnstOf<S>["light"]> & CnstOf<S>["_Light"];
+export type CnstInsight<S extends ServiceModel> = UnCls<CnstOf<S>["insight"]> & CnstOf<S>["_Insight"];
 export type CnstDefault<S extends ServiceModel> = CnstOf<S>["_Default"];
 export type CnstDefaultInput<S extends ServiceModel> = CnstOf<S>["_DefaultInput"];
 export type CnstDefaultState<S extends ServiceModel> = CnstOf<S>["_DefaultState"];
@@ -21,23 +24,26 @@ export type CnstPurifiedInput<S extends ServiceModel> = CnstOf<S>["_PurifiedInpu
 export type CnstCapitalizedRefName<S extends ServiceModel> = CnstOf<S>["_CapitalizedRefName"];
 
 export type DbFilter<S extends ServiceModel> = DbOf<S>["_Filter"];
+export type DbDoc<S extends ServiceModel> = DbOf<S>["_Doc"];
+export type DbQuery<S extends ServiceModel> = DbOf<S>["_Query"];
 export type DbSort<S extends ServiceModel> = DbOf<S>["_Sort"];
 
 export type SlceSrv<S extends SliceCls> = S["srv"];
-export type SlceCnstRefName<S extends SliceCls> = S["srv"]["cnst"]["refName"];
-export type SlceCnstInput<S extends SliceCls> = S["srv"]["cnst"]["_Input"];
-export type SlceCnstFull<S extends SliceCls> = S["srv"]["cnst"]["_Full"];
-export type SlceCnstLight<S extends SliceCls> = S["srv"]["cnst"]["_Light"];
-export type SlceCnstInsight<S extends SliceCls> = S["srv"]["cnst"]["_Insight"];
-export type SlceCnstDefault<S extends SliceCls> = S["srv"]["cnst"]["_Default"];
-export type SlceCnstDefaultInput<S extends SliceCls> = S["srv"]["cnst"]["_DefaultInput"];
-export type SlceCnstDefaultState<S extends SliceCls> = S["srv"]["cnst"]["_DefaultState"];
-export type SlceCnstPurifiedInput<S extends SliceCls> = S["srv"]["cnst"]["_PurifiedInput"];
-export type SlceCnstCapitalizedRefName<S extends SliceCls> = S["srv"]["cnst"]["_CapitalizedRefName"];
-export type SlceCnstStateLight<S extends SliceCls> = S["srv"]["cnst"]["_StateLight"];
-export type SlceCnstStateInsight<S extends SliceCls> = S["srv"]["cnst"]["_StateInsight"];
-export type SlceDbFilter<S extends SliceCls> = S["srv"]["db"]["_Filter"];
-export type SlceDbSort<S extends SliceCls> = S["srv"]["db"]["_Sort"];
+export type SlceCnstRefName<S extends SliceCls> = CnstRefName<SlceSrv<S>>;
+export type SlceCnstInput<S extends SliceCls> = CnstInput<SlceSrv<S>>;
+export type SlceCnstFull<S extends SliceCls> = CnstFull<SlceSrv<S>>;
+export type SlceCnstLight<S extends SliceCls> = CnstLight<SlceSrv<S>>;
+export type SlceCnstInsight<S extends SliceCls> = CnstInsight<SlceSrv<S>>;
+export type SlceCnstDefault<S extends SliceCls> = CnstDefault<SlceSrv<S>>;
+export type SlceCnstDefaultInput<S extends SliceCls> = CnstDefaultInput<SlceSrv<S>>;
+export type SlceCnstDefaultState<S extends SliceCls> = CnstDefaultState<SlceSrv<S>>;
+export type SlceCnstPurifiedInput<S extends SliceCls> = CnstPurifiedInput<SlceSrv<S>>;
+export type SlceCnstCapitalizedRefName<S extends SliceCls> = CnstCapitalizedRefName<SlceSrv<S>>;
+export type SlceCnstStateLight<S extends SliceCls> = CnstStateLight<SlceSrv<S>>;
+export type SlceCnstStateInsight<S extends SliceCls> = CnstStateInsight<SlceSrv<S>>;
+export type SlceDbFilter<S extends SliceCls> = DbFilter<SlceSrv<S>>;
+export type SlceDbQuery<S extends SliceCls> = DbQuery<SlceSrv<S>>;
+export type SlceDbSort<S extends SliceCls> = DbSort<SlceSrv<S>>;
 
 export const argTypes = ["body", "param", "search", "upload", "msg", "room"] as const;
 export type ArgType = (typeof argTypes)[number];

package/store/action.ts

@@ -1,4 +1,4 @@
-import { DataList, type Dayjs, FIELD_META, type GetStateObject, type SLICE_META } from "akanjs/base";
+import { DataList, type Dayjs, FIELD_META, type GetStateObject } from "akanjs/base";
 import {
   capitalize,
   deepObjectify,
@@ -20,9 +20,21 @@ import {
 } from "akanjs/constant";
 import type { BaseFilterSortKey, ExtractSort, FilterInstance } from "akanjs/document";
 import type { FetchInitForm, FetchProxy } from "akanjs/fetch";
-import type { SerializedSlice, SliceCls, SliceInfoArgs } from "akanjs/signal";
+import type {
+  SerializedSlice,
+  SlceCnstCapitalizedRefName,
+  SlceCnstDefault,
+  SlceCnstDefaultInput,
+  SlceCnstFull,
+  SlceCnstInput,
+  SlceCnstLight,
+  SlceCnstRefName,
+  SlceDbFilter,
+  SlceDbSort,
+  SliceCls,
+} from "akanjs/signal";
 import type { SliceStateKey } from "./state";
-import type { SetGet } from "./types";
+import type { SetGet, StoreSliceArgs, StoreSliceMap, StoreSliceSuffixCap } from "./types";
 
 type SliceActionKey =
   | "initModel"
@@ -33,6 +45,16 @@ type SliceActionKey =
   | "setLimitOfModel"
   | "setQueryArgsOfModel"
   | "setSortOfModel";
+type _SliceMap<S extends SliceCls> = StoreSliceMap<S>;
+type _ActionRefName<S extends SliceCls> = SlceCnstRefName<S>;
+type _ActionCap<S extends SliceCls> = SlceCnstCapitalizedRefName<S>;
+type _ActionInput<S extends SliceCls> = SlceCnstInput<S>;
+type _ActionFull<S extends SliceCls> = SlceCnstFull<S>;
+type _ActionLight<S extends SliceCls> = SlceCnstLight<S>;
+type _ActionDefault<S extends SliceCls> = SlceCnstDefault<S>;
+type _ActionDefaultInput<S extends SliceCls> = SlceCnstDefaultInput<S>;
+type _ActionFilter<S extends SliceCls> = SlceDbFilter<S>;
+type _ActionSort<S extends SliceCls> = SlceDbSort<S>;
 
 const isNullableSliceArg = (arg: SerializedSlice["args"][number]) => arg.nullable ?? arg.type === "search";
 
@@ -207,59 +229,45 @@ type FormSetter<
     [K in `writeOn${_CapitalizedRefName}`]: (path: string | (string | number)[], value: any) => void;
   };
 
-type _SliceActionMap<SlceCls extends SliceCls> = SlceCls[typeof SLICE_META];
-type _ActSuffixCap<SlceCls extends SliceCls, Suffix extends keyof _SliceActionMap<SlceCls>> = Capitalize<
-  Suffix & string
->;
-type _ActArgs<SlceCls extends SliceCls, Suffix extends keyof _SliceActionMap<SlceCls>> = SliceInfoArgs<
-  _SliceActionMap<SlceCls>[Suffix]
->;
-
 type DefaultSliceActionFields<
   SlceCls extends SliceCls,
   _CapRef extends string,
   _FetchInitFormWithFetchPolicy,
   _Light,
   _Sort,
+  _Suffixes extends keyof _SliceMap<SlceCls> = keyof _SliceMap<SlceCls>,
 > = {
-  [Suffix in keyof _SliceActionMap<SlceCls> as `init${_CapRef}${_ActSuffixCap<SlceCls, Suffix>}`]: (
-    ...args: [...args: _ActArgs<SlceCls, Suffix>, initForm?: _FetchInitFormWithFetchPolicy]
+  [Suffix in _Suffixes as `init${_CapRef}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: (
+    ...args: [...args: StoreSliceArgs<SlceCls, Suffix>, initForm?: _FetchInitFormWithFetchPolicy]
   ) => Promise<void>;
 } & {
-  [Suffix in keyof _SliceActionMap<SlceCls> as `refresh${_CapRef}${_ActSuffixCap<SlceCls, Suffix>}`]: (
-    initForm?: _FetchInitFormWithFetchPolicy & { queryArgs?: _ActArgs<SlceCls, Suffix> },
+  [Suffix in _Suffixes as `refresh${_CapRef}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: (
+    initForm?: _FetchInitFormWithFetchPolicy & { queryArgs?: StoreSliceArgs<SlceCls, Suffix> },
   ) => Promise<void>;
 } & {
-  [Suffix in keyof _SliceActionMap<SlceCls> as `select${_CapRef}${_ActSuffixCap<SlceCls, Suffix>}`]: (
+  [Suffix in _Suffixes as `select${_CapRef}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: (
     model: _Light | _Light[],
     options?: { refresh?: boolean; remove?: boolean },
   ) => void;
 } & {
-  [Suffix in keyof _SliceActionMap<SlceCls> as `setPageOf${_CapRef}${_ActSuffixCap<SlceCls, Suffix>}`]: (
-    page: number,
-    options?: FetchPolicy,
-  ) => Promise<void>;
-} & {
-  [Suffix in keyof _SliceActionMap<SlceCls> as `addPageOf${_CapRef}${_ActSuffixCap<SlceCls, Suffix>}`]: (
-    page: number,
-    options?: FetchPolicy,
-  ) => Promise<void>;
-} & {
-  [Suffix in keyof _SliceActionMap<SlceCls> as `setLimitOf${_CapRef}${_ActSuffixCap<SlceCls, Suffix>}`]: (
-    limit: number,
+  [Suffix in _Suffixes as
+    | `setPageOf${_CapRef}${StoreSliceSuffixCap<SlceCls, Suffix>}`
+    | `addPageOf${_CapRef}${StoreSliceSuffixCap<SlceCls, Suffix>}`
+    | `setLimitOf${_CapRef}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: (
+    value: number,
     options?: FetchPolicy,
   ) => Promise<void>;
 } & {
-  [Suffix in keyof _SliceActionMap<SlceCls> as `setQueryArgsOf${_CapRef}${_ActSuffixCap<SlceCls, Suffix>}`]: (
+  [Suffix in _Suffixes as `setQueryArgsOf${_CapRef}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: (
     ...args:
-      | [...args: _ActArgs<SlceCls, Suffix>, options?: FetchPolicy]
+      | [...args: StoreSliceArgs<SlceCls, Suffix>, options?: FetchPolicy]
       | [
-          setQueryArgs: (...prevQueryArgs: _ActArgs<SlceCls, Suffix>) => _ActArgs<SlceCls, Suffix>,
+          setQueryArgs: (...prevQueryArgs: StoreSliceArgs<SlceCls, Suffix>) => StoreSliceArgs<SlceCls, Suffix>,
           options?: FetchPolicy,
         ]
   ) => Promise<void>;
 } & {
-  [Suffix in keyof _SliceActionMap<SlceCls> as `setSortOf${_CapRef}${_ActSuffixCap<SlceCls, Suffix>}`]: (
+  [Suffix in _Suffixes as `setSortOf${_CapRef}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: (
     sort: _Sort,
     options?: FetchPolicy,
   ) => Promise<void>;
@@ -267,15 +275,15 @@ type DefaultSliceActionFields<
 
 export type DefaultAction<
   SlceCls extends SliceCls,
-  _RefName extends string = SlceCls["srv"]["cnst"]["refName"],
-  _Input = SlceCls["srv"]["cnst"]["_Input"],
-  _Full extends { id: string } = SlceCls["srv"]["cnst"]["_Full"],
-  _Light = SlceCls["srv"]["cnst"]["_Light"],
-  _Filter extends FilterInstance = SlceCls["srv"]["db"]["_Filter"],
-  _CapitalizedRefName extends string = Capitalize<_RefName>,
-  _Default = SlceCls["srv"]["cnst"]["_Default"],
-  _DefaultInput = SlceCls["srv"]["cnst"]["_DefaultInput"],
-  _Sort = SlceCls["srv"]["db"]["_Sort"],
+  _RefName extends string = _ActionRefName<SlceCls>,
+  _Input = _ActionInput<SlceCls>,
+  _Full extends { id: string } = _ActionFull<SlceCls>,
+  _Light = _ActionLight<SlceCls>,
+  _Filter extends FilterInstance = _ActionFilter<SlceCls>,
+  _CapitalizedRefName extends string = _ActionCap<SlceCls>,
+  _Default = _ActionDefault<SlceCls>,
+  _DefaultInput = _ActionDefaultInput<SlceCls>,
+  _Sort = _ActionSort<SlceCls>,
   _CreateOption = CreateOption<_Full>,
   _FetchInitFormWithFetchPolicy = FetchInitForm<_Input, _Filter, _DefaultInput, _Sort> & FetchPolicy,
 > = BaseAction<_RefName, _Input, _Full, _Light, _CapitalizedRefName, _CreateOption> &
@@ -854,10 +862,15 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
     const singleSliceAction = {
       [namesOfSlice.initModel]: async function (
         this: SetGet,
-        ...args: [...args: any[], initForm: FetchInitForm<Input, Filter> & FetchPolicy]
+        ...args: [...args: any[], initForm: FetchInitForm<Input, Filter, DefaultOf<Input>, Sort> & FetchPolicy]
       ) {
         const initArgLength = Math.min(args.length, slice.args.length);
-        const initForm = { invalidate: false, ...(args[slice.args.length] ?? {}) } as FetchInitForm<Input, Filter> &
+        const initForm = { invalidate: false, ...(args[slice.args.length] ?? {}) } as FetchInitForm<
+          Input,
+          Filter,
+          DefaultOf<Input>,
+          Sort
+        > &
           FetchPolicy;
         const queryArgs = new Array(initArgLength).fill(null).map((_, i) => args[i] as object);
         const defaultModel = new cnst.full().set(initForm.default ?? {}) as unknown as Full;
@@ -869,7 +882,7 @@ export const makeActions = (refName: string, slice: { [key: string]: SerializedS
       },
       [namesOfSlice.refreshModel]: async function (
         this: SetGet,
-        initForm: FetchInitForm<Input, Filter> & FetchPolicy & { queryArgs?: any[] } = {},
+        initForm: FetchInitForm<Input, Filter, DefaultOf<Input>, Sort> & FetchPolicy & { queryArgs?: any[] } = {},
       ) {
         const args = initForm.queryArgs ?? [];
         const refreshArgLength = Math.min(args.length, slice.args.length);

package/store/state.ts

@@ -1,9 +1,20 @@
-import { DataList, type SLICE_META } from "akanjs/base";
+import { DataList } from "akanjs/base";
 import { capitalize } from "akanjs/common";
 import { ConstantRegistry, type DefaultOf } from "akanjs/constant";
 import type { ExtractSort, FilterInstance } from "akanjs/document";
-import type { SerializedSlice, SliceCls, SliceInfoArgs } from "akanjs/signal";
-import type { Submit } from "./types";
+import type {
+  SerializedSlice,
+  SlceCnstCapitalizedRefName,
+  SlceCnstDefault,
+  SlceCnstFull,
+  SlceCnstInsight,
+  SlceCnstLight,
+  SlceCnstRefName,
+  SlceDbFilter,
+  SlceDbSort,
+  SliceCls,
+} from "akanjs/signal";
+import type { StoreSliceArgs, StoreSliceMap, StoreSliceSuffixCap, Submit } from "./types";
 
 export type SliceStateKey =
   | "defaultModel"
@@ -18,6 +29,16 @@ export type SliceStateKey =
   | "limitOfModel"
   | "queryArgsOfModel"
   | "sortOfModel";
+type _SliceMap<S extends SliceCls> = StoreSliceMap<S>;
+type _StateRefName<S extends SliceCls> = SlceCnstRefName<S>;
+type _StateCap<S extends SliceCls> = SlceCnstCapitalizedRefName<S>;
+type _StateFull<S extends SliceCls> = SlceCnstFull<S>;
+type _StateLight<S extends SliceCls> = SlceCnstLight<S>;
+type _StateInsight<S extends SliceCls> = SlceCnstInsight<S>;
+type _StateDefault<S extends SliceCls> = SlceCnstDefault<S>;
+type _StateFilter<S extends SliceCls> = SlceDbFilter<S>;
+type _StateSort<S extends SliceCls> = SlceDbSort<S>;
+
 type BaseState<RefName extends string, Full, _Default = DefaultOf<Full>> = {
   [K in RefName]: Full | null;
 } & {
@@ -73,15 +94,6 @@ export type SliceState<
   [K in `sortOf${_CapitalizedRefName}${_CapitalizedSuffix}`]: _Sort;
 };
 
-type _SliceMap<SlceCls extends SliceCls> = SlceCls[typeof SLICE_META];
-type _SuffixStr<SlceCls extends SliceCls, Suffix extends keyof _SliceMap<SlceCls>> = Suffix & string;
-type _SuffixCap<SlceCls extends SliceCls, Suffix extends keyof _SliceMap<SlceCls>> = Capitalize<
-  _SuffixStr<SlceCls, Suffix>
->;
-type _ArgsOf<SlceCls extends SliceCls, Suffix extends keyof _SliceMap<SlceCls>> = SliceInfoArgs<
-  _SliceMap<SlceCls>[Suffix]
->;
-
 type DefaultSliceStateFields<
   SlceCls extends SliceCls,
   _RefName extends string,
@@ -91,45 +103,44 @@ type DefaultSliceStateFields<
   _Insight,
   _Default,
   _Sort,
+  _Suffixes extends keyof _SliceMap<SlceCls> = keyof _SliceMap<SlceCls>,
 > = {
-  [Suffix in keyof _SliceMap<SlceCls> as `default${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: _Default;
-} & {
-  [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}List${_SuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
-} & {
-  [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}ListLoading${_SuffixCap<SlceCls, Suffix>}`]: boolean;
-} & {
-  [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}InitList${_SuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
-} & {
-  [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}InitAt${_SuffixCap<SlceCls, Suffix>}`]: Date;
+  [Suffix in _Suffixes as `default${_CapRefName}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: _Default;
 } & {
-  [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}Selection${_SuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
+  [Suffix in _Suffixes as
+    | `${_RefName}List${StoreSliceSuffixCap<SlceCls, Suffix>}`
+    | `${_RefName}InitList${StoreSliceSuffixCap<SlceCls, Suffix>}`
+    | `${_RefName}Selection${StoreSliceSuffixCap<SlceCls, Suffix>}`]: DataList<_Light>;
 } & {
-  [Suffix in keyof _SliceMap<SlceCls> as `${_RefName}Insight${_SuffixCap<SlceCls, Suffix>}`]: _Insight;
+  [Suffix in _Suffixes as `${_RefName}InitAt${StoreSliceSuffixCap<SlceCls, Suffix>}`]: Date;
 } & {
-  [Suffix in keyof _SliceMap<SlceCls> as `lastPageOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: number;
+  [Suffix in _Suffixes as `${_RefName}ListLoading${StoreSliceSuffixCap<SlceCls, Suffix>}`]: boolean;
 } & {
-  [Suffix in keyof _SliceMap<SlceCls> as `pageOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: number;
+  [Suffix in _Suffixes as `${_RefName}Insight${StoreSliceSuffixCap<SlceCls, Suffix>}`]: _Insight;
 } & {
-  [Suffix in keyof _SliceMap<SlceCls> as `limitOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: number;
+  [Suffix in _Suffixes as
+    | `lastPageOf${_CapRefName}${StoreSliceSuffixCap<SlceCls, Suffix>}`
+    | `pageOf${_CapRefName}${StoreSliceSuffixCap<SlceCls, Suffix>}`
+    | `limitOf${_CapRefName}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: number;
 } & {
-  [Suffix in keyof _SliceMap<SlceCls> as `queryArgsOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: _ArgsOf<
+  [Suffix in _Suffixes as `queryArgsOf${_CapRefName}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: StoreSliceArgs<
     SlceCls,
     Suffix
   >;
 } & {
-  [Suffix in keyof _SliceMap<SlceCls> as `sortOf${_CapRefName}${_SuffixCap<SlceCls, Suffix>}`]: _Sort;
+  [Suffix in _Suffixes as `sortOf${_CapRefName}${StoreSliceSuffixCap<SlceCls, Suffix>}`]: _Sort;
 };
 
 export type DefaultState<
   SlceCls extends SliceCls,
-  _RefName extends SlceCls["srv"]["cnst"]["refName"] = SlceCls["srv"]["cnst"]["refName"],
-  _Full = NonNullable<SlceCls["srv"]["cnst"]>["_Full"],
-  _Light extends { id: string } = SlceCls["srv"]["cnst"]["_Light"],
-  _Insight = SlceCls["srv"]["cnst"]["_Insight"],
-  _Filter extends FilterInstance = SlceCls["srv"]["db"]["_Filter"],
-  _CapitalizedRefName extends string = Capitalize<_RefName>,
-  _Default = SlceCls["srv"]["cnst"]["_Default"],
-  _Sort = SlceCls["srv"]["db"]["_Sort"],
+  _RefName extends _StateRefName<SlceCls> = _StateRefName<SlceCls>,
+  _Full = _StateFull<SlceCls>,
+  _Light extends { id: string } = _StateLight<SlceCls>,
+  _Insight = _StateInsight<SlceCls>,
+  _Filter extends FilterInstance = _StateFilter<SlceCls>,
+  _CapitalizedRefName extends string = _StateCap<SlceCls>,
+  _Default = _StateDefault<SlceCls>,
+  _Sort = _StateSort<SlceCls>,
 > = BaseState<_RefName, _Full, _Default> &
   DefaultSliceStateFields<SlceCls, _RefName, _CapitalizedRefName, _Full, _Light, _Insight, _Default, _Sort>;
 

package/store/stateBuilder.ts

@@ -1,11 +1,11 @@
 import {
   type Cls,
   DataList,
+  DEFAULT_VALUE,
   type EnumInstance,
   getEnv,
   getNonArrayModel,
   isEnum,
-  PRIMITIVE_DEFAULT_VALUE,
   PrimitiveRegistry,
   type PrimitiveScalar,
 } from "akanjs/base";
@@ -80,7 +80,7 @@ type FieldTypeInput = PrimitiveInput | Cls | EnumInstance | FieldTypeInput[];
 
 type ValueOfType<T> = T extends readonly (infer V)[]
   ? ValueOfType<V>[]
-  : T extends { [PRIMITIVE_DEFAULT_VALUE]: infer V }
+  : T extends { [DEFAULT_VALUE]: infer V }
     ? V
     : T extends EnumInstance<any, infer V>
       ? V
@@ -300,7 +300,7 @@ const createTypedDefaultFactory = (type: any, options: { default?: any; nullable
   if (arrDepth > 0) return () => [];
   if (isEnum(modelRef)) return () => (modelRef as EnumInstance).values[0];
   if (PrimitiveRegistry.has(modelRef as Cls)) {
-    const defaultValue = (modelRef as typeof PrimitiveScalar)[PRIMITIVE_DEFAULT_VALUE];
+    const defaultValue = (modelRef as typeof PrimitiveScalar)[DEFAULT_VALUE];
     return makeDefaultFactory(defaultValue);
   }
   if (ConstantRegistry.has(modelRef as Cls)) return () => new (modelRef as Cls)();

package/store/store.ts

@@ -11,7 +11,18 @@ import {
 import { applyMixins } from "akanjs/common";
 import type { FilterInstance } from "akanjs/document";
 import type { ClientSignal } from "akanjs/fetch";
-import type { SerializedSlice, SliceCls } from "akanjs/signal";
+import type {
+  SerializedSlice,
+  SlceCnstCapitalizedRefName,
+  SlceCnstDefault,
+  SlceCnstFull,
+  SlceCnstInput,
+  SlceCnstInsight,
+  SlceCnstLight,
+  SlceDbFilter,
+  SlceDbSort,
+  SliceCls,
+} from "akanjs/signal";
 import { type DefaultAction, makeActions, makeFormSetter } from "./action";
 import { createDatabaseState, createSliceState, type DefaultState } from "./state";
 import {
@@ -29,7 +40,42 @@ import {
   type WritableStateBuilder,
   type WritableStateOf,
 } from "./stateBuilder";
-import type { InternalSlice, SetGet, SetGetWritable } from "./types";
+import type { InternalSlice, SetGet, SetGetWritable, StoreSliceMap, StoreSliceName, StoreSliceSuffix } from "./types";
+
+type _SliceMap<S extends SliceCls> = StoreSliceMap<S>;
+type _StoreInput<S extends SliceCls> = SlceCnstInput<S>;
+type _StoreFull<S extends SliceCls> = SlceCnstFull<S>;
+type _StoreLight<S extends SliceCls> = SlceCnstLight<S>;
+type _StoreInsight<S extends SliceCls> = SlceCnstInsight<S>;
+type _StoreFilter<S extends SliceCls> = SlceDbFilter<S>;
+type _StoreCap<S extends SliceCls> = SlceCnstCapitalizedRefName<S>;
+type _StoreDefault<S extends SliceCls> = SlceCnstDefault<S>;
+type _StoreSort<S extends SliceCls> = SlceDbSort<S>;
+type StoreSliceOf<
+  SlceCls extends SliceCls,
+  RefName extends string,
+  Suffix extends keyof _SliceMap<SlceCls>,
+  Input,
+  Full,
+  Light extends { id: string },
+  Insight,
+  Filter extends FilterInstance,
+  CapitalizedRefName extends string,
+  Default,
+  Sort,
+> = InternalSlice<
+  _SliceMap<SlceCls>[Suffix],
+  RefName,
+  StoreSliceSuffix<SlceCls, Suffix>,
+  Input,
+  Full,
+  Light,
+  Insight,
+  Filter,
+  CapitalizedRefName,
+  Default,
+  Sort
+>;
 
 export type StoreCls<
   RefName extends string = string,
@@ -38,24 +84,24 @@ export type StoreCls<
   SlceCls extends SliceCls = any,
   DerivedState = unknown,
   State = WritableState & DerivedState,
-  _Input = SlceCls["srv"]["cnst"]["_Input"],
-  _Full = SlceCls["srv"]["cnst"]["_Full"],
-  _Light extends { id: string } = SlceCls["srv"]["cnst"]["_Light"],
-  _Insight = SlceCls["srv"]["cnst"]["_Insight"],
-  _Filter extends FilterInstance = SlceCls["srv"]["db"]["_Filter"],
-  _CapitalizedRefName extends string = Capitalize<RefName>,
-  _Default = SlceCls["srv"]["cnst"]["_Default"],
-  _Sort = SlceCls["srv"]["db"]["_Sort"],
+  _Input = _StoreInput<SlceCls>,
+  _Full = _StoreFull<SlceCls>,
+  _Light extends { id: string } = _StoreLight<SlceCls>,
+  _Insight = _StoreInsight<SlceCls>,
+  _Filter extends FilterInstance = _StoreFilter<SlceCls>,
+  _CapitalizedRefName extends string = _StoreCap<SlceCls>,
+  _Default = _StoreDefault<SlceCls>,
+  _Sort = _StoreSort<SlceCls>,
 > = Cls<
   SetGetWritable<WritableState, State> &
     Action & {
       slice: {
-        [Suffix in keyof SlceCls[typeof SLICE_META] as Suffix extends string
-          ? `${RefName}${Capitalize<Suffix>}`
-          : never]: InternalSlice<
-          SlceCls[typeof SLICE_META][Suffix],
+        [Suffix in keyof _SliceMap<SlceCls> as Suffix extends string
+          ? StoreSliceName<RefName, Suffix>
+          : never]: StoreSliceOf<
+          SlceCls,
           RefName,
-          Suffix & string,
+          Suffix,
           _Input,
           _Full,
           _Light,

package/store/types.ts

@@ -1,6 +1,7 @@
+import type { SLICE_META } from "akanjs/base";
 import type { DefaultOf } from "akanjs/constant";
 import type { ExtractSort, FilterInstance } from "akanjs/document";
-import type { SliceInfo } from "akanjs/signal";
+import type { SliceCls, SliceInfo, SliceInfoArgs } from "akanjs/signal";
 import type { SliceAction } from "./action";
 import type { SliceState } from "./state";
 
@@ -35,10 +36,20 @@ export type Get<State, Actions> = {
   get: () => State & Actions;
 };
 
+export type StoreSliceMap<SlceCls extends SliceCls> = SlceCls[typeof SLICE_META];
+export type StoreSliceSuffix<SlceCls extends SliceCls, Suffix extends keyof StoreSliceMap<SlceCls>> = Suffix & string;
+export type StoreSliceSuffixCap<SlceCls extends SliceCls, Suffix extends keyof StoreSliceMap<SlceCls>> = Capitalize<
+  StoreSliceSuffix<SlceCls, Suffix>
+>;
+export type StoreSliceArgs<SlceCls extends SliceCls, Suffix extends keyof StoreSliceMap<SlceCls>> = SliceInfoArgs<
+  StoreSliceMap<SlceCls>[Suffix]
+>;
+export type StoreSliceName<RefName extends string, Suffix extends string> = `${RefName}${Capitalize<Suffix>}`;
+
 export type SliceStateAction<
   RefName extends string = string,
   Suffix extends string = "",
-  SliceName extends string = `${RefName}${Capitalize<Suffix>}`,
+  SliceName extends string = StoreSliceName<RefName, Suffix>,
   State = any,
   Action = any,
 > = Action & {
@@ -61,9 +72,8 @@ export type InternalSlice<
   _CapitalizedRefName extends string = Capitalize<RefName>,
   _Default = DefaultOf<Full>,
   _Sort = ExtractSort<Filter>,
-  _Args extends any[] = SlceInfo extends SliceInfo<any, any, any, any, any, any, any, any, infer Args, any, any>
-    ? Args
-    : never,
+  _Args extends any[] = SliceInfoArgs<SlceInfo>,
   _SliceState = SliceState<RefName, "", Full, Light, _Args, Insight, Filter, _CapitalizedRefName, "", _Default, _Sort>,
   _SliceAction = SliceAction<RefName, "", Input, Light, _Args, Filter, _CapitalizedRefName, "", _Sort>,
-> = SliceStateAction<RefName, Suffix, `${RefName}${Capitalize<Suffix>}`, _SliceState, _SliceAction>;
+  _SliceName extends string = StoreSliceName<RefName, Suffix>,
+> = SliceStateAction<RefName, Suffix, _SliceName, _SliceState, _SliceAction>;

package/types/base/base.d.ts

@@ -1,10 +1,14 @@
-import type { Cls } from ".";
+import type { CLIENT_VALUE, Cls, DEFAULT_VALUE, PURIFIED_VALUE, SERVER_VALUE } from ".";
 import { Float, Int } from "./primitiveRegistry.d.ts";
 export type EnumInstance<RefName extends string = string, T = string | number> = Cls<{
     refName: RefName;
     value: T;
 }, {
     refName: RefName;
+    [SERVER_VALUE]: T;
+    [CLIENT_VALUE]: T;
+    [DEFAULT_VALUE]: T;
+    [PURIFIED_VALUE]: T;
     type: StringConstructor | typeof Int | typeof Float;
     values: readonly T[];
     valueMap: Map<T, number>;