@gialicus/smart-object 1.0.0 → 2.0.1

package/CHANGELOG.md

@@ -5,14 +5,51 @@ 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).
 
+## [2.0.1] - 2026-06-27
+
+### Added
+
+- Support for `z.date()` and `z.coerce.date()` with ISO 8601 operation values and `Date` getters
+- Support for `z.bigint()`, `z.map` (string keys), and `z.set` via explicit JSON-safe codecs
+- Per-entry API for `z.record` fields: `get{Field}Entry`, `set{Field}Entry`, `delete{Field}Entry`
+- Union variant switching: `switchVariant` and generated `switchTo{Variant}` for discriminated unions
+- Root schema variants: `z.intersection` and `z.lazy`
+- Zod schema introspection module (`src/zod-introspect.ts`) and codec layer (`src/smart-object/codecs.ts`)
+
+## [2.0.0] - 2026-06-27
+
+### Breaking
+
+- Getters for object and array fields always return deep clones; in-place mutation no longer affects internal state
+- Removed `SmartObjectOptions` and the `immutableReads` factory option
+- `operations` getter returns a defensive copy instead of the internal array reference
+
+### Added
+
+- `toJSON()` instance method for deep-cloned, JSON-safe snapshots (also used by `JSON.stringify`)
+- `SmartObjectError` with structured `code`, optional `field`, and `cause` for programmatic error handling
+- Zod schema introspection isolated in `src/zod-introspect.ts`
+- CI matrix job testing Zod peer compatibility (`4.0.0` and `latest`)
+
+### Changed
+
+- Getter and setter methods are defined on the class prototype (one definition per schema, not per instance)
+- Object field setters use a single `deepClone` per write instead of two
+- `fromOperations` re-validates state with Zod after applying patches; invalid replay throws `SmartObjectError` and rolls back
+- Setter and union validation errors throw `SmartObjectError` instead of generic `Error`
+- Unsupported schema at factory time throws `SmartObjectError` with code `UnsupportedSchema`
+
 ## [1.0.0] - 2026-06-27
 
 ### Added
 
 - `SmartObject(schema)` factory: typed getters and `set*` methods generated from a Zod object schema
+- Support for `z.union([...])` and `z.discriminatedUnion(...)` at schema root
 - 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`
+- Exported types: `Operation`, `SetMethods`, `SetMethodsUnion`, `AllKeys`, `UnionDataShape`, `OperationsAccessor`, `SmartObjectConstructor`, `SmartObjectInstance`
 
+[2.0.1]: https://github.com/gialicus/smart-object/compare/v2.0.0...v2.0.1
+[2.0.0]: https://github.com/gialicus/smart-object/compare/v1.0.0...v2.0.0
 [1.0.0]: https://github.com/gialicus/smart-object/releases/tag/v1.0.0

package/README.md

@@ -23,7 +23,7 @@ const Person = SmartObject(z.object({
 
 const person = new Person({ name: "Mario", age: 30 });
 
-// Reads expose validated state without side effects
+// Reads expose validated state
 console.log(person.name); // "Mario"
 
 // Writes validate first, then append patches to person.operations
@@ -40,6 +40,9 @@ person.setName("Luigi"); // Unchanged value — no operation added (keeps sync p
 
 person.clearOperations(); // Drops the audit trail after persist/sync; state is unchanged
 
+// Snapshot for serialization — deep clone, safe for JSON.stringify
+console.log(person.toJSON());
+
 // Initial construction is the replay baseline — it never emits operations
 console.log(new Person({ name: "Mario", age: 30 }).operations); // []
 
@@ -48,37 +51,85 @@ const initial = { name: "Mario", age: 30 };
 const person2 = Person.fromOperations(initial, [...person.operations]);
 ```
 
+### Union root schemas
+
+`SmartObject` also accepts `z.discriminatedUnion(...)` and `z.union([...])` when every option is a `z.object(...)`:
+
+```typescript
+const Event = SmartObject(z.discriminatedUnion("type", [
+    z.object({ type: z.literal("click"), x: z.number(), y: z.number() }),
+    z.object({ type: z.literal("scroll"), delta: z.number() }),
+]));
+
+const event = new Event({ type: "click", x: 10, y: 20 });
+event.setX(15);
+
+// Switch the active union variant atomically
+event.switchToScroll({ delta: 5 });
+// or: event.switchVariant({ type: "scroll", delta: 5 });
+```
+
+See [`examples/event.ts`](examples/event.ts) and [`examples/profile.ts`](examples/profile.ts) for full demos.
+
+Object and array getters always return deep clones — in-place mutation does not affect internal state or the operation log. Only `set*` methods generate RFC 6902 operations.
+
 ## API
 
 ### `SmartObject(schema)`
 
-Factory that accepts a `z.object(...)` and returns an instantiable class.
+Factory that accepts a Zod schema and returns an instantiable class.
 
 | Parameter | Type | Description |
 |-----------|------|-------------|
-| `schema` | `z.ZodObject` | Zod schema defining the object shape |
+| `schema` | `z.ZodObject` \| `z.ZodUnion` \| `z.ZodDiscriminatedUnion` \| `z.ZodIntersection` \| `z.ZodLazy` | Zod schema defining the object shape |
 
 **Members generated for each schema field `foo`:**
 
 | Member | Type | Description |
 |--------|------|-------------|
-| `foo` | getter | Exposes the current validated field value |
+| `foo` | getter | Exposes the current validated field value (deep clone for objects and arrays) |
 | `setFoo(value)` | `(value: T) => void` | Validates, updates state, and records patches only when the value actually changes |
 
+`set*` method names follow camelCase with the field name capitalized (`name` → `setName`, `userId` → `setUserId`).
+
+**Union root extras** (discriminated and generic unions):
+
+| Member | Type | Description |
+|--------|------|-------------|
+| `switchVariant(value)` | `(variant) => void` | Replaces the entire active variant after full schema validation |
+| `switchTo{Variant}(fields)` | `(fields) => void` | Discriminated unions only — switches to a variant without repeating the discriminator (e.g. `switchToScroll({ delta: 5 })`) |
+
+**Record field extras** (for each `z.record(...)` field `tags`):
+
+| Member | Type | Description |
+|--------|------|-------------|
+| `getTagsEntry(key)` | `(key: string) => V \| undefined` | Reads a single record entry |
+| `setTagsEntry(key, value)` | `(key: string, value: V) => void` | Validates and patches a single entry (`/tags/{key}`) |
+| `deleteTagsEntry(key)` | `(key: string) => void` | Removes a record entry |
+
 **Instance members:**
 
 | Member | Type | Description |
 |--------|------|-------------|
-| `operations` | `readonly Operation[]` | Chronological RFC 6902 patch log |
+| `operations` | `readonly Operation[]` | Chronological RFC 6902 patch log (defensive copy) |
 | `clearOperations()` | `() => void` | Clears the patch log without rolling back state |
-
-`set*` method names follow camelCase with the field name capitalized (`name` → `setName`, `address` → `setAddress`).
+| `toJSON()` | `() => T` | Deep clone of current state, safe for `JSON.stringify` |
 
 **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 |
+| `fromOperations(initial, operations)` | `(initial, Operation[]) => Instance` | Builds an instance from a baseline, replays and validates operations, and copies them into the accumulator |
+
+### `SmartObjectError`
+
+Structured error thrown on validation failures, invalid union field access, and failed replay:
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `code` | `"InvalidValue"` \| `"InvalidUnionField"` \| `"InvalidReplay"` \| `"UnsupportedSchema"` | Error category |
+| `field` | `string` \| `undefined` | Schema field path when applicable |
+| `cause` | `unknown` | Original error (e.g. `ZodError`) |
 
 ### `Operation`
 
@@ -93,8 +144,24 @@ RFC 6902 operation emitted by [fast-json-patch](https://github.com/Starcounter-J
 
 - `Operation` — JSON Patch operation (re-export from `fast-json-patch`)
 - `SetMethods<T>` — mapped type of inferred `set*` methods for shape `T`
+- `SetMethodsUnion<T>` — `set*` methods for union root schemas
+- `AllKeys<T>` — all keys across union members
+- `UnionDataShape<U>` — flattened data shape for union roots
+- `VariantSwitchMethods<T>` — `switchVariant` for union roots
+- `DiscriminatedVariantSwitchMethods<T, D>` — `switchVariant` plus generated `switchTo*` methods
+- `RecordFieldMethods<T>` — dynamic entry accessors for `z.record` fields
 - `OperationsAccessor` — `operations` and `clearOperations()`
+- `SnapshotAccessor<T>` — `toJSON()`
 - `SmartObjectConstructor<T>` — constructor type including `fromOperations`
+- `SmartObjectInstance<T>` — full instance type (getters + set* + operations + toJSON)
+
+## Limitations
+
+- **Partial discriminator write** — Changing a discriminated union discriminator alone via `setType(...)` without providing the new variant fields throws `SmartObjectError`. Use `switchVariant(...)` or `switchTo{Variant}(...)` instead.
+- **Union field on wrong variant** — Setting a field that does not exist on the active variant throws `SmartObjectError`.
+- **Date fields** — `z.date()` and `z.coerce.date()` are supported; operations store ISO 8601 strings while getters return `Date` instances.
+- **Map, Set, and bigint** — `z.map` (string keys), `z.set`, and `z.bigint()` are supported with explicit codecs; operations use JSON-safe plain objects, arrays, and decimal strings respectively. Whole-field replace is used for Map/Set updates. Non-string map keys are not supported.
+- **Transforms** — `z.transform` / `z.pipe` with preprocessing work at runtime; operations store the **output** value after validation. TypeScript setter input types may not reflect transforms.
 
 ## Design rationale
 
@@ -103,25 +170,66 @@ RFC 6902 operation emitted by [fast-json-patch](https://github.com/Starcounter-J
 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)
+6. **Replay** — `fromOperations(initial, operations)` replays patches, re-validates with Zod, and requires the same baseline used when the operations were produced.
 
-## Full example
+## Examples
 
-See [`examples/person.ts`](examples/person.ts) for a demo with primitives, nested objects, and arrays.
+- [`examples/person.ts`](examples/person.ts) — primitives, nested objects, and arrays
+- [`examples/event.ts`](examples/event.ts) — discriminated union root
+- [`examples/profile.ts`](examples/profile.ts) — generic union root
 
 ## Project structure
 
 ```
 smart-object/
 ├── src/
-│   ├── index.ts          # Public API barrel export
-│   ├── smart-object.ts   # SmartObject factory
-│   └── types.ts          # Operation and inferred types
+│   ├── index.ts              # Public API barrel export
+│   ├── types.ts              # Operation and inferred types
+│   ├── errors.ts             # SmartObjectError
+│   ├── zod-introspect.ts     # Zod schema introspection
+│   └── smart-object/
+│       ├── index.ts          # Re-export SmartObject
+│       ├── factory.ts        # Public SmartObject() factory
+│       ├── build-class.ts    # Class generation orchestration
+│       ├── instance-state.ts # WeakMap-backed instance storage
+│       ├── read-field.ts     # Defensive getter reads
+│       ├── json-patch.ts     # fast-json-patch wrapper + Date-safe deepClone
+│       ├── codecs.ts         # ISO 8601 serialization for date fields
+│       ├── apply-operations.ts # Replay and rollback
+│       ├── union-variant.ts  # Union variant matching
+│       ├── define-prototype.ts # Getter/setter prototype setup
+│       └── setters/
+│           ├── object-field.ts
+│           ├── union-field.ts
+│           ├── variant-switch.ts
+│           └── record-field.ts
 ├── examples/
-│   └── person.ts         # Usage demo
+│   ├── person.ts
+│   ├── event.ts
+│   └── profile.ts
 ├── tests/
-│   └── smart-object.test.ts
-└── dist/                 # Build output (generated)
+│   ├── fixtures/
+│   │   ├── person.ts
+│   │   ├── entity.ts
+│   │   ├── event.ts
+│   │   └── profile.ts
+│   ├── smart-object/
+│   │   ├── construction.test.ts
+│   │   ├── getters.test.ts
+│   │   ├── setters.test.ts
+│   │   ├── clear-operations.test.ts
+│   │   ├── from-operations.test.ts
+│   │   ├── union-fields.test.ts
+│   │   ├── discriminated-union-root.test.ts
+│   │   ├── generic-union-root.test.ts
+│   │   ├── robustness.test.ts
+│   │   ├── setter-naming.test.ts
+│   │   ├── to-json.test.ts
+│   │   ├── schema-variants.test.ts
+│   │   ├── record-fields.test.ts
+│   │   ├── date-codec.test.ts
+│   │   ├── intersection-lazy.test.ts
+│   │   └── types.test.ts
+│   └── zod-introspect.test.ts
+└── dist/                     # Build output (generated)
 ```

package/dist/errors.d.ts

@@ -0,0 +1,20 @@
+export type SmartObjectErrorCode = "InvalidValue" | "InvalidUnionField" | "InvalidReplay" | "UnsupportedSchema";
+/**
+ * Structured error for SmartObject operations — enables programmatic handling
+ * without parsing generic Error messages.
+ */
+export declare class SmartObjectError extends Error {
+    readonly code: SmartObjectErrorCode;
+    readonly field?: string;
+    readonly cause?: unknown;
+    constructor(code: SmartObjectErrorCode, message: string, options?: {
+        field?: string;
+        cause?: unknown;
+    });
+    static invalidValue(field: string, cause: unknown): SmartObjectError;
+    static invalidUnionField(field: string, message?: string): SmartObjectError;
+    static invalidUnionState(): SmartObjectError;
+    static invalidReplay(cause: unknown): SmartObjectError;
+    static unsupportedSchema(message: string): SmartObjectError;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,oBAAoB,GAC5B,cAAc,GACd,mBAAmB,GACnB,eAAe,GACf,mBAAmB,CAAC;AAExB;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;gBAGvB,IAAI,EAAE,oBAAoB,EAC1B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;IAS/C,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,gBAAgB;IAapE,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,gBAAgB;IAQ3E,MAAM,CAAC,iBAAiB,IAAI,gBAAgB;IAI5C,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB;IAStD,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB;CAG5D"}

package/dist/errors.js

@@ -0,0 +1,40 @@
+/**
+ * Structured error for SmartObject operations — enables programmatic handling
+ * without parsing generic Error messages.
+ */
+export class SmartObjectError extends Error {
+    code;
+    field;
+    cause;
+    constructor(code, message, options) {
+        super(message);
+        this.name = "SmartObjectError";
+        this.code = code;
+        this.field = options?.field;
+        this.cause = options?.cause;
+    }
+    static invalidValue(field, cause) {
+        if (cause instanceof SmartObjectError) {
+            return cause;
+        }
+        const message = cause instanceof Error && "issues" in cause
+            ? `Invalid value for "${field}": ${cause.issues.map((i) => i.message).join(", ")}`
+            : `Invalid value for "${field}"`;
+        return new SmartObjectError("InvalidValue", message, { field, cause });
+    }
+    static invalidUnionField(field, message) {
+        return new SmartObjectError("InvalidUnionField", message ?? `Cannot set "${field}" on the active union variant`, { field });
+    }
+    static invalidUnionState() {
+        return new SmartObjectError("InvalidUnionField", "Cannot set field on invalid union state");
+    }
+    static invalidReplay(cause) {
+        const message = cause instanceof Error
+            ? `Operation replay failed: ${cause.message}`
+            : "Operation replay failed";
+        return new SmartObjectError("InvalidReplay", message, { cause });
+    }
+    static unsupportedSchema(message) {
+        return new SmartObjectError("UnsupportedSchema", message);
+    }
+}

package/dist/index.d.ts

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

package/dist/index.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,YAAY,EACV,OAAO,EACP,iCAAiC,EACjC,SAAS,EACT,kBAAkB,EAClB,kBAAkB,EAClB,UAAU,EACV,eAAe,EACf,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,GACrB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1 +1,2 @@
-export { SmartObject } from "./smart-object.js";
+export { SmartObjectError } from "./errors.js";
+export { SmartObject } from "./smart-object/index.js";

package/dist/smart-object/apply-operations.d.ts

@@ -0,0 +1,5 @@
+import type { Operation } from "fast-json-patch";
+import type { SmartObjectSchema } from "../types.js";
+import type { InstanceState } from "./instance-state.js";
+export declare function applyOperations<T>(state: InstanceState<T>, zodSchema: SmartObjectSchema, instance: object, operations: Operation[]): void;
+//# sourceMappingURL=apply-operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apply-operations.d.ts","sourceRoot":"","sources":["../../src/smart-object/apply-operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,wBAAgB,eAAe,CAAC,CAAC,EAC/B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,SAAS,EAAE,iBAAiB,EAC5B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,SAAS,EAAE,GACtB,IAAI,CAkBN"}

package/dist/smart-object/apply-operations.js

@@ -0,0 +1,21 @@
+import { SmartObjectError } from "../errors.js";
+import { deserializeDataFromPatch } from "./codecs.js";
+import { applyPatch, deepClone } from "./json-patch.js";
+export function applyOperations(state, zodSchema, instance, operations) {
+    if (operations.length === 0) {
+        return;
+    }
+    const data = state.getData(instance);
+    const snapshot = deepClone(data);
+    try {
+        applyPatch(data, operations, false, true);
+        const deserialized = deserializeDataFromPatch(data, zodSchema);
+        const validated = zodSchema.parse(deserialized);
+        state.setData(instance, validated);
+        state.getOperations(instance).push(...operations);
+    }
+    catch (cause) {
+        state.setData(instance, snapshot);
+        throw SmartObjectError.invalidReplay(cause);
+    }
+}

package/dist/smart-object/build-class.d.ts

@@ -0,0 +1,3 @@
+import type { SmartObjectConstructor, SmartObjectSchema } from "../types.js";
+export declare function buildSmartObjectClass<T extends SmartObjectSchema>(zodSchema: T): SmartObjectConstructor<T>;
+//# sourceMappingURL=build-class.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build-class.d.ts","sourceRoot":"","sources":["../../src/smart-object/build-class.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAuB,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOlG,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,iBAAiB,EAC/D,SAAS,EAAE,CAAC,GACX,sBAAsB,CAAC,CAAC,CAAC,CAqC3B"}

package/dist/smart-object/build-class.js

@@ -0,0 +1,31 @@
+import { getSchemaShapeKeys } from "../zod-introspect.js";
+import { applyOperations } from "./apply-operations.js";
+import { definePrototype } from "./define-prototype.js";
+import { createInstanceState } from "./instance-state.js";
+import { deepClone } from "./json-patch.js";
+export function buildSmartObjectClass(zodSchema) {
+    const keys = getSchemaShapeKeys(zodSchema);
+    const state = createInstanceState();
+    class SmartObjectClass {
+        static fromOperations(initial, operations) {
+            const instance = new SmartObjectClass(initial);
+            applyOperations(state, zodSchema, instance, operations);
+            return instance;
+        }
+        get operations() {
+            return [...state.getOperations(this)];
+        }
+        clearOperations() {
+            state.getOperations(this).length = 0;
+        }
+        toJSON() {
+            return deepClone(state.getData(this));
+        }
+        constructor(initial) {
+            state.setData(this, zodSchema.parse(initial ?? {}));
+            state.initOperations(this);
+        }
+    }
+    definePrototype(SmartObjectClass.prototype, state, zodSchema, keys);
+    return SmartObjectClass;
+}

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

@@ -0,0 +1,15 @@
+import type { z } from "zod";
+import type { SmartObjectSchema } from "../types.js";
+export declare function serializeValue(schema: z.ZodType, value: unknown): unknown;
+export declare function deserializeValue(schema: z.ZodType, value: unknown): unknown;
+export declare function serializeDataForPatch<T extends Record<string, unknown>>(data: T, rootSchema: SmartObjectSchema): T;
+export declare function deserializeDataFromPatch<T extends Record<string, unknown>>(data: T, rootSchema: SmartObjectSchema): T;
+export declare function serializePatchValue(rootSchema: SmartObjectSchema, key: string, value: unknown): unknown;
+export declare function serializeEntryPatchValue(fieldSchema: z.ZodType, valueSchema: z.ZodType, value: unknown): unknown;
+/** Serialize a single entry container for RFC 6902 compare (record or map field). */
+export declare function serializeEntryContainer(fieldSchema: z.ZodType, container: unknown): Record<string, unknown>;
+/** @deprecated Use serializeValue */
+export declare function serializeFieldValue(fieldSchema: z.ZodType, value: unknown): unknown;
+/** @deprecated Use deserializeValue */
+export declare function deserializeFieldValue(fieldSchema: z.ZodType, value: unknown): unknown;
+//# sourceMappingURL=codecs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.d.ts","sourceRoot":"","sources":["../../src/smart-object/codecs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAwBrD,wBAAgB,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CA6DzE;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAmE3E;AAED,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrE,IAAI,EAAE,CAAC,EACP,UAAU,EAAE,iBAAiB,GAC5B,CAAC,CAeH;AAED,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxE,IAAI,EAAE,CAAC,EACP,UAAU,EAAE,iBAAiB,GAC5B,CAAC,CAeH;AAED,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,iBAAiB,EAC7B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,GACb,OAAO,CAQT;AAED,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,CAAC,CAAC,OAAO,EACtB,WAAW,EAAE,CAAC,CAAC,OAAO,EACtB,KAAK,EAAE,OAAO,GACb,OAAO,CAYT;AAED,qFAAqF;AACrF,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,CAAC,CAAC,OAAO,EACtB,SAAS,EAAE,OAAO,GACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAGzB;AAED,qCAAqC;AACrC,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAEnF;AAED,uCAAuC;AACvC,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAErF"}

package/dist/smart-object/codecs.js

@@ -0,0 +1,163 @@
+import { getFieldSchema, getMergedObjectShape, isZodRecord, unwrapFieldSchema, } from "../zod-introspect.js";
+function getSchemaDef(schema) {
+    return schema._zod.def;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function serializeValue(schema, value) {
+    const inner = unwrapFieldSchema(schema);
+    const def = getSchemaDef(inner);
+    if (value instanceof Date && def.type === "date") {
+        return value.toISOString();
+    }
+    if (typeof value === "bigint" && def.type === "bigint") {
+        return value.toString();
+    }
+    if (value instanceof Map && def.type === "map") {
+        const keySchema = def.keyType;
+        const valueSchema = def.valueType;
+        const result = {};
+        for (const [key, entryValue] of value.entries()) {
+            const serializedKey = serializeValue(keySchema, key);
+            if (typeof serializedKey === "string") {
+                result[serializedKey] = serializeValue(valueSchema, entryValue);
+            }
+        }
+        return result;
+    }
+    if (value instanceof Set && def.type === "set") {
+        const valueSchema = def.valueType;
+        return [...value].map((item) => serializeValue(valueSchema, item));
+    }
+    if (def.type === "object" && isPlainObject(value)) {
+        const shape = def.shape ?? {};
+        const result = {};
+        for (const [key, fieldValue] of Object.entries(value)) {
+            const fieldSchema = shape[key];
+            result[key] = fieldSchema ? serializeValue(fieldSchema, fieldValue) : fieldValue;
+        }
+        return result;
+    }
+    if (def.type === "array" && Array.isArray(value)) {
+        const elementSchema = def.element;
+        return value.map((item) => serializeValue(elementSchema, item));
+    }
+    if (def.type === "record" && isPlainObject(value)) {
+        const valueSchema = def.valueType;
+        const result = {};
+        for (const [key, fieldValue] of Object.entries(value)) {
+            result[key] = serializeValue(valueSchema, fieldValue);
+        }
+        return result;
+    }
+    return value;
+}
+export function deserializeValue(schema, value) {
+    const inner = unwrapFieldSchema(schema);
+    const def = getSchemaDef(inner);
+    if (def.type === "date" && typeof value === "string") {
+        const parsed = new Date(value);
+        if (!Number.isNaN(parsed.getTime())) {
+            return parsed;
+        }
+        return value;
+    }
+    if (def.type === "bigint" && typeof value === "string") {
+        try {
+            return BigInt(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    if (def.type === "map" && isPlainObject(value)) {
+        const keySchema = def.keyType;
+        const valueSchema = def.valueType;
+        const map = new Map();
+        for (const [key, entryValue] of Object.entries(value)) {
+            map.set(deserializeValue(keySchema, key), deserializeValue(valueSchema, entryValue));
+        }
+        return map;
+    }
+    if (def.type === "set" && Array.isArray(value)) {
+        const valueSchema = def.valueType;
+        return new Set(value.map((item) => deserializeValue(valueSchema, item)));
+    }
+    if (def.type === "object" && isPlainObject(value)) {
+        const shape = def.shape ?? {};
+        const result = {};
+        for (const [key, fieldValue] of Object.entries(value)) {
+            const fieldSchema = shape[key];
+            result[key] = fieldSchema ? deserializeValue(fieldSchema, fieldValue) : fieldValue;
+        }
+        return result;
+    }
+    if (def.type === "array" && Array.isArray(value)) {
+        const elementSchema = def.element;
+        return value.map((item) => deserializeValue(elementSchema, item));
+    }
+    if (def.type === "record" && isPlainObject(value)) {
+        const valueSchema = def.valueType;
+        const result = {};
+        for (const [key, fieldValue] of Object.entries(value)) {
+            result[key] = deserializeValue(valueSchema, fieldValue);
+        }
+        return result;
+    }
+    return value;
+}
+export function serializeDataForPatch(data, rootSchema) {
+    const shape = getMergedObjectShape(rootSchema);
+    if (Object.keys(shape).length === 0) {
+        return data;
+    }
+    const result = {};
+    for (const [key, fieldValue] of Object.entries(data)) {
+        const fieldSchema = shape[key];
+        result[key] = fieldSchema ? serializeValue(fieldSchema, fieldValue) : fieldValue;
+    }
+    return result;
+}
+export function deserializeDataFromPatch(data, rootSchema) {
+    const shape = getMergedObjectShape(rootSchema);
+    if (Object.keys(shape).length === 0) {
+        return data;
+    }
+    const result = {};
+    for (const [key, fieldValue] of Object.entries(data)) {
+        const fieldSchema = shape[key];
+        result[key] = fieldSchema ? deserializeValue(fieldSchema, fieldValue) : fieldValue;
+    }
+    return result;
+}
+export function serializePatchValue(rootSchema, key, value) {
+    const fieldSchema = getFieldSchema(rootSchema, key);
+    if (!fieldSchema) {
+        return value;
+    }
+    return serializeValue(fieldSchema, value);
+}
+export function serializeEntryPatchValue(fieldSchema, valueSchema, value) {
+    const inner = unwrapFieldSchema(fieldSchema);
+    if (isZodRecord(inner)) {
+        return serializeValue(valueSchema, value);
+    }
+    if (isPlainObject(value)) {
+        return serializeValue(fieldSchema, value);
+    }
+    return serializeValue(valueSchema, value);
+}
+/** Serialize a single entry container for RFC 6902 compare (record or map field). */
+export function serializeEntryContainer(fieldSchema, container) {
+    const serialized = serializeValue(fieldSchema, container);
+    return isPlainObject(serialized) ? serialized : {};
+}
+/** @deprecated Use serializeValue */
+export function serializeFieldValue(fieldSchema, value) {
+    return serializeValue(fieldSchema, value);
+}
+/** @deprecated Use deserializeValue */
+export function deserializeFieldValue(fieldSchema, value) {
+    return deserializeValue(fieldSchema, value);
+}

package/dist/smart-object/define-prototype.d.ts

@@ -0,0 +1,4 @@
+import type { SmartObjectSchema } from "../types.js";
+import type { InstanceState } from "./instance-state.js";
+export declare function definePrototype<T>(prototype: object, state: InstanceState<T>, zodSchema: SmartObjectSchema, keys: string[]): void;
+//# sourceMappingURL=define-prototype.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"define-prototype.d.ts","sourceRoot":"","sources":["../../src/smart-object/define-prototype.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAarD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAoEzD,wBAAgB,eAAe,CAAC,CAAC,EAC/B,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,SAAS,EAAE,iBAAiB,EAC5B,IAAI,EAAE,MAAM,EAAE,GACb,IAAI,CAiCN"}