@diphyx/harlemify 5.2.0 → 5.4.0

package/README.md

@@ -2,40 +2,66 @@
 
 > Factory-driven state management for Nuxt powered by [Harlem](https://harlemjs.com/)
 
+![Version](https://img.shields.io/badge/version-5.3.0-42b883)
+![License](https://img.shields.io/badge/license-MIT-blue)
+
 Define your data **shape** once with Zod — get typed **models**, computed **views**, and async **actions** with a single `createStore` call.
 
-- **Schema-first** — Define your data shape once, get TypeScript types and validation automatically
-- **Reactive state** — Single items and collections with built-in mutations
-- **Computed views** — Derived read-only state that updates when models change
-- **API integration** — Declarative HTTP actions that fetch and commit data in one step
-- **Status tracking** — Every action exposes loading, error, and status reactively
-- **Concurrency control** — Block, skip, cancel, or allow parallel calls per action
-- **Vue composables** — Reactive helpers for actions, models, and views in components
-- **SSR ready** — Server-side rendering with automatic state hydration
+Built on top of [Harlem](https://harlemjs.com/), a powerful and extensible state management library for Vue 3.
 
-## Install
+---
 
-```bash
-npm install @diphyx/harlemify
-```
+## The Problem
+
+Every Nuxt app has the same boilerplate for every API resource:
 
 ```typescript
-// nuxt.config.ts
-export default defineNuxtConfig({
-    modules: ["@diphyx/harlemify"],
-});
+// Without Harlemify — this gets written for EVERY resource
+
+// 1. Define types manually
+interface User {
+    id: number;
+    name: string;
+    email: string;
+}
+
+// 2. Define state
+const users = ref<User[]>([]);
+const currentUser = ref<User | null>(null);
+const loading = ref(false);
+const error = ref<Error | null>(null);
+
+// 3. Write fetch logic
+async function fetchUsers() {
+    loading.value = true;
+    error.value = null;
+    try {
+        users.value = await $fetch("/api/users");
+    } catch (e) {
+        error.value = e as Error;
+    } finally {
+        loading.value = false;
+    }
+}
+
+// 4. Repeat for create, update, delete...
+// 5. Repeat for every resource in your app...
 ```
 
-## Usage
+## The Solution
+
+With Harlemify, define a data shape once and get everything else for free:
 
 ```typescript
-const userShape = shape((factory) => ({
-    id: factory.number().meta({
-        identifier: true,
-    }),
-    name: factory.string(),
-    email: factory.email(),
-}));
+const userShape = shape((factory) => {
+    return {
+        id: factory.number().meta({
+            identifier: true,
+        }),
+        name: factory.string(),
+        email: factory.email(),
+    };
+});
 
 export const userStore = createStore({
     name: "users",
@@ -57,35 +83,73 @@ export const userStore = createStore({
                 {
                     url: "/users",
                 },
+                { model: "list", mode: ModelManyMode.SET },
+            ),
+            get: api.get(
                 {
-                    model: "list",
-                    mode: ModelManyMode.SET,
+                    url(view) {
+                        return `/users/${view.user.value?.id}`;
+                    },
+                },
+                { model: "current", mode: ModelOneMode.SET },
+            ),
+            create: api.post(
+                {
+                    url: "/users",
                 },
+                { model: "list", mode: ModelManyMode.ADD },
+            ),
+            delete: api.delete(
+                {
+                    url(view) {
+                        return `/users/${view.user.value?.id}`;
+                    },
+                },
+                { model: "list", mode: ModelManyMode.REMOVE },
             ),
         };
     },
 });
 ```
 
+Use it in any component with built-in composables:
+
 ```vue
 <script setup>
-const { execute, loading } = useStoreAction(userStore, "list");
-const { data } = useStoreView(userStore, "users");
+const { execute, loading, error } = useStoreAction(userStore, "list");
+const { data: users } = useStoreView(userStore, "users");
 
 await execute();
 </script>
 
 <template>
-    <ul v-if="!loading">
-        <li v-for="user in data.value" :key="user.id">{{ user.name }}</li>
+    <p v-if="error">{{ error.message }}</p>
+    <ul v-else-if="!loading">
+        <li v-for="user in users" :key="user.id">{{ user.name }}</li>
     </ul>
 </template>
 ```
 
+## Compatibility
+
+| Dependency | Version               |
+| ---------- | --------------------- |
+| Nuxt       | `^3.14.0` or `^4.0.0` |
+| Vue        | `^3.5.0`              |
+| Zod        | `^4.0.0`              |
+
+> **Note:** Early Nuxt 4 versions (e.g., 4.1.x) may have issues resolving the `#build` alias for module templates. If you encounter build errors related to `#build/harlemify.config`, upgrade to the latest Nuxt 4 release.
+
 ## Documentation
 
+Full docs with guides, API reference, and examples:
+
 [https://diphyx.github.io/harlemify/](https://diphyx.github.io/harlemify/)
 
+## Contributing
+
+Contributions are welcome! Please open an issue first to discuss what you'd like to change.
+
 ## License
 
-MIT
+[MIT](LICENSE)

package/dist/module.json

@@ -2,9 +2,9 @@
   "name": "harlemify",
   "configKey": "harlemify",
   "compatibility": {
-    "nuxt": ">=3.0.0 || >=4.0.0"
+    "nuxt": "^3.14.0 || ^4.0.0"
   },
-  "version": "5.2.0",
+  "version": "5.4.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,17 +1,18 @@
-import { defineNuxtModule, createResolver, addTemplate, addPlugin, addImportsDir, addImports } from '@nuxt/kit';
+import { useLogger, defineNuxtModule, createResolver, addTemplate, addPlugin, addImportsDir, addImports } from '@nuxt/kit';
 
+const logger = useLogger("harlemify");
 const module = defineNuxtModule({
   meta: {
     name: "harlemify",
     configKey: "harlemify",
     compatibility: {
-      nuxt: ">=3.0.0 || >=4.0.0"
+      nuxt: "^3.14.0 || ^4.0.0"
     }
   },
   defaults: {},
   setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
-    addTemplate({
+    const template = addTemplate({
       write: true,
       filename: "harlemify.config.mjs",
       getContents() {
@@ -27,6 +28,7 @@ const module = defineNuxtModule({
       }
     ]);
     nuxt.options.build.transpile.push(/@harlem\//);
+    logger.success(`Module registered, config template: ${template.dst}`);
   }
 });
 

package/dist/runtime/composables/action.d.ts

@@ -1,10 +1,10 @@
 import { type ComputedRef, type Ref } from "vue";
-import { ActionStatus, type ActionCall, type ActionCallOptions } from "../core/types/action.js";
+import { ActionStatus, type ActionCall, type ActionApiCall, type ActionHandlerCall, type ActionCallOptions, type ActionApiCallOptions, type ActionHandlerCallOptions } from "../core/types/action.js";
 export interface UseStoreActionOptions {
     isolated?: boolean;
 }
-export type UseStoreAction<T> = {
-    execute: (options?: ActionCallOptions) => Promise<T>;
+export type UseStoreAction<T, O = ActionCallOptions> = {
+    execute: (options?: Omit<O, "bind">) => Promise<T>;
     error: Readonly<Ref<Error | null>>;
     status: Readonly<Ref<ActionStatus>>;
     loading: ComputedRef<boolean>;
@@ -14,4 +14,4 @@ export declare function useIsolatedActionError(): Ref<Error | null>;
 export declare function useIsolatedActionStatus(): Ref<ActionStatus>;
 export declare function useStoreAction<A extends Record<string, ActionCall<any>>, K extends keyof A & string, T = Awaited<ReturnType<A[K]>>>(store: {
     action: A;
-}, key: K, options?: UseStoreActionOptions): UseStoreAction<T>;
+}, key: K, options?: UseStoreActionOptions): UseStoreAction<T, A[K] extends ActionHandlerCall<infer P, any> ? ActionHandlerCallOptions<P> : A[K] extends ActionApiCall<any> ? ActionApiCallOptions : ActionCallOptions>;

package/dist/runtime/composables/compose.d.ts

@@ -0,0 +1,9 @@
+import type { Ref } from "vue";
+import type { ComposeCallback, ComposeDefinitions, StoreCompose } from "../core/types/compose.js";
+export type UseStoreCompose<A extends any[] = any[]> = {
+    execute: (...args: A) => Promise<void>;
+    active: Readonly<Ref<boolean>>;
+};
+export declare function useStoreCompose<CD extends ComposeDefinitions, K extends keyof StoreCompose<CD> & string, A extends any[] = CD[K] extends ComposeCallback<infer P> ? P : any[]>(store: {
+    compose: StoreCompose<CD>;
+}, key: K): UseStoreCompose<A>;

package/dist/runtime/composables/compose.js

@@ -0,0 +1,10 @@
+export function useStoreCompose(store, key) {
+  const compose = store.compose[key];
+  if (!compose) {
+    throw new Error(`Compose "${key}" not found in store`);
+  }
+  return {
+    execute: (...args) => compose(...args),
+    active: compose.active
+  };
+}

package/dist/runtime/composables/model.d.ts

@@ -1,4 +1,4 @@
-import type { ModelCall, ModelOneCall, ModelManyCall, ModelOneCommit, ModelManyCommit, StoreModel, ModelDefinitions } from "../core/types/model.js";
+import type { ModelCall, ModelOneCall, ModelManyCall, ModelOneCommit, ModelManyListCommit, ModelManyRecordCommit, ModelManyCommit, StoreModel, ModelDefinitions } from "../core/types/model.js";
 export interface UseStoreModelOptions {
     debounce?: number;
     throttle?: number;
@@ -8,14 +8,14 @@ type UseStoreModelOne<C extends ModelOneCommit<any>> = {
     reset: C["reset"];
     patch: C["patch"];
 };
-type UseStoreModelMany<C extends ModelManyCommit<any>> = {
+type UseStoreModelMany<C extends ModelManyListCommit<any, any> | ModelManyRecordCommit<any>> = {
     set: C["set"];
     reset: C["reset"];
     patch: C["patch"];
     add: C["add"];
     remove: C["remove"];
 };
-export type UseStoreModel<M extends ModelCall<any> = ModelCall<any>> = M extends ModelManyCall<infer S> ? UseStoreModelMany<ModelManyCommit<S>> : M extends ModelOneCall<infer S> ? UseStoreModelOne<ModelOneCommit<S>> : never;
+export type UseStoreModel<M extends ModelCall<any> = ModelCall<any>> = M extends ModelManyCall<infer S, infer I, infer T> ? UseStoreModelMany<ModelManyCommit<S, I, T>> : M extends ModelOneCall<infer S> ? UseStoreModelOne<ModelOneCommit<S>> : never;
 export declare function useStoreModel<M extends StoreModel<ModelDefinitions>, K extends keyof M & string>(store: {
     model: M;
 }, key: K, options?: UseStoreModelOptions): UseStoreModel<M[K]>;

package/dist/runtime/composables/view.d.ts

@@ -6,9 +6,8 @@ export interface UseStoreViewTrackOptions {
     debounce?: number;
     throttle?: number;
 }
-export interface UseStoreViewOptions<T> {
+export interface UseStoreViewOptions {
     proxy?: boolean;
-    default?: T;
 }
 export type UseStoreViewData<T> = {
     value: T;
@@ -25,9 +24,9 @@ export type UseStoreViewComputed<T> = {
 };
 export declare function useStoreView<V extends Record<string, ViewCall>, K extends keyof V & string, T = V[K] extends ComputedRef<infer R> ? R : unknown>(store: {
     view: V;
-}, key: K, options: UseStoreViewOptions<T> & {
+}, key: K, options: UseStoreViewOptions & {
     proxy: false;
 }): UseStoreViewComputed<T>;
 export declare function useStoreView<V extends Record<string, ViewCall>, K extends keyof V & string, T = V[K] extends ComputedRef<infer R> ? R : unknown>(store: {
     view: V;
-}, key: K, options?: UseStoreViewOptions<T>): UseStoreViewProxy<T>;
+}, key: K, options?: UseStoreViewOptions): UseStoreViewProxy<T>;

package/dist/runtime/composables/view.js

@@ -1,17 +1,5 @@
-import { computed, watch } from "vue";
+import { watch } from "vue";
 import { debounce, throttle, toReactiveProxy } from "../core/utils/base.js";
-function resolveDefault(view, defaultValue) {
-  if (defaultValue === void 0) {
-    return view;
-  }
-  return computed(() => {
-    const value = view.value;
-    if (value == null) {
-      return defaultValue;
-    }
-    return value;
-  });
-}
 function resolveData(source, proxy) {
   if (proxy !== false) {
     return toReactiveProxy(source);
@@ -22,7 +10,7 @@ export function useStoreView(store, key, options) {
   if (!store.view[key]) {
     throw new Error(`View "${key}" not found in store`);
   }
-  const source = resolveDefault(store.view[key], options?.default);
+  const source = store.view[key];
   const data = resolveData(source, options?.proxy);
   function resolveCallback(callback, callbackOptions) {
     if (callbackOptions?.debounce) {

package/dist/runtime/core/layers/model.js

@@ -1,26 +1,55 @@
 import { wrapBaseDefinition } from "../utils/base.js";
+import { resolveShapeIdentifier } from "../utils/shape.js";
 import {
-  ModelKind
+  ModelType,
+  ModelManyKind
 } from "../types/model.js";
 export function createModelFactory(config, logger) {
   function one(shape, options) {
+    function defaultResolver() {
+      if (options?.default) {
+        return options.default();
+      }
+      if ("defaults" in shape && typeof shape.defaults === "function") {
+        return shape.defaults();
+      }
+      return {};
+    }
     return wrapBaseDefinition({
       shape,
-      kind: ModelKind.OBJECT,
+      type: ModelType.ONE,
+      default: defaultResolver,
       options: {
-        identifier: config?.identifier,
-        ...options
+        pre: options?.pre,
+        post: options?.post
       },
       logger
     });
   }
   function many(shape, options) {
+    const kind = options?.kind ?? ModelManyKind.LIST;
+    let identifier;
+    if (kind === ModelManyKind.LIST) {
+      identifier = resolveShapeIdentifier(shape, options?.identifier, config?.identifier);
+    }
+    function defaultResolver() {
+      if (options?.default) {
+        return options.default();
+      }
+      if (kind === ModelManyKind.LIST) {
+        return [];
+      }
+      return {};
+    }
     return wrapBaseDefinition({
       shape,
-      kind: ModelKind.ARRAY,
+      type: ModelType.MANY,
+      kind,
+      identifier,
+      default: defaultResolver,
       options: {
-        identifier: config?.identifier,
-        ...options
+        pre: options?.pre,
+        post: options?.post
       },
       logger
     });

package/dist/runtime/core/store.d.ts

@@ -1,5 +1,6 @@
 import type { ModelDefinitions } from "./types/model.js";
 import type { ViewDefinitions } from "./types/view.js";
 import type { ActionDefinitions } from "./types/action.js";
+import type { ComposeDefinitions } from "./types/compose.js";
 import type { Store, StoreConfig } from "./types/store.js";
-export declare function createStore<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>>(config: StoreConfig<MD, VD, AD>): Store<MD, VD, AD>;
+export declare function createStore<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>, CD extends ComposeDefinitions = ComposeDefinitions>(config: StoreConfig<MD, VD, AD, CD>): Store<MD, VD, AD, CD>;

package/dist/runtime/core/store.js

@@ -5,29 +5,46 @@ import { createModelFactory } from "./layers/model.js";
 import { createViewFactory } from "./layers/view.js";
 import { createActionFactory } from "./layers/action.js";
 import { createStoreState, createStoreModel, createStoreView, createStoreAction } from "./utils/store.js";
+import { createStoreCompose } from "./utils/compose.js";
 export function createStore(config) {
-  const logger = createConsola({
-    level: runtimeConfig.logger,
-    defaults: {
-      tag: `harlemify:${config.name}`
-    }
-  });
-  logger.info("Creating store");
-  const modelFactory = createModelFactory(runtimeConfig.model, logger);
-  const viewFactory = createViewFactory(runtimeConfig.view, logger);
-  const actionFactory = createActionFactory(runtimeConfig.action, logger);
-  const modelDefinitions = config.model(modelFactory);
-  const viewDefinitions = config.view(viewFactory);
-  const actionDefinitions = config.action(actionFactory);
-  const state = createStoreState(modelDefinitions);
-  const source = createStoreSource(config.name, state);
-  const model = createStoreModel(modelDefinitions, source);
-  const view = createStoreView(viewDefinitions, source);
-  const action = createStoreAction(actionDefinitions, model, view);
-  logger.info("Store created");
-  return {
-    model,
-    view,
-    action
-  };
+  function init() {
+    const logger = createConsola({
+      level: runtimeConfig.logger,
+      defaults: {
+        tag: `harlemify:${config.name}`
+      }
+    });
+    logger.info("Creating store");
+    const modelFactory = createModelFactory(runtimeConfig.model, logger);
+    const viewFactory = createViewFactory(runtimeConfig.view, logger);
+    const actionFactory = createActionFactory(runtimeConfig.action, logger);
+    const modelDefinitions = config.model(modelFactory);
+    const viewDefinitions = config.view(viewFactory);
+    const actionDefinitions = config.action(actionFactory);
+    const state = createStoreState(modelDefinitions);
+    const source = createStoreSource(config.name, state);
+    const model = createStoreModel(modelDefinitions, source);
+    const view = createStoreView(viewDefinitions, source);
+    const action = createStoreAction(actionDefinitions, model, view);
+    const compose = createStoreCompose(config.compose, { model, view, action }, logger);
+    logger.info("Store created");
+    return {
+      model,
+      view,
+      action,
+      compose
+    };
+  }
+  if (config.lazy) {
+    let instance;
+    return new Proxy({}, {
+      get(_, prop) {
+        if (!instance) {
+          instance = init();
+        }
+        return instance[prop];
+      }
+    });
+  }
+  return init();
 }

package/dist/runtime/core/types/action.d.ts

@@ -1,6 +1,6 @@
 import type { ComputedRef, DeepReadonly, MaybeRefOrGetter, Ref } from "vue";
 import type { BaseDefinition } from "./base.js";
-import type { ModelDefinitions, ModelOneCommitOptions, ModelManyCommitOptions, StoreModel } from "./model.js";
+import type { ModelDefinitions, ModelDefinitionInfer, ModelOneCommitOptions, ModelManyCommitOptions, StoreModel } from "./model.js";
 import { ModelOneMode, ModelManyMode } from "./model.js";
 import type { ViewDefinitions, StoreView } from "./view.js";
 export interface RuntimeActionConfig {
@@ -22,6 +22,10 @@ export declare enum ActionConcurrent {
     CANCEL = "cancel",
     ALLOW = "allow"
 }
+export declare enum ActionType {
+    API = "api",
+    HANDLER = "handler"
+}
 export declare enum ActionApiMethod {
     GET = "GET",
     HEAD = "HEAD",
@@ -42,42 +46,49 @@ export interface ActionApiRequest<MD extends ModelDefinitions, VD extends ViewDe
     concurrent?: ActionConcurrent;
 }
 export type ActionApiRequestShortcut<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = Omit<ActionApiRequest<MD, VD>, "method">;
-export interface ActionApiCommit<MD extends ModelDefinitions> {
-    model: keyof MD;
+export interface ActionApiCommit<MD extends ModelDefinitions, K extends keyof MD = keyof MD> {
+    model: K;
     mode: ModelOneMode | ModelManyMode;
     value?: (data: unknown) => unknown;
     options?: ModelOneCommitOptions | ModelManyCommitOptions;
 }
-export interface ActionApiDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> extends BaseDefinition {
+export interface ActionApiDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, K extends keyof MD = keyof MD> extends BaseDefinition {
     request: ActionApiRequest<MD, VD>;
-    commit?: ActionApiCommit<MD>;
+    commit?: ActionApiCommit<MD, K>;
 }
-export interface ActionHandlerOptions {
-    payload?: unknown;
+export interface ActionHandlerOptions<P = unknown> {
+    payload?: P;
     concurrent?: ActionConcurrent;
 }
-export type ActionHandlerCallback<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, R = void> = (context: {
+export type ActionHandlerCallback<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, P = unknown, R = void> = (context: {
     model: StoreModel<MD>;
     view: StoreView<MD, VD>;
-    payload: unknown;
-}) => Promise<R>;
-export interface ActionHandlerDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, R = void> extends BaseDefinition {
-    callback: ActionHandlerCallback<MD, VD, R>;
-    options?: ActionHandlerOptions;
+    payload: P;
+}) => Promise<R> | R;
+export interface ActionHandlerDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, P = unknown, R = void> extends BaseDefinition {
+    callback: ActionHandlerCallback<MD, VD, P, R>;
+    options?: ActionHandlerOptions<P>;
 }
-export type ActionDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = ActionApiDefinition<MD, VD> | ActionHandlerDefinition<MD, VD, unknown>;
+export type ActionDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = ActionApiDefinition<MD, VD> | ActionHandlerDefinition<MD, VD, any, any>;
 export type ActionDefinitions<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = Record<string, ActionDefinition<MD, VD>>;
 export interface ActionApiFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
-    (request: ActionApiRequest<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
-    get(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
-    head(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
-    post(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
-    put(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
-    patch(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
-    delete(request: ActionApiRequestShortcut<MD, VD>, commit?: ActionApiCommit<MD>): ActionApiDefinition<MD, VD>;
+    <K extends keyof MD>(request: ActionApiRequest<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    (request: ActionApiRequest<MD, VD>): ActionApiDefinition<MD, VD>;
+    get<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    get(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    head<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    head(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    post<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    post(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    put<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    put(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    patch<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    patch(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
+    delete<K extends keyof MD>(request: ActionApiRequestShortcut<MD, VD>, commit: ActionApiCommit<MD, K>): ActionApiDefinition<MD, VD, K>;
+    delete(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD>;
 }
 export interface ActionHandlerFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
-    <R>(callback: ActionHandlerCallback<MD, VD, R>, options?: ActionHandlerOptions): ActionHandlerDefinition<MD, VD, R>;
+    <P = unknown, R = void>(callback: ActionHandlerCallback<MD, VD, P, R>, options?: ActionHandlerOptions<P>): ActionHandlerDefinition<MD, VD, P, R>;
 }
 export interface ActionFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
     api: ActionApiFactory<MD, VD>;
@@ -117,13 +128,13 @@ export interface ActionApiCallOptions extends ActionCallBaseOptions {
     transformer?: ActionCallTransformerOptions;
     commit?: ActionCallCommitOptions;
 }
-export interface ActionResolvedHandler<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
+export interface ActionResolvedHandler<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, P = unknown> {
     model: StoreModel<MD>;
     view: StoreView<MD, VD>;
-    payload: unknown;
+    payload: P;
 }
-export interface ActionHandlerCallOptions extends ActionCallBaseOptions {
-    payload?: unknown;
+export interface ActionHandlerCallOptions<P = unknown> extends ActionCallBaseOptions {
+    payload?: P;
 }
 export type ActionCallOptions = ActionApiCallOptions | ActionHandlerCallOptions;
 export interface ActionCallBase {
@@ -133,12 +144,14 @@ export interface ActionCallBase {
     reset: () => void;
 }
 export interface ActionApiCall<T = void> extends ActionCallBase {
+    readonly actionType: ActionType.API;
     (options?: ActionApiCallOptions): Promise<T>;
 }
-export interface ActionHandlerCall<T = void> extends ActionCallBase {
-    (options?: ActionHandlerCallOptions): Promise<T>;
+export interface ActionHandlerCall<P = unknown, T = void> extends ActionCallBase {
+    readonly actionType: ActionType.HANDLER;
+    (options?: ActionHandlerCallOptions<P>): Promise<T>;
 }
-export type ActionCall<T = void> = ActionApiCall<T> | ActionHandlerCall<T>;
+export type ActionCall<T = void> = ActionApiCall<T> | ActionHandlerCall<any, T>;
 export type StoreAction<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> = {
-    [K in keyof AD]: AD[K] extends ActionApiDefinition<MD, VD> ? ActionApiCall : AD[K] extends ActionHandlerDefinition<MD, VD, infer R> ? ActionHandlerCall<R> : never;
+    [K in keyof AD]: AD[K] extends ActionApiDefinition<MD, VD, infer MK> ? MK extends keyof MD ? ActionApiCall<ModelDefinitionInfer<MD, MK>> : ActionApiCall : AD[K] extends ActionHandlerDefinition<MD, VD, infer P, infer R> ? ActionHandlerCall<P, R> : never;
 };

package/dist/runtime/core/types/action.js

@@ -12,6 +12,11 @@ export var ActionConcurrent = /* @__PURE__ */ ((ActionConcurrent2) => {
   ActionConcurrent2["ALLOW"] = "allow";
   return ActionConcurrent2;
 })(ActionConcurrent || {});
+export var ActionType = /* @__PURE__ */ ((ActionType2) => {
+  ActionType2["API"] = "api";
+  ActionType2["HANDLER"] = "handler";
+  return ActionType2;
+})(ActionType || {});
 export var ActionApiMethod = /* @__PURE__ */ ((ActionApiMethod2) => {
   ActionApiMethod2["GET"] = "GET";
   ActionApiMethod2["HEAD"] = "HEAD";

package/dist/runtime/core/types/base.d.ts

@@ -1,6 +1,5 @@
 import type { ConsolaInstance } from "consola";
 export interface BaseDefinition {
-    readonly key: string;
+    key: string;
     logger?: ConsolaInstance;
-    setKey(key: string): void;
 }

package/dist/runtime/core/types/compose.d.ts

@@ -0,0 +1,18 @@
+import type { Ref } from "vue";
+import type { ModelDefinitions, StoreModel } from "./model.js";
+import type { ViewDefinitions, StoreView } from "./view.js";
+import type { ActionDefinitions, StoreAction } from "./action.js";
+export type ComposeCallback<A extends any[] = any[]> = (...args: A) => Promise<void> | void;
+export type ComposeDefinitions = Record<string, ComposeCallback<any[]>>;
+export interface ComposeContext<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, AD extends ActionDefinitions<MD, VD>> {
+    model: StoreModel<MD>;
+    view: StoreView<MD, VD>;
+    action: StoreAction<MD, VD, AD>;
+}
+export type ComposeCall<A extends any[] = any[]> = {
+    (...args: A): Promise<void>;
+    active: Readonly<Ref<boolean>>;
+};
+export type StoreCompose<CD extends ComposeDefinitions> = {
+    [K in keyof CD]: CD[K] extends ComposeCallback<infer A> ? ComposeCall<A> : never;
+};