@gialicus/smart-object 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-06-27
+
+### Added
+
+- `SmartObject(schema)` factory: typed getters and `set*` methods generated from a Zod object schema
+- RFC 6902 operation log (`operations`) for every validated change
+- `clearOperations()` to reset the audit trail without rolling back state
+- `fromOperations(initial, operations)` static method for deterministic replay
+- Exported types: `Operation`, `SetMethods`, `OperationsAccessor`, `SmartObjectConstructor`, `SmartObjectInstance`
+
+[1.0.0]: https://github.com/gialicus/smart-object/releases/tag/v1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026, Gia Licoletta
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# @gialicus/smart-object
+
+Typed TypeScript objects backed by Zod schemas, with an RFC 6902 operation log for every validated change. Use them when you need mutable, type-safe state plus a portable delta trail for audit, sync, or replay — without bolting on a separate change-tracking layer.
+
+## Installation
+
+```bash
+npm install @gialicus/smart-object zod
+```
+
+Dependencies: [Zod](https://zod.dev) (peer dependency — schema validation) and [fast-json-patch](https://github.com/Starcounter-Jack/JSON-Patch) (RFC 6902 patch application, bundled).
+
+## Usage
+
+```typescript
+import z from "zod";
+import { SmartObject } from "@gialicus/smart-object";
+
+const Person = SmartObject(z.object({
+    name: z.string(),
+    age: z.number(),
+}));
+
+const person = new Person({ name: "Mario", age: 30 });
+
+// Reads expose validated state without side effects
+console.log(person.name); // "Mario"
+
+// Writes validate first, then append patches to person.operations
+person.setName("Luigi");
+person.setAge(31);
+
+console.log(person.operations);
+// [
+//   { op: "replace", path: "/name", value: "Luigi" },
+//   { op: "replace", path: "/age", value: 31 },
+// ]
+
+person.setName("Luigi"); // Unchanged value — no operation added (keeps sync payloads minimal)
+
+person.clearOperations(); // Drops the audit trail after persist/sync; state is unchanged
+
+// Initial construction is the replay baseline — it never emits operations
+console.log(new Person({ name: "Mario", age: 30 }).operations); // []
+
+// Reconstruct from baseline + accumulated deltas
+const initial = { name: "Mario", age: 30 };
+const person2 = Person.fromOperations(initial, [...person.operations]);
+```
+
+## API
+
+### `SmartObject(schema)`
+
+Factory that accepts a `z.object(...)` and returns an instantiable class.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `schema` | `z.ZodObject` | Zod schema defining the object shape |
+
+**Members generated for each schema field `foo`:**
+
+| Member | Type | Description |
+|--------|------|-------------|
+| `foo` | getter | Exposes the current validated field value |
+| `setFoo(value)` | `(value: T) => void` | Validates, updates state, and records patches only when the value actually changes |
+
+**Instance members:**
+
+| Member | Type | Description |
+|--------|------|-------------|
+| `operations` | `readonly Operation[]` | Chronological RFC 6902 patch log |
+| `clearOperations()` | `() => void` | Clears the patch log without rolling back state |
+
+`set*` method names follow camelCase with the field name capitalized (`name` → `setName`, `address` → `setAddress`).
+
+**Static members:**
+
+| Member | Type | Description |
+|--------|------|-------------|
+| `fromOperations(initial, operations)` | `(initial, Operation[]) => Instance` | Builds an instance from a baseline, replays operations, and copies them into the accumulator |
+
+### `Operation`
+
+RFC 6902 operation emitted by [fast-json-patch](https://github.com/Starcounter-Jack/JSON-Patch) when a field actually changes. Examples:
+
+```typescript
+{ op: "replace", path: "/name", value: "Luigi" }
+{ op: "add", path: "/age", value: 30 }
+```
+
+### Exported types
+
+- `Operation` — JSON Patch operation (re-export from `fast-json-patch`)
+- `SetMethods<T>` — mapped type of inferred `set*` methods for shape `T`
+- `OperationsAccessor` — `operations` and `clearOperations()`
+- `SmartObjectConstructor<T>` — constructor type including `fromOperations`
+
+## Design rationale
+
+1. **Construction** — `new Person(initial)` validates and seeds internal state without emitting operations, because that snapshot is the baseline every later patch is measured against.
+2. **Validation** — Each write is validated against the schema so the operation log only records structurally valid changes.
+3. **No-op writes** — Identical values are skipped to keep the patch log minimal and suitable for network sync.
+4. **Patch-based updates** — Changes are expressed as RFC 6902 operations so deltas are standard, composable, and replayable.
+5. **Operation accumulation** — Patches from `compare` are appended in order, preserving causality for audit and replay.
+6. **Replay** — `fromOperations(initial, operations)` requires the same baseline used when the operations were produced, enabling deterministic reconstruction on another client or after persistence.
+
+- `SmartObjectInstance<T>` — full instance type (getters + set* + operations)
+
+## Full example
+
+See [`examples/person.ts`](examples/person.ts) for a demo with primitives, nested objects, and arrays.
+
+## Project structure
+
+```
+smart-object/
+├── src/
+│   ├── index.ts          # Public API barrel export
+│   ├── smart-object.ts   # SmartObject factory
+│   └── types.ts          # Operation and inferred types
+├── examples/
+│   └── person.ts         # Usage demo
+├── tests/
+│   └── smart-object.test.ts
+└── dist/                 # Build output (generated)
+```

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { SmartObject } from "./smart-object.js";
+export type { AllKeys, Operation, OperationsAccessor, SetMethods, SetMethodsUnion, SmartObjectConstructor, SmartObjectInstance, SmartObjectSchema, UnionDataShape, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EACV,OAAO,EACP,SAAS,EACT,kBAAkB,EAClB,UAAU,EACV,eAAe,EACf,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,cAAc,GACf,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export { SmartObject } from "./smart-object.js";

package/dist/smart-object.d.ts

@@ -0,0 +1,36 @@
+import type { z } from "zod";
+import type { SmartObjectConstructor } from "./types.js";
+/**
+ * Builds a typed SmartObject class from a Zod schema.
+ *
+ * The goal is to offer mutable, schema-validated objects that also produce an
+ * RFC 6902 operation log — useful for audit trails, client/server sync, and
+ * event replay without a separate change-tracking layer.
+ *
+ * Zod is the single source of truth: the same schema drives runtime validation,
+ * TypeScript inference, and the dynamically generated read/write API.
+ *
+ * Initial construction does not emit operations because that state is the baseline
+ * every subsequent patch is measured against.
+ *
+ * @typeParam T - Zod object or union-of-objects schema that defines the instance shape
+ * @param zodSchema - A `z.object({ ... })`, `z.union([...])`, or `z.discriminatedUnion(...)` schema
+ * @returns An instantiable class with types inferred from the schema
+ *
+ * @example
+ * ```typescript
+ * const Person = SmartObject(z.object({
+ *     name: z.string(),
+ *     age: z.number(),
+ * }));
+ *
+ * const person = new Person({ name: "Mario", age: 30 });
+ * person.setName("Luigi");
+ * // Only actual changes become operations — suitable for sync payloads
+ * console.log(person.operations); // [{ op: "replace", path: "/name", value: "Luigi" }]
+ * ```
+ */
+export declare function SmartObject<T extends z.ZodObject>(zodSchema: T): SmartObjectConstructor<T>;
+export declare function SmartObject<T extends z.ZodDiscriminatedUnion>(zodSchema: T): SmartObjectConstructor<T>;
+export declare function SmartObject<T extends z.ZodUnion>(zodSchema: T): SmartObjectConstructor<T>;
+//# sourceMappingURL=smart-object.d.ts.map

package/dist/smart-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-object.d.ts","sourceRoot":"","sources":["../src/smart-object.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,sBAAsB,EAA0C,MAAM,YAAY,CAAC;AAsMjG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;AAC5F,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,qBAAqB,EAC3D,SAAS,EAAE,CAAC,GACX,sBAAsB,CAAC,CAAC,CAAC,CAAC;AAC7B,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC"}

package/dist/smart-object.js

@@ -0,0 +1,157 @@
+import jsonPatch from "fast-json-patch";
+const { applyPatch, compare, deepClone } = jsonPatch;
+function isZodObject(schema) {
+    return (typeof schema === "object" &&
+        schema !== null &&
+        "_zod" in schema &&
+        schema._zod.def.type === "object");
+}
+function isZodUnionRoot(schema) {
+    return schema._zod.def.type === "union";
+}
+function isZodDiscriminatedUnion(schema) {
+    return "discriminator" in schema._zod.def;
+}
+function isZodUnionOfObjects(schema) {
+    return schema.options.length > 0 && schema.options.every(isZodObject);
+}
+function getObjectShapeKeys(schema) {
+    return Object.keys(schema.shape);
+}
+function getUnionObjectKeys(schema) {
+    const keys = new Set();
+    for (const option of schema.options) {
+        if (!isZodObject(option)) {
+            continue;
+        }
+        for (const key of Object.keys(option.shape)) {
+            keys.add(key);
+        }
+    }
+    return [...keys];
+}
+function buildSmartObjectClass(zodSchema) {
+    const keys = isZodObject(zodSchema)
+        ? getObjectShapeKeys(zodSchema)
+        : getUnionObjectKeys(zodSchema);
+    class SmartObjectClass {
+        #data;
+        #operations = [];
+        static fromOperations(initial, operations) {
+            const instance = new SmartObjectClass(initial);
+            instance.#applyOperations(operations);
+            return instance;
+        }
+        #applyOperations(operations) {
+            if (operations.length === 0) {
+                return;
+            }
+            applyPatch(this.#data, operations, false, true);
+            this.#operations.push(...operations);
+        }
+        get operations() {
+            return this.#operations;
+        }
+        clearOperations() {
+            this.#operations.length = 0;
+        }
+        constructor(initial) {
+            for (const key of keys) {
+                const setMethodName = `set${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+                Object.defineProperty(this, key, {
+                    get: () => this.#data[key],
+                    enumerable: true,
+                    configurable: true,
+                });
+                Object.defineProperty(this, setMethodName, {
+                    value: isZodObject(zodSchema)
+                        ? this.#createObjectFieldSetter(zodSchema, key)
+                        : this.#createUnionFieldSetter(zodSchema, key),
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
+            }
+            this.#data = zodSchema.parse(initial ?? {});
+        }
+        #createObjectFieldSetter(schema, key) {
+            const fieldSchema = schema.shape[key];
+            return (value) => {
+                const parsed = fieldSchema.parse(value);
+                const beforeData = deepClone(this.#data);
+                const afterData = { ...deepClone(this.#data), [key]: parsed };
+                const patch = compare(beforeData, afterData);
+                if (patch.length === 0) {
+                    return;
+                }
+                applyPatch(this.#data, patch, false, true);
+                this.#operations.push(...patch);
+            };
+        }
+        #getActiveVariantViaDiscriminator(schema, data) {
+            const discriminator = schema._zod.def.discriminator;
+            const tag = data[discriminator];
+            for (const option of schema.options) {
+                if (!isZodObject(option)) {
+                    continue;
+                }
+                const tagSchema = option.shape[discriminator];
+                if (tagSchema?.safeParse(tag).success) {
+                    return option;
+                }
+            }
+            return undefined;
+        }
+        #getMatchingVariantObjects(schema) {
+            if (isZodDiscriminatedUnion(schema)) {
+                const activeVariant = this.#getActiveVariantViaDiscriminator(schema, this.#data);
+                return activeVariant ? [activeVariant] : [];
+            }
+            return schema.options
+                .filter(isZodObject)
+                .filter((option) => option.safeParse(this.#data).success);
+        }
+        #assertKeyAllowedOnMatchingVariants(matchingVariants, key) {
+            if (matchingVariants.length === 0) {
+                throw new Error("Cannot set field on invalid union state");
+            }
+            if (matchingVariants.length === 1) {
+                if (!(key in matchingVariants[0].shape)) {
+                    throw new Error(`Cannot set "${key}" on the active union variant`);
+                }
+                return;
+            }
+            if (!matchingVariants.some((variant) => key in variant.shape)) {
+                throw new Error(`Cannot set "${key}" on the active union variant`);
+            }
+        }
+        #createUnionFieldSetter(schema, key) {
+            return (value) => {
+                const matchingVariants = this.#getMatchingVariantObjects(schema);
+                this.#assertKeyAllowedOnMatchingVariants(matchingVariants, key);
+                const beforeData = deepClone(this.#data);
+                const candidate = { ...deepClone(this.#data), [key]: value };
+                const parsed = schema.parse(candidate);
+                const patch = compare(beforeData, parsed);
+                if (patch.length === 0) {
+                    return;
+                }
+                this.#data = parsed;
+                this.#operations.push(...patch);
+            };
+        }
+    }
+    return SmartObjectClass;
+}
+export function SmartObject(zodSchema) {
+    if (isZodObject(zodSchema)) {
+        return buildSmartObjectClass(zodSchema);
+    }
+    if (isZodUnionRoot(zodSchema)) {
+        if (!isZodUnionOfObjects(zodSchema)) {
+            throw new TypeError("SmartObject union root requires all options to be z.object(...)");
+        }
+        return buildSmartObjectClass(zodSchema);
+    }
+    throw new TypeError("SmartObject requires a z.object(...), z.union([...]), or z.discriminatedUnion(...) schema");
+}

package/dist/types.d.ts

@@ -0,0 +1,63 @@
+import type { Operation } from "fast-json-patch";
+import type { z } from "zod";
+export type { Operation };
+/**
+ * Schemas accepted by SmartObject: plain objects or unions of objects at root.
+ */
+export type SmartObjectSchema = z.ZodObject | z.ZodDiscriminatedUnion | z.ZodUnion;
+/**
+ * Compile-time map of `set*` methods for each schema key.
+ *
+ * Setters are generated at runtime, so mapped types preserve type safety
+ * even though the class body is built dynamically from the Zod shape.
+ */
+export type SetMethods<T> = {
+    [K in keyof T as `set${Capitalize<string & K>}`]: (value: T[K]) => void;
+};
+/**
+ * All keys across union members — `keyof` on a union only yields common keys.
+ */
+export type AllKeys<T> = T extends unknown ? keyof T : never;
+/**
+ * `set*` methods for union root schemas.
+ *
+ * Each setter accepts the union of value types for that key across variants.
+ */
+export type SetMethodsUnion<T> = {
+    [K in AllKeys<T> as `set${Capitalize<string & K>}`]: (value: T extends unknown ? (K extends keyof T ? T[K] : never) : never) => void;
+};
+/**
+ * Read/write surface and audit trail are separate concerns in the public API.
+ *
+ * Grouping operations here keeps mutation methods focused on state while
+ * consumers can still inspect or reset the patch history explicitly.
+ */
+export type OperationsAccessor = {
+    /** Chronological RFC 6902 log — order matters for replay and sync */
+    readonly operations: readonly Operation[];
+    /** Drops accumulated patches after persist/sync without rolling back state */
+    clearOperations(): void;
+};
+/**
+ * Flattened data shape for union roots — exposes all variant keys on one surface.
+ */
+export type UnionDataShape<U> = {
+    [K in AllKeys<U>]: U extends unknown ? (K extends keyof U ? U[K] : never) : never;
+};
+/**
+ * Full instance contract: validated data shape, typed mutators, and patch log.
+ *
+ * Intersection types merge these concerns into one consumable surface for callers.
+ */
+export type SmartObjectInstance<T extends SmartObjectSchema> = (T extends z.ZodObject ? z.infer<T> : UnionDataShape<z.infer<T>>) & (T extends z.ZodObject ? SetMethods<z.infer<T>> : SetMethodsUnion<z.infer<T>>) & OperationsAccessor;
+/**
+ * Constructor type for a SmartObject class, including replay as a first-class capability.
+ *
+ * `fromOperations` lives on the constructor type because replay is a core use case,
+ * not an optional utility added after the fact.
+ */
+export type SmartObjectConstructor<T extends SmartObjectSchema> = {
+    new (initial?: z.input<T>): SmartObjectInstance<T>;
+    fromOperations(initial: z.input<T> | undefined, operations: Operation[]): SmartObjectInstance<T>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,qBAAqB,GAAG,CAAC,CAAC,QAAQ,CAAC;AAEnF;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;KACzB,CAAC,IAAI,MAAM,CAAC,IAAI,MAAM,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;CACxE,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,GAAG,MAAM,CAAC,GAAG,KAAK,CAAC;AAE7D;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI;KAC9B,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,IAAI,MAAM,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,GAAG,CACnD,KAAK,EAAE,CAAC,SAAS,OAAO,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK,KAClE,IAAI;CACV,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,qEAAqE;IACrE,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,8EAA8E;IAC9E,eAAe,IAAI,IAAI,CAAC;CACzB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;KAC7B,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,OAAO,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK;CAClF,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,iBAAiB,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,GACjF,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GACV,cAAc,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAC7B,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,GAAG,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAC9E,kBAAkB,CAAC;AAErB;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,iBAAiB,IAAI;IAChE,KAAK,OAAO,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC;IACnD,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC;CAClG,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@gialicus/smart-object",
+  "version": "1.0.0",
+  "description": "Oggetti TypeScript generati da schemi Zod con getter, set* tipizzati e operazioni JSON Patch",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "check": "biome check .",
+    "check:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "dev": "npm run build && tsx examples/person.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build && npm test",
+    "prepare": "node -e \"process.exit(require('fs').existsSync('.git')?0:1)\" && husky || true"
+  },
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  },
+  "dependencies": {
+    "fast-json-patch": "^3.1.1"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.1",
+    "@commitlint/cli": "^21.1.0",
+    "@commitlint/config-conventional": "^21.1.0",
+    "husky": "^9.1.7",
+    "tsx": "^4.20.3",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "zod": "^4.4.3"
+  },
+  "keywords": [
+    "zod",
+    "json-patch",
+    "typescript",
+    "audit",
+    "sync",
+    "rfc6902",
+    "smart-object",
+    "change-tracking"
+  ],
+  "author": "Gia Licoletta",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gialicus/smart-object.git"
+  },
+  "homepage": "https://github.com/gialicus/smart-object#readme",
+  "bugs": {
+    "url": "https://github.com/gialicus/smart-object/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  }
+}