@diphyx/harlemify 6.1.1 → 6.3.0

package/README.md

@@ -23,9 +23,11 @@ If you are an AI coding agent working on a project that uses `@diphyx/harlemify`
 ## Install
 
 ```bash
-npm install @diphyx/harlemify
+npm install @diphyx/harlemify zod
 ```
 
+> `zod` is a peer dependency — install it in your project.
+
 ```typescript
 // nuxt.config.ts
 export default defineNuxtConfig({

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": "^3.14.0 || ^4.0.0"
   },
-  "version": "6.1.1",
+  "version": "6.3.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

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

@@ -1,5 +1,5 @@
-import type { ConsolaInstance } from "consola";
+import type { Logger } from "../types/base.js";
 import type { ModelDefinitions } from "../types/model.js";
 import type { ViewDefinitions } from "../types/view.js";
 import { type RuntimeActionConfig, type ActionFactory } from "../types/action.js";
-export declare function createActionFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>>(config?: RuntimeActionConfig, logger?: ConsolaInstance): ActionFactory<MD, VD>;
+export declare function createActionFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>>(config?: RuntimeActionConfig, logger?: Logger): ActionFactory<MD, VD>;

package/dist/runtime/core/layers/model.d.ts

@@ -1,3 +1,3 @@
-import type { ConsolaInstance } from "consola";
+import type { Logger } from "../types/base.js";
 import { type RuntimeModelConfig, type ModelFactory } from "../types/model.js";
-export declare function createModelFactory(config?: RuntimeModelConfig, logger?: ConsolaInstance): ModelFactory;
+export declare function createModelFactory(config?: RuntimeModelConfig, logger?: Logger): ModelFactory;

package/dist/runtime/core/layers/view.d.ts

@@ -1,4 +1,4 @@
-import type { ConsolaInstance } from "consola";
+import type { Logger } from "../types/base.js";
 import type { ModelDefinitions } from "../types/model.js";
 import type { RuntimeViewConfig, ViewFactory } from "../types/view.js";
-export declare function createViewFactory<MD extends ModelDefinitions>(config?: RuntimeViewConfig, logger?: ConsolaInstance): ViewFactory<MD>;
+export declare function createViewFactory<MD extends ModelDefinitions>(config?: RuntimeViewConfig, logger?: Logger): ViewFactory<MD>;

package/dist/runtime/core/store.js

@@ -1,5 +1,4 @@
 import { effectScope } from "vue";
-import { createConsola } from "consola";
 import { createStore as createStoreSource } from "@harlem/core";
 import { runtimeConfig } from "../config.js";
 import { createModelFactory } from "./layers/model.js";
@@ -7,14 +6,10 @@ 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";
+import { createLogger } from "./utils/logger.js";
 export function createStore(config) {
   function init() {
-    const logger = createConsola({
-      level: runtimeConfig.logger,
-      defaults: {
-        tag: `harlemify:${config.name}`
-      }
-    });
+    const logger = createLogger(`harlemify:${config.name}`, runtimeConfig.logger);
     logger.info("Creating store");
     const modelFactory = createModelFactory(runtimeConfig.model, logger);
     const viewFactory = createViewFactory(runtimeConfig.view, logger);

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

@@ -46,16 +46,26 @@ 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, K extends keyof MD = keyof MD> {
+export interface ActionApiCommitContext<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
+    request: Readonly<{
+        url: string;
+        method: ActionApiMethod;
+        headers: Readonly<Record<string, string>>;
+        query: Readonly<Record<string, unknown>>;
+        body: unknown;
+    }>;
+    view: DeepReadonly<StoreView<MD, VD>>;
+}
+export interface ActionApiCommit<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, K extends keyof MD = keyof MD> {
     model: K;
     mode: ModelOneMode | ModelManyMode;
-    value?: (data: unknown) => unknown;
+    transform?: (data: unknown, context: ActionApiCommitContext<MD, VD>) => unknown;
     options?: ModelOneCommitOptions | ModelManyCommitOptions;
 }
-export type ActionApiCommitReturn<MD extends ModelDefinitions, C extends readonly ActionApiCommit<MD>[]> = C extends readonly [] ? unknown : {
+export type ActionApiCommitReturn<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, C extends readonly ActionApiCommit<MD, VD>[]> = C extends readonly [] ? unknown : {
     [E in C[number] as E["model"] & string]: E["model"] extends keyof MD ? ModelDefinitionInfer<MD, E["model"]> : never;
 };
-export interface ActionApiDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, C extends readonly ActionApiCommit<MD>[] = readonly ActionApiCommit<MD>[]> extends BaseDefinition {
+export interface ActionApiDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>, C extends readonly ActionApiCommit<MD, VD>[] = readonly ActionApiCommit<MD, VD>[]> extends BaseDefinition {
     request: ActionApiRequest<MD, VD>;
     commits: C;
 }
@@ -74,25 +84,25 @@ export interface ActionHandlerDefinition<MD extends ModelDefinitions, VD extends
 }
 export type ActionDefinition<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = ActionApiDefinition<MD, VD, any> | ActionHandlerDefinition<MD, VD, any, any>;
 export type ActionDefinitions<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = Record<string, ActionDefinition<MD, VD>>;
-type ActionApiCommitTuple<MD extends ModelDefinitions> = readonly [
-    ActionApiCommit<MD, keyof MD>,
-    ...ActionApiCommit<MD, keyof MD>[]
+type ActionApiCommitTuple<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> = readonly [
+    ActionApiCommit<MD, VD, keyof MD>,
+    ...ActionApiCommit<MD, VD, keyof MD>[]
 ];
 export interface ActionApiFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
     (request: ActionApiRequest<MD, VD>): ActionApiDefinition<MD, VD, []>;
-    <const C extends ActionApiCommitTuple<MD>>(request: ActionApiRequest<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
+    <const C extends ActionApiCommitTuple<MD, VD>>(request: ActionApiRequest<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
     get(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD, []>;
-    get<const C extends ActionApiCommitTuple<MD>>(request: ActionApiRequestShortcut<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
+    get<const C extends ActionApiCommitTuple<MD, VD>>(request: ActionApiRequestShortcut<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
     head(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD, []>;
-    head<const C extends ActionApiCommitTuple<MD>>(request: ActionApiRequestShortcut<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
+    head<const C extends ActionApiCommitTuple<MD, VD>>(request: ActionApiRequestShortcut<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
     post(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD, []>;
-    post<const C extends ActionApiCommitTuple<MD>>(request: ActionApiRequestShortcut<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
+    post<const C extends ActionApiCommitTuple<MD, VD>>(request: ActionApiRequestShortcut<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
     put(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD, []>;
-    put<const C extends ActionApiCommitTuple<MD>>(request: ActionApiRequestShortcut<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
+    put<const C extends ActionApiCommitTuple<MD, VD>>(request: ActionApiRequestShortcut<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
     patch(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD, []>;
-    patch<const C extends ActionApiCommitTuple<MD>>(request: ActionApiRequestShortcut<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
+    patch<const C extends ActionApiCommitTuple<MD, VD>>(request: ActionApiRequestShortcut<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
     delete(request: ActionApiRequestShortcut<MD, VD>): ActionApiDefinition<MD, VD, []>;
-    delete<const C extends ActionApiCommitTuple<MD>>(request: ActionApiRequestShortcut<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
+    delete<const C extends ActionApiCommitTuple<MD, VD>>(request: ActionApiRequestShortcut<MD, VD>, ...commits: C): ActionApiDefinition<MD, VD, C>;
 }
 export interface ActionHandlerFactory<MD extends ModelDefinitions, VD extends ViewDefinitions<MD>> {
     <P = unknown, R = void>(callback: ActionHandlerCallback<MD, VD, P, R>, options?: ActionHandlerOptions<P>): ActionHandlerDefinition<MD, VD, P, R>;
@@ -160,6 +170,6 @@ export interface ActionHandlerCall<P = unknown, T = void> extends ActionCallBase
 }
 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, infer C> ? C extends readonly ActionApiCommit<MD>[] ? ActionApiCall<ActionApiCommitReturn<MD, C>> : ActionApiCall : AD[K] extends ActionHandlerDefinition<MD, VD, infer P, infer R> ? ActionHandlerCall<P, R> : never;
+    [K in keyof AD]: AD[K] extends ActionApiDefinition<MD, VD, infer C> ? C extends readonly ActionApiCommit<MD, VD>[] ? ActionApiCall<ActionApiCommitReturn<MD, VD, C>> : ActionApiCall : AD[K] extends ActionHandlerDefinition<MD, VD, infer P, infer R> ? ActionHandlerCall<P, R> : never;
 };
 export {};

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

@@ -1,5 +1,10 @@
-import type { ConsolaInstance } from "consola";
+export interface Logger {
+    info(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
 export interface BaseDefinition {
     key: string;
-    logger?: ConsolaInstance;
+    logger?: Logger;
 }

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

@@ -31,15 +31,19 @@ export type ModelDefaultIdentifier<S extends Shape> = "id" extends keyof S ? "id
 export type AtLeastOne<S extends Shape> = {
     [K in keyof S]: Pick<S, K>;
 }[keyof S];
-export interface ModelDefinitionOptions {
-    pre?: () => void;
-    post?: () => void;
+export type ModelHookContext<T> = {
+    mode: ModelOneMode | ModelManyMode;
+    state: T;
+};
+export interface ModelDefinitionOptions<T = unknown> {
+    pre?: (context: ModelHookContext<T>) => void;
+    post?: (context: ModelHookContext<T>) => void;
 }
 export interface ModelOneDefinition<S extends Shape> extends BaseDefinition {
     shape: ShapeType<S>;
     type: ModelType.ONE;
     default: () => S;
-    options?: ModelDefinitionOptions;
+    options?: ModelDefinitionOptions<S>;
 }
 export interface ModelManyDefinition<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST> extends BaseDefinition {
     shape: ShapeType<S>;
@@ -47,7 +51,7 @@ export interface ModelManyDefinition<S extends Shape, I extends keyof S = ModelD
     kind: T;
     identifier: [T] extends [ModelManyKind.LIST] ? I : never;
     default: () => [T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]>;
-    options?: ModelDefinitionOptions;
+    options?: ModelDefinitionOptions<[T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]>>;
 }
 export type ModelDefinition<S extends Shape> = ModelOneDefinition<S> | ModelManyDefinition<S, any, any>;
 export type ModelDefinitions = Record<string, ModelDefinition<any>>;
@@ -59,10 +63,10 @@ export type ModelDefinitionsInfer<MD extends ModelDefinitions> = {
     [K in keyof MD]: ModelDefinitionInfer<MD, K>;
 };
 export interface ModelFactory {
-    one<S extends Shape>(shape: ShapeType<S>, options?: ModelDefinitionOptions & {
+    one<S extends Shape>(shape: ShapeType<S>, options?: ModelDefinitionOptions<S> & {
         default?: () => S;
     }): ModelOneDefinition<S>;
-    many<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST>(shape: ShapeType<S>, options?: ModelDefinitionOptions & {
+    many<S extends Shape, I extends keyof S = ModelDefaultIdentifier<S>, T extends ModelManyKind = ModelManyKind.LIST>(shape: ShapeType<S>, options?: ModelDefinitionOptions<[T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]>> & {
         kind?: T;
         identifier?: [T] extends [ModelManyKind.LIST] ? I : never;
         default?: () => [T] extends [ModelManyKind.LIST] ? S[] : Record<string, S[]>;

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

@@ -1,4 +1,3 @@
-import { defu } from "defu";
 import { ref, computed, readonly, toValue, nextTick } from "vue";
 import {
   ActionApiMethod,
@@ -6,7 +5,7 @@ import {
   ActionStatus,
   ActionConcurrent
 } from "../types/action.js";
-import { trimStart, trimEnd, isEmptyRecord, isPlainObject } from "./base.js";
+import { trimStart, trimEnd, isEmptyRecord, isPlainObject, merge } from "./base.js";
 import {
   ActionApiError,
   ActionHandlerError,
@@ -38,12 +37,12 @@ function resolveApiUrl(definition, view, options) {
 function resolveApiHeaders(definition, view, options) {
   const initial = resolveValue(definition.request.headers, view, {});
   const custom = options?.headers ?? {};
-  return defu(custom, initial);
+  return merge(custom, initial);
 }
 function resolveApiQuery(definition, view, options) {
   const initial = resolveValue(definition.request.query, view, {});
   const custom = options?.query ?? {};
-  return defu(custom, initial);
+  return merge(custom, initial);
 }
 function resolveApiBody(definition, view, target, options) {
   if (definition.request.method === ActionApiMethod.GET || definition.request.method === ActionApiMethod.HEAD) {
@@ -51,7 +50,7 @@ function resolveApiBody(definition, view, target, options) {
   }
   const initial = resolveValue(definition.request.body, view, {});
   const custom = options?.body ?? {};
-  const body = defu(custom, initial);
+  const body = merge(custom, initial);
   if (!isPlainObject(body)) {
     return body;
   }
@@ -97,9 +96,9 @@ function resolveCommitMode(commit, options) {
   }
   return commit.mode;
 }
-function resolveCommitValue(commit, data) {
-  if (typeof commit.value === "function") {
-    return commit.value(data);
+function resolveCommitTransform(commit, data, context) {
+  if (typeof commit.transform === "function") {
+    return commit.transform(data, context);
   }
   return data;
 }
@@ -177,7 +176,7 @@ async function executeHandler(definition, handler) {
     throw handlerError;
   }
 }
-function executeCommit(definition, model, data, options) {
+function executeCommit(definition, model, data, context, options) {
   const commits = definition.commits;
   if (!commits || commits.length === 0) {
     return data;
@@ -192,7 +191,7 @@ function executeCommit(definition, model, data, options) {
         });
       }
       const mode = resolveCommitMode(commit, options);
-      let value = resolveCommitValue(commit, data);
+      let value = resolveCommitTransform(commit, data, context);
       if (!isEmptyRecord(target.aliases())) {
         value = resolveAliasInbound(value, target.aliases());
       }
@@ -296,7 +295,11 @@ export function createAction(definition, model, view) {
             },
             options
           );
-          data = executeCommit(definition, model, response, options);
+          const context = {
+            request: { url, method, headers, query, body },
+            view
+          };
+          data = executeCommit(definition, model, response, context, options);
         } else if (isHandlerDefinition(definition)) {
           const payload = resolveHandlerPayload(definition, options);
           data = await executeHandler(definition, {

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

@@ -1,4 +1,5 @@
 import type { BaseDefinition } from "../types/base.js";
+export declare function snapshot<T>(value: T): T;
 export declare function wrapBaseDefinition<T extends Omit<BaseDefinition, "key">>(definition: T): T & BaseDefinition;
 export declare function trimStart(value: string, char: string): string;
 export declare function trimEnd(value: string, char: string): string;
@@ -6,5 +7,6 @@ export declare function ensureArray<T>(value: T | T[]): T[];
 export declare function isObject(value: unknown): value is object;
 export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 export declare function isEmptyRecord(record: Record<string, unknown> | undefined): record is undefined;
+export declare function merge<T>(priority: unknown, base: T): T;
 export declare function debounce<T extends (...args: any[]) => any>(callback: T, delay: number): T;
 export declare function throttle<T extends (...args: any[]) => any>(callback: T, delay: number): T;

package/dist/runtime/core/utils/base.js

@@ -1,3 +1,7 @@
+import { objectClone, typeIsObject } from "@harlem/utilities";
+export function snapshot(value) {
+  return objectClone(value);
+}
 export function wrapBaseDefinition(definition) {
   let key = "";
   return Object.defineProperties(definition, {
@@ -23,16 +27,10 @@ export function ensureArray(value) {
   return Array.isArray(value) ? value : [value];
 }
 export function isObject(value) {
-  return value != null && typeof value === "object";
+  return typeIsObject(value);
 }
 export function isPlainObject(value) {
-  if (!isObject(value)) {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    return false;
-  }
-  return true;
+  return isObject(value);
 }
 export function isEmptyRecord(record) {
   if (!record) {
@@ -43,6 +41,20 @@ export function isEmptyRecord(record) {
   }
   return false;
 }
+export function merge(priority, base) {
+  if (!isPlainObject(priority) || !isPlainObject(base)) {
+    return priority;
+  }
+  const output = { ...base };
+  for (const key of Object.keys(priority)) {
+    const value = priority[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    output[key] = merge(value, output[key]);
+  }
+  return output;
+}
 export function debounce(callback, delay) {
   let timer = null;
   return (...args) => {

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

@@ -1,3 +1,3 @@
-import type { ConsolaInstance } from "consola";
+import type { Logger } from "../types/base.js";
 import type { ComposeDefinitions, StoreCompose } from "../types/compose.js";
-export declare function createStoreCompose<CD extends ComposeDefinitions>(composeConfig: ((...args: any[]) => CD) | undefined, context: Record<string, unknown>, logger?: ConsolaInstance): StoreCompose<CD>;
+export declare function createStoreCompose<CD extends ComposeDefinitions>(composeConfig: ((...args: any[]) => CD) | undefined, context: Record<string, unknown>, logger?: Logger): StoreCompose<CD>;

package/dist/runtime/core/utils/logger.d.ts

@@ -0,0 +1,2 @@
+import type { Logger } from "../types/base.js";
+export declare function createLogger(tag: string, level?: number): Logger;

package/dist/runtime/core/utils/logger.js

@@ -0,0 +1,22 @@
+const LEVELS = {
+  error: 0,
+  warn: 1,
+  info: 3,
+  debug: 4
+};
+export function createLogger(tag, level = -999) {
+  function report(method, sink) {
+    return (message, ...args) => {
+      if (LEVELS[method] > level) {
+        return;
+      }
+      sink(`[${tag}]`, message, ...args);
+    };
+  }
+  return {
+    info: report("info", console.info),
+    debug: report("debug", console.debug),
+    warn: report("warn", console.warn),
+    error: report("error", console.error)
+  };
+}

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

@@ -1,5 +1,4 @@
-import { defu } from "defu";
-import { ensureArray } from "./base.js";
+import { ensureArray, snapshot, merge } from "./base.js";
 import { resolveShapeAliases } from "./shape.js";
 import {
   ModelType,
@@ -8,12 +7,17 @@ import {
   ModelManyMode,
   ModelSilent
 } from "../types/model.js";
-function callHook(definition, hook, silent) {
+function callHook(definition, source, hook, mode, silent) {
   if (silent === true || silent === hook) {
     return;
   }
+  const handler = definition.options?.[hook];
+  if (!handler) {
+    return;
+  }
   try {
-    definition.options?.[hook]?.();
+    const state = snapshot(source.state[definition.key]);
+    handler({ mode, state });
   } catch (error) {
     definition.logger?.error(`Model ${hook} hook error`, {
       model: definition.key,
@@ -21,14 +25,14 @@ function callHook(definition, hook, silent) {
     });
   }
 }
-function wrapOperation(definition, mutation, operation, silent) {
+function wrapOperation(definition, source, mode, operation, silent) {
   definition.logger?.debug("Model mutation", {
     model: definition.key,
-    mutation
+    mutation: mode
   });
-  callHook(definition, ModelSilent.PRE, silent);
+  callHook(definition, source, ModelSilent.PRE, mode, silent);
   operation();
-  callHook(definition, ModelSilent.POST, silent);
+  callHook(definition, source, ModelSilent.POST, mode, silent);
 }
 function createOneCommit(definition, source) {
   const setOperation = source.mutation(`${definition.key}:set`, (state, { payload }) => {
@@ -39,7 +43,7 @@ function createOneCommit(definition, source) {
   });
   const patchOperation = source.mutation(`${definition.key}:patch`, (state, { payload, options }) => {
     if (options?.deep) {
-      state[definition.key] = defu(payload, state[definition.key]);
+      state[definition.key] = merge(payload, state[definition.key]);
       return;
     }
     state[definition.key] = {
@@ -49,13 +53,19 @@ function createOneCommit(definition, source) {
   });
   return {
     set(payload, options) {
-      wrapOperation(definition, "set", () => setOperation({ payload }), options?.silent);
+      wrapOperation(definition, source, ModelOneMode.SET, () => setOperation({ payload }), options?.silent);
     },
     reset(options) {
-      wrapOperation(definition, "reset", () => resetOperation(), options?.silent);
+      wrapOperation(definition, source, ModelOneMode.RESET, () => resetOperation(), options?.silent);
     },
     patch(payload, options) {
-      wrapOperation(definition, "patch", () => patchOperation({ payload, options }), options?.silent);
+      wrapOperation(
+        definition,
+        source,
+        ModelOneMode.PATCH,
+        () => patchOperation({ payload, options }),
+        options?.silent
+      );
     }
   };
 }
@@ -77,7 +87,7 @@ function createManyListCommit(definition, source) {
         return item;
       }
       if (options?.deep) {
-        return defu(found, item);
+        return merge(found, item);
       }
       return {
         ...item,
@@ -120,19 +130,37 @@ function createManyListCommit(definition, source) {
   });
   return {
     set(payload, options) {
-      wrapOperation(definition, "set", () => setOperation({ payload }), options?.silent);
+      wrapOperation(definition, source, ModelManyMode.SET, () => setOperation({ payload }), options?.silent);
     },
     reset(options) {
-      wrapOperation(definition, "reset", () => resetOperation(), options?.silent);
+      wrapOperation(definition, source, ModelManyMode.RESET, () => resetOperation(), options?.silent);
     },
     patch(payload, options) {
-      wrapOperation(definition, "patch", () => patchOperation({ payload, options }), options?.silent);
+      wrapOperation(
+        definition,
+        source,
+        ModelManyMode.PATCH,
+        () => patchOperation({ payload, options }),
+        options?.silent
+      );
     },
     remove(payload, options) {
-      wrapOperation(definition, "remove", () => removeOperation({ payload }), options?.silent);
+      wrapOperation(
+        definition,
+        source,
+        ModelManyMode.REMOVE,
+        () => removeOperation({ payload }),
+        options?.silent
+      );
     },
     add(payload, options) {
-      wrapOperation(definition, "add", () => addOperation({ payload, options }), options?.silent);
+      wrapOperation(
+        definition,
+        source,
+        ModelManyMode.ADD,
+        () => addOperation({ payload, options }),
+        options?.silent
+      );
     }
   };
 }
@@ -145,7 +173,7 @@ function createManyRecordCommit(definition, source) {
   });
   const patchOperation = source.mutation(`${definition.key}:patch`, (state, { payload, options }) => {
     if (options?.deep) {
-      state[definition.key] = defu(payload, state[definition.key]);
+      state[definition.key] = merge(payload, state[definition.key]);
       return;
     }
     state[definition.key] = {
@@ -170,19 +198,31 @@ function createManyRecordCommit(definition, source) {
   });
   return {
     set(payload, options) {
-      wrapOperation(definition, "set", () => setOperation({ payload }), options?.silent);
+      wrapOperation(definition, source, ModelManyMode.SET, () => setOperation({ payload }), options?.silent);
     },
     reset(options) {
-      wrapOperation(definition, "reset", () => resetOperation(), options?.silent);
+      wrapOperation(definition, source, ModelManyMode.RESET, () => resetOperation(), options?.silent);
     },
     patch(payload, options) {
-      wrapOperation(definition, "patch", () => patchOperation({ payload, options }), options?.silent);
+      wrapOperation(
+        definition,
+        source,
+        ModelManyMode.PATCH,
+        () => patchOperation({ payload, options }),
+        options?.silent
+      );
     },
     remove(payload, options) {
-      wrapOperation(definition, "remove", () => removeOperation({ payload }), options?.silent);
+      wrapOperation(
+        definition,
+        source,
+        ModelManyMode.REMOVE,
+        () => removeOperation({ payload }),
+        options?.silent
+      );
     },
     add(payload, options) {
-      wrapOperation(definition, "add", () => addOperation({ payload }), options?.silent);
+      wrapOperation(definition, source, ModelManyMode.ADD, () => addOperation({ payload }), options?.silent);
     }
   };
 }

package/dist/runtime/core/utils/shape.js

@@ -1,6 +1,5 @@
-import { defu } from "defu";
 import { z } from "zod";
-import { isPlainObject, isEmptyRecord } from "./base.js";
+import { isPlainObject, isEmptyRecord, merge } from "./base.js";
 function resolveShapeFields(shape) {
   if (!("shape" in shape) || typeof shape.shape !== "object" || !shape.shape) {
     return void 0;
@@ -183,7 +182,7 @@ export function decorateShape(object) {
     defaults(overrides) {
       const zero = resolveZeroValues(object);
       if (overrides) {
-        return defu(overrides, zero);
+        return merge(overrides, zero);
       }
       return zero;
     }

package/dist/runtime/core/utils/view.js

@@ -1,10 +1,11 @@
+import { snapshot } from "./base.js";
 import { ViewClone } from "../types/view.js";
 function resolveClonedValue(definition, value) {
   if (!definition.options?.clone) {
     return value;
   }
   if (definition.options.clone === ViewClone.DEEP) {
-    return JSON.parse(JSON.stringify(value));
+    return snapshot(value);
   }
   if (Array.isArray(value)) {
     return [...value];

package/dist/runtime/index.d.ts

@@ -7,8 +7,8 @@ export type { ModelOneCommitOptions, ModelManyCommitOptions } from "./core/types
 export { ViewClone } from "./core/types/view.js";
 export type { ViewDefinitionOptions } from "./core/types/view.js";
 export { ActionStatus, ActionConcurrent, ActionType, ActionApiMethod } from "./core/types/action.js";
-export type { ActionCall, ActionApiCall, ActionHandlerCall, ActionCallOptions, ActionCallBaseOptions, ActionApiCallOptions, ActionHandlerCallOptions, ActionCallTransformerOptions, ActionCallBindOptions, ActionCallCommitOptions, ActionHandlerOptions, ActionResolvedApi, } from "./core/types/action.js";
-export { ActionApiError, ActionHandlerError, ActionCommitError, ActionConcurrentError, isError, toError } from "./core/utils/error.js";
+export type { ActionCall, ActionApiCall, ActionApiCommitContext, ActionHandlerCall, ActionCallOptions, ActionCallBaseOptions, ActionApiCallOptions, ActionHandlerCallOptions, ActionCallTransformerOptions, ActionCallBindOptions, ActionCallCommitOptions, ActionHandlerOptions, ActionResolvedApi, } from "./core/types/action.js";
+export { ActionApiError, ActionHandlerError, ActionCommitError, ActionConcurrentError, isError, toError, } from "./core/utils/error.js";
 export type { ComposeCallback, ComposeCall, ComposeDefinitions, ComposeContext, StoreCompose, } from "./core/types/compose.js";
 export { useStoreCompose } from "./composables/compose.js";
 export type { UseStoreCompose } from "./composables/compose.js";

package/dist/runtime/index.js

@@ -3,7 +3,14 @@ export { shape } from "./core/layers/shape.js";
 export { ModelType, ModelManyKind, ModelOneMode, ModelManyMode, ModelSilent } from "./core/types/model.js";
 export { ViewClone } from "./core/types/view.js";
 export { ActionStatus, ActionConcurrent, ActionType, ActionApiMethod } from "./core/types/action.js";
-export { ActionApiError, ActionHandlerError, ActionCommitError, ActionConcurrentError, isError, toError } from "./core/utils/error.js";
+export {
+  ActionApiError,
+  ActionHandlerError,
+  ActionCommitError,
+  ActionConcurrentError,
+  isError,
+  toError
+} from "./core/utils/error.js";
 export { useStoreCompose } from "./composables/compose.js";
 export { useIsolatedActionStatus, useIsolatedActionError, useStoreAction } from "./composables/action.js";
 export { useStoreModel } from "./composables/model.js";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@diphyx/harlemify",
-    "version": "6.1.1",
+    "version": "6.3.0",
     "description": "API state management for Nuxt powered by Harlem",
     "keywords": [
         "nuxt",
@@ -45,29 +45,33 @@
         "prepare": "pnpm nuxt prepare && pnpm nuxt prepare playground",
         "dev": "pnpm nuxt dev playground",
         "build": "nuxt-module-build build",
-        "lint": "eslint . --fix",
+        "lint": "eslint ./ --fix",
+        "format": "prettier ./ --write",
         "test": "vitest run",
         "test:e2e": "playwright test"
     },
+    "peerDependencies": {
+        "zod": "^4.4.3"
+    },
     "dependencies": {
         "@harlem/core": "^3.1.8",
-        "@nuxt/kit": "^3.14.0 || ^4.0.0",
-        "consola": "^3.4.2",
-        "defu": "^6.1.4",
-        "zod": "^4.3.6"
+        "@harlem/utilities": "^3.1.8",
+        "@nuxt/kit": "^4.4.6"
     },
     "devDependencies": {
         "@nuxt/eslint-config": "^0.6.2",
         "@nuxt/module-builder": "^0.8.4",
-        "@nuxt/schema": "^4.3.1",
+        "@nuxt/schema": "^4.4.6",
         "@nuxt/test-utils": "^3.23.0",
-        "@playwright/test": "^1.58.2",
-        "@types/node": "^22.19.11",
+        "@playwright/test": "^1.60.0",
+        "@types/node": "^22.19.19",
         "@vitest/coverage-v8": "^2.1.9",
-        "eslint": "^9.39.2",
-        "nuxt": "^4.3.1",
+        "eslint": "^9.39.4",
+        "nuxt": "^4.4.6",
+        "prettier": "^3.8.3",
         "typescript": "^5.9.3",
         "vitest": "^2.1.9",
-        "vue": "^3.5.28"
+        "vue": "^3.5.35",
+        "zod": "^4.4.3"
     }
 }