@voidhash/mimic 0.0.1-alpha.1 → 0.0.1-alpha.111

package/src/primitives/Struct.ts

@@ -4,9 +4,57 @@ import * as Operation from "../Operation";
 import * as OperationPath from "../OperationPath";
 import * as ProxyEnvironment from "../ProxyEnvironment";
 import * as Transform from "../Transform";
-import type { Primitive, PrimitiveInternal, MaybeUndefined, AnyPrimitive, Validator, InferState, InferProxy, InferSnapshot } from "../Primitive";
+import type { Primitive, PrimitiveInternal, MaybeUndefined, AnyPrimitive, Validator, InferState, InferProxy, InferSnapshot, NeedsValue, InferUpdateInput, InferSetInput } from "../Primitive";
 import { ValidationError } from "../Primitive";
-import { runValidators } from "./shared";
+import { runValidators, applyDefaults } from "./shared";
+
+// =============================================================================
+// Struct Set Input Types
+// =============================================================================
+
+/**
+ * Determines if a field is required for set() operations.
+ * A field is required if: TRequired is true AND THasDefault is false
+ */
+type IsRequiredForSet<T> = T extends Primitive<any, any, true, false> ? true : false;
+
+/**
+ * Extract keys of fields that are required for set() (required without default).
+ */
+type RequiredSetKeys<TFields extends Record<string, AnyPrimitive>> = {
+  [K in keyof TFields]: IsRequiredForSet<TFields[K]> extends true ? K : never;
+}[keyof TFields];
+
+/**
+ * Extract keys of fields that are optional for set() (has default OR not required).
+ */
+type OptionalSetKeys<TFields extends Record<string, AnyPrimitive>> = {
+  [K in keyof TFields]: IsRequiredForSet<TFields[K]> extends true ? never : K;
+}[keyof TFields];
+
+/**
+ * Compute the input type for set() operations on a struct.
+ * Required fields (required without default) must be provided.
+ * Optional fields (has default or not required) can be omitted.
+ * Uses each field's TSetInput type to handle nested structs correctly.
+ */
+export type StructSetInput<TFields extends Record<string, AnyPrimitive>> = 
+  { readonly [K in RequiredSetKeys<TFields>]: InferSetInput<TFields[K]> } &
+  { readonly [K in OptionalSetKeys<TFields>]?: InferSetInput<TFields[K]> };
+
+/**
+ * Input type for set() - respects required/default status of the struct.
+ * If the struct is required without a default, the value must be provided.
+ * The value itself uses StructSetInput which handles field-level required/default logic.
+ */
+type InferStructSetInput<TFields extends Record<string, AnyPrimitive>, TRequired extends boolean, THasDefault extends boolean> = 
+  NeedsValue<StructSetInput<TFields>, TRequired, THasDefault>;
+
+/**
+ * Input type for update() - always partial since update only modifies specified fields.
+ * For nested structs, allows recursive partial updates.
+ */
+type InferStructUpdateInput<TFields extends Record<string, AnyPrimitive>> = StructUpdateValue<TFields>;
 
 
 /**
@@ -25,19 +73,29 @@ export type InferStructSnapshot<TFields extends Record<string, AnyPrimitive>> =
   readonly [K in keyof TFields]: InferSnapshot<TFields[K]>;
 };
 
+/**
+ * Maps a schema definition to a partial update type.
+ * Uses each field's TUpdateInput type, which handles nested updates recursively.
+ */
+export type StructUpdateValue<TFields extends Record<string, AnyPrimitive>> = {
+  readonly [K in keyof TFields]?: InferUpdateInput<TFields[K]>;
+};
+
 /**
  * Maps a schema definition to its proxy type.
  * Provides nested field access + get()/set()/toSnapshot() methods for the whole struct.
  */
-export type StructProxy<TFields extends Record<string, AnyPrimitive>, TDefined extends boolean = false> = {
+export type StructProxy<TFields extends Record<string, AnyPrimitive>, TRequired extends boolean = false, THasDefault extends boolean = false> = {
   readonly [K in keyof TFields]: InferProxy<TFields[K]>;
 } & {
   /** Gets the entire struct value */
-  get(): MaybeUndefined<InferStructState<TFields>, TDefined>;
-  /** Sets the entire struct value */
-  set(value: InferStructState<TFields>): void;
+  get(): MaybeUndefined<InferStructState<TFields>, TRequired, THasDefault>;
+  /** Sets the entire struct value (only fields that are required without defaults must be provided) */
+  set(value: InferStructSetInput<TFields, TRequired, THasDefault>): void;
+  /** Updates only the specified fields (partial update, handles nested structs recursively) */
+  update(value: InferStructUpdateInput<TFields>): void;
   /** Returns a readonly snapshot of the struct for rendering */
-  toSnapshot(): MaybeUndefined<InferStructSnapshot<TFields>, TDefined>;
+  toSnapshot(): MaybeUndefined<InferStructSnapshot<TFields>, TRequired, THasDefault>;
 };
 
 interface StructPrimitiveSchema<TFields extends Record<string, AnyPrimitive>> {
@@ -47,12 +105,16 @@ interface StructPrimitiveSchema<TFields extends Record<string, AnyPrimitive>> {
   readonly validators: readonly Validator<InferStructState<TFields>>[];
 }
 
-export class StructPrimitive<TFields extends Record<string, AnyPrimitive>, TDefined extends boolean = false>
-  implements Primitive<InferStructState<TFields>, StructProxy<TFields, TDefined>>
+export class StructPrimitive<TFields extends Record<string, AnyPrimitive>, TRequired extends boolean = false, THasDefault extends boolean = false>
+  implements Primitive<InferStructState<TFields>, StructProxy<TFields, TRequired, THasDefault>, TRequired, THasDefault, InferStructSetInput<TFields, TRequired, THasDefault>, InferStructUpdateInput<TFields>>
 {
   readonly _tag = "StructPrimitive" as const;
   readonly _State!: InferStructState<TFields>;
-  readonly _Proxy!: StructProxy<TFields, TDefined>;
+  readonly _Proxy!: StructProxy<TFields, TRequired, THasDefault>;
+  readonly _TRequired!: TRequired;
+  readonly _THasDefault!: THasDefault;
+  readonly TSetInput!: InferStructSetInput<TFields, TRequired, THasDefault>;
+  readonly TUpdateInput!: InferStructUpdateInput<TFields>;
 
   private readonly _schema: StructPrimitiveSchema<TFields>;
 
@@ -70,7 +132,7 @@ export class StructPrimitive<TFields extends Record<string, AnyPrimitive>, TDefi
   }
 
   /** Mark this struct as required */
-  required(): StructPrimitive<TFields, true> {
+  required(): StructPrimitive<TFields, true, THasDefault> {
     return new StructPrimitive({
       ...this._schema,
       required: true,
@@ -78,10 +140,12 @@ export class StructPrimitive<TFields extends Record<string, AnyPrimitive>, TDefi
   }
 
   /** Set a default value for this struct */
-  default(defaultValue: InferStructState<TFields>): StructPrimitive<TFields, true> {
+  default(defaultValue: StructSetInput<TFields>): StructPrimitive<TFields, TRequired, true> {
+    // Apply defaults to the provided value
+    const merged = applyDefaults(this as AnyPrimitive, defaultValue as Partial<InferStructState<TFields>>) as InferStructState<TFields>;
     return new StructPrimitive({
       ...this._schema,
-      defaultValue,
+      defaultValue: merged,
     });
   }
 
@@ -91,15 +155,15 @@ export class StructPrimitive<TFields extends Record<string, AnyPrimitive>, TDefi
   }
 
   /** Add a custom validation rule (useful for cross-field validation) */
-  refine(fn: (value: InferStructState<TFields>) => boolean, message: string): StructPrimitive<TFields, TDefined> {
+  refine(fn: (value: InferStructState<TFields>) => boolean, message: string): StructPrimitive<TFields, TRequired, THasDefault> {
     return new StructPrimitive({
       ...this._schema,
       validators: [...this._schema.validators, { validate: fn, message }],
     });
   }
 
-  readonly _internal: PrimitiveInternal<InferStructState<TFields>, StructProxy<TFields, TDefined>> = {
-    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): StructProxy<TFields, TDefined> => {
+  readonly _internal: PrimitiveInternal<InferStructState<TFields>, StructProxy<TFields, TRequired, THasDefault>> = {
+    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): StructProxy<TFields, TRequired, THasDefault> => {
       const fields = this._schema.fields;
       const defaultValue = this._schema.defaultValue;
 
@@ -130,33 +194,66 @@ export class StructPrimitive<TFields extends Record<string, AnyPrimitive>, TDefi
         return snapshot as InferStructSnapshot<TFields>;
       };
 
-      // Create the base object with get/set/toSnapshot methods
+      // Create the base object with get/set/update/toSnapshot methods
       const base = {
-        get: (): MaybeUndefined<InferStructState<TFields>, TDefined> => {
+        get: (): MaybeUndefined<InferStructState<TFields>, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as InferStructState<TFields> | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<InferStructState<TFields>, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<InferStructState<TFields>, TRequired, THasDefault>;
         },
-        set: (value: InferStructState<TFields>) => {
+        set: (value: InferStructSetInput<TFields, TRequired, THasDefault>) => {
+          // Apply defaults for missing fields
+          const merged = applyDefaults(this as AnyPrimitive, value as Partial<InferStructState<TFields>>) as InferStructState<TFields>;
           env.addOperation(
-            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
+            Operation.fromDefinition(operationPath, this._opDefinitions.set, merged)
           );
         },
-        toSnapshot: (): MaybeUndefined<InferStructSnapshot<TFields>, TDefined> => {
+        update: (value: InferStructUpdateInput<TFields>) => {
+          for (const key in value) {
+            if (Object.prototype.hasOwnProperty.call(value, key)) {
+              const fieldValue = value[key as keyof TFields];
+              if (fieldValue === undefined) continue; // Skip undefined values
+
+              const fieldPrimitive = fields[key as keyof TFields];
+              if (!fieldPrimitive) continue; // Skip unknown fields
+
+              const fieldPath = operationPath.append(key);
+              const fieldProxy = fieldPrimitive._internal.createProxy(env, fieldPath);
+
+              // Check if this is a nested struct and value is a plain object (partial update)
+              if (
+                fieldPrimitive._tag === "StructPrimitive" &&
+                typeof fieldValue === "object" &&
+                fieldValue !== null &&
+                !Array.isArray(fieldValue)
+              ) {
+                // Recursively update nested struct
+                (fieldProxy as { update: (v: unknown) => void }).update(fieldValue);
+              } else {
+                // Set the field value directly
+                (fieldProxy as { set: (v: unknown) => void }).set(fieldValue);
+              }
+            }
+          }
+        },
+        toSnapshot: (): MaybeUndefined<InferStructSnapshot<TFields>, TRequired, THasDefault> => {
           const snapshot = buildSnapshot();
-          return snapshot as MaybeUndefined<InferStructSnapshot<TFields>, TDefined>;
+          return snapshot as MaybeUndefined<InferStructSnapshot<TFields>, TRequired, THasDefault>;
         },
       };
 
       // Use a JavaScript Proxy to intercept field access
-      return new globalThis.Proxy(base as StructProxy<TFields, TDefined>, {
-        get: (target, prop, receiver) => {
-          // Return base methods (get, set, toSnapshot)
+      return new globalThis.Proxy(base as StructProxy<TFields, TRequired, THasDefault>, {
+        get: (target, prop, _receiver) => {
+          // Return base methods (get, set, update, toSnapshot)
           if (prop === "get") {
             return target.get;
           }
           if (prop === "set") {
             return target.set;
           }
+          if (prop === "update") {
+            return target.update;
+          }
           if (prop === "toSnapshot") {
             return target.toSnapshot;
           }
@@ -175,8 +272,8 @@ export class StructPrimitive<TFields extends Record<string, AnyPrimitive>, TDefi
 
           return undefined;
         },
-        has: (target, prop) => {
-          if (prop === "get" || prop === "set" || prop === "toSnapshot") return true;
+        has: (_target, prop) => {
+          if (prop === "get" || prop === "set" || prop === "update" || prop === "toSnapshot") return true;
           if (typeof prop === "string" && prop in fields) return true;
           return false;
         },
@@ -343,6 +440,6 @@ export class StructPrimitive<TFields extends Record<string, AnyPrimitive>, TDefi
 /** Creates a new StructPrimitive with the given fields */
 export const Struct = <TFields extends Record<string, AnyPrimitive>>(
   fields: TFields
-): StructPrimitive<TFields, false> =>
+): StructPrimitive<TFields, false, false> =>
   new StructPrimitive({ required: false, defaultValue: undefined, fields, validators: [] });
 

package/src/primitives/Tree.ts

@@ -5,11 +5,12 @@ import * as OperationPath from "../OperationPath";
 import * as ProxyEnvironment from "../ProxyEnvironment";
 import * as Transform from "../Transform";
 import * as FractionalIndex from "../FractionalIndex";
-import type { Primitive, PrimitiveInternal, Validator, InferProxy } from "./shared";
-import { ValidationError } from "./shared";
+import type { Primitive, PrimitiveInternal, Validator, InferProxy, AnyPrimitive, InferSetInput, InferUpdateInput } from "./shared";
+import { ValidationError, applyDefaults } from "./shared";
 import { runValidators } from "./shared";
 import type { AnyTreeNodePrimitive, InferTreeNodeType, InferTreeNodeDataState, InferTreeNodeChildren } from "./TreeNode";
-import { InferStructState } from "./Struct";
+import { InferStructState, StructSetInput, StructUpdateValue } from "./Struct";
+import { StructPrimitive } from "./Struct";
 
 
 /**
@@ -37,7 +38,7 @@ export interface TypedTreeNodeState<TNode extends AnyTreeNodePrimitive> {
 /**
  * The state type for trees - a flat array of nodes
  */
-export type TreeState<TRoot extends AnyTreeNodePrimitive> = readonly TreeNodeState[];
+export type TreeState<_TRoot extends AnyTreeNodePrimitive> = readonly TreeNodeState[];
 
 /**
  * Helper to get children sorted by position
@@ -105,6 +106,30 @@ export type TreeNodeSnapshot<TNode extends AnyTreeNodePrimitive> = {
 export type InferTreeSnapshot<T extends TreePrimitive<any>> =
   T extends TreePrimitive<infer TRoot> ? TreeNodeSnapshot<TRoot> : never;
 
+/**
+ * Helper type to infer the update value type from a TreeNode's data.
+ * Uses StructUpdateValue directly to get field-level partial update semantics.
+ * All fields are optional in update operations.
+ */
+export type TreeNodeUpdateValue<TNode extends AnyTreeNodePrimitive> = 
+  TNode["data"] extends StructPrimitive<infer TFields, any, any>
+    ? StructUpdateValue<TFields>
+    : InferUpdateInput<TNode["data"]>;
+
+/**
+ * Helper type to infer the input type for node data (respects field defaults).
+ * Uses StructSetInput directly so that:
+ * - Fields that are required AND have no default must be provided
+ * - Fields that are optional OR have defaults can be omitted
+ * 
+ * This bypasses the struct-level NeedsValue wrapper since tree inserts
+ * always require a data object (even if empty for all-optional fields).
+ */
+export type TreeNodeDataSetInput<TNode extends AnyTreeNodePrimitive> = 
+  TNode["data"] extends StructPrimitive<infer TFields, any, any>
+    ? StructSetInput<TFields>
+    : InferSetInput<TNode["data"]>;
+
 /**
  * Typed proxy for a specific node type - provides type-safe data access
  */
@@ -117,12 +142,14 @@ export interface TypedNodeProxy<TNode extends AnyTreeNodePrimitive> {
   readonly data: InferProxy<TNode["data"]>;
   /** Get the raw node state */
   get(): TypedTreeNodeState<TNode>;
+  /** Updates only the specified data fields (partial update, handles nested structs recursively) */
+  update(value: TreeNodeUpdateValue<TNode>): void;
 }
 
 /**
  * Node proxy with type narrowing capabilities
  */
-export interface TreeNodeProxyBase<TRoot extends AnyTreeNodePrimitive> {
+export interface TreeNodeProxyBase<_TRoot extends AnyTreeNodePrimitive> {
   /** The node ID */
   readonly id: string;
   /** The node type (string) */
@@ -158,40 +185,40 @@ export interface TreeProxy<TRoot extends AnyTreeNodePrimitive> {
   /** Gets a node proxy by ID with type narrowing capabilities */
   node(id: string): TreeNodeProxyBase<TRoot> | undefined;
   
-  /** Insert a new node as the first child */
+  /** Insert a new node as the first child (applies defaults for node data) */
   insertFirst<TNode extends AnyTreeNodePrimitive>(
     parentId: string | null,
     nodeType: TNode,
-    data: InferTreeNodeDataState<TNode>
+    data: TreeNodeDataSetInput<TNode>
   ): string;
   
-  /** Insert a new node as the last child */
+  /** Insert a new node as the last child (applies defaults for node data) */
   insertLast<TNode extends AnyTreeNodePrimitive>(
     parentId: string | null,
     nodeType: TNode,
-    data: InferTreeNodeDataState<TNode>
+    data: TreeNodeDataSetInput<TNode>
   ): string;
   
-  /** Insert a new node at a specific index among siblings */
+  /** Insert a new node at a specific index among siblings (applies defaults for node data) */
   insertAt<TNode extends AnyTreeNodePrimitive>(
     parentId: string | null,
     index: number,
     nodeType: TNode,
-    data: InferTreeNodeDataState<TNode>
+    data: TreeNodeDataSetInput<TNode>
   ): string;
   
-  /** Insert a new node after a sibling */
+  /** Insert a new node after a sibling (applies defaults for node data) */
   insertAfter<TNode extends AnyTreeNodePrimitive>(
     siblingId: string,
     nodeType: TNode,
-    data: InferTreeNodeDataState<TNode>
+    data: TreeNodeDataSetInput<TNode>
   ): string;
   
-  /** Insert a new node before a sibling */
+  /** Insert a new node before a sibling (applies defaults for node data) */
   insertBefore<TNode extends AnyTreeNodePrimitive>(
     siblingId: string,
     nodeType: TNode,
-    data: InferTreeNodeDataState<TNode>
+    data: TreeNodeDataSetInput<TNode>
   ): string;
   
   /** Remove a node and all its descendants */
@@ -218,6 +245,13 @@ export interface TreeProxy<TRoot extends AnyTreeNodePrimitive> {
     nodeType: TNode
   ): InferProxy<TNode["data"]>;
   
+  /** Updates only the specified data fields of a node (partial update) */
+  updateAt<TNode extends AnyTreeNodePrimitive>(
+    id: string,
+    nodeType: TNode,
+    value: TreeNodeUpdateValue<TNode>
+  ): void;
+  
   /** Convert tree to a nested snapshot for UI rendering */
   toSnapshot(): TreeNodeSnapshot<TRoot> | undefined;
 }
@@ -229,12 +263,22 @@ interface TreePrimitiveSchema<TRoot extends AnyTreeNodePrimitive> {
   readonly validators: readonly Validator<TreeState<TRoot>>[];
 }
 
-export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
-  implements Primitive<TreeState<TRoot>, TreeProxy<TRoot>>
+/** Input type for tree set() - tree state */
+export type TreeSetInput<TRoot extends AnyTreeNodePrimitive> = TreeState<TRoot>;
+
+/** Input type for tree update() - same as set() for trees */
+export type TreeUpdateInput<TRoot extends AnyTreeNodePrimitive> = TreeState<TRoot>;
+
+export class TreePrimitive<TRoot extends AnyTreeNodePrimitive, TRequired extends boolean = false, THasDefault extends boolean = false>
+  implements Primitive<TreeState<TRoot>, TreeProxy<TRoot>, TRequired, THasDefault, TreeSetInput<TRoot>, TreeUpdateInput<TRoot>>
 {
   readonly _tag = "TreePrimitive" as const;
   readonly _State!: TreeState<TRoot>;
   readonly _Proxy!: TreeProxy<TRoot>;
+  readonly _TRequired!: TRequired;
+  readonly _THasDefault!: THasDefault;
+  readonly TSetInput!: TreeSetInput<TRoot>;
+  readonly TUpdateInput!: TreeUpdateInput<TRoot>;
 
   private readonly _schema: TreePrimitiveSchema<TRoot>;
   private _nodeTypeRegistry: Map<string, AnyTreeNodePrimitive> | undefined;
@@ -271,7 +315,7 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
   }
 
   /** Mark this tree as required */
-  required(): TreePrimitive<TRoot> {
+  required(): TreePrimitive<TRoot, true, THasDefault> {
     return new TreePrimitive({
       ...this._schema,
       required: true,
@@ -279,7 +323,7 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
   }
 
   /** Set a default value for this tree */
-  default(defaultValue: TreeState<TRoot>): TreePrimitive<TRoot> {
+  default(defaultValue: TreeState<TRoot>): TreePrimitive<TRoot, TRequired, true> {
     return new TreePrimitive({
       ...this._schema,
       defaultValue,
@@ -292,7 +336,7 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
   }
 
   /** Add a custom validation rule */
-  refine(fn: (value: TreeState<TRoot>) => boolean, message: string): TreePrimitive<TRoot> {
+  refine(fn: (value: TreeState<TRoot>) => boolean, message: string): TreePrimitive<TRoot, TRequired, THasDefault> {
     return new TreePrimitive({
       ...this._schema,
       validators: [...this._schema.validators, { validate: fn, message }],
@@ -404,11 +448,16 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
               );
             }
             const nodePath = operationPath.append(nodeState.id);
+            const dataProxy = nodeType.data._internal.createProxy(env, nodePath) as InferProxy<TNode["data"]>;
             return {
               id: nodeState.id,
               type: nodeType.type as InferTreeNodeType<TNode>,
-              data: nodeType.data._internal.createProxy(env, nodePath) as InferProxy<TNode["data"]>,
+              data: dataProxy,
               get: () => nodeState as TypedTreeNodeState<TNode>,
+              update: (value: TreeNodeUpdateValue<TNode>) => {
+                // Delegate to the data proxy's update method
+                (dataProxy as { update: (v: unknown) => void }).update(value);
+              },
             };
           },
           
@@ -474,7 +523,7 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
         insertFirst: <TNode extends AnyTreeNodePrimitive>(
           parentId: string | null,
           nodeType: TNode,
-          data: InferTreeNodeDataState<TNode>
+          data: TreeNodeDataSetInput<TNode>
         ): string => {
           const state = getCurrentState();
           const siblings = getOrderedChildren(state, parentId);
@@ -496,13 +545,16 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
             throw new ValidationError("Tree already has a root node");
           }
 
+          // Apply defaults to node data
+          const mergedData = applyDefaults(nodeType.data as AnyPrimitive, data as Partial<InferTreeNodeDataState<TNode>>) as InferTreeNodeDataState<TNode>;
+
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.insert, {
               id,
               type: nodeType.type,
               parentId,
               pos,
-              data,
+              data: mergedData,
             })
           );
 
@@ -512,7 +564,7 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
         insertLast: <TNode extends AnyTreeNodePrimitive>(
           parentId: string | null,
           nodeType: TNode,
-          data: InferTreeNodeDataState<TNode>
+          data: TreeNodeDataSetInput<TNode>
         ): string => {
           const state = getCurrentState();
           const siblings = getOrderedChildren(state, parentId);
@@ -534,13 +586,16 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
             throw new ValidationError("Tree already has a root node");
           }
 
+          // Apply defaults to node data
+          const mergedData = applyDefaults(nodeType.data as AnyPrimitive, data as Partial<InferTreeNodeDataState<TNode>>) as InferTreeNodeDataState<TNode>;
+
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.insert, {
               id,
               type: nodeType.type,
               parentId,
               pos,
-              data,
+              data: mergedData,
             })
           );
 
@@ -551,7 +606,7 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
           parentId: string | null,
           index: number,
           nodeType: TNode,
-          data: InferTreeNodeDataState<TNode>
+          data: TreeNodeDataSetInput<TNode>
         ): string => {
           const state = getCurrentState();
           const siblings = getOrderedChildren(state, parentId);
@@ -575,13 +630,16 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
             throw new ValidationError("Tree already has a root node");
           }
 
+          // Apply defaults to node data
+          const mergedData = applyDefaults(nodeType.data as AnyPrimitive, data as Partial<InferTreeNodeDataState<TNode>>) as InferTreeNodeDataState<TNode>;
+
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.insert, {
               id,
               type: nodeType.type,
               parentId,
               pos,
-              data,
+              data: mergedData,
             })
           );
 
@@ -591,7 +649,7 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
         insertAfter: <TNode extends AnyTreeNodePrimitive>(
           siblingId: string,
           nodeType: TNode,
-          data: InferTreeNodeDataState<TNode>
+          data: TreeNodeDataSetInput<TNode>
         ): string => {
           const state = getCurrentState();
           const sibling = state.find(n => n.id === siblingId);
@@ -610,13 +668,16 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
           const parentType = getParentType(parentId);
           this._validateChildType(parentType, nodeType.type);
 
+          // Apply defaults to node data
+          const mergedData = applyDefaults(nodeType.data as AnyPrimitive, data as Partial<InferTreeNodeDataState<TNode>>) as InferTreeNodeDataState<TNode>;
+
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.insert, {
               id,
               type: nodeType.type,
               parentId,
               pos,
-              data,
+              data: mergedData,
             })
           );
 
@@ -626,7 +687,7 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
         insertBefore: <TNode extends AnyTreeNodePrimitive>(
           siblingId: string,
           nodeType: TNode,
-          data: InferTreeNodeDataState<TNode>
+          data: TreeNodeDataSetInput<TNode>
         ): string => {
           const state = getCurrentState();
           const sibling = state.find(n => n.id === siblingId);
@@ -645,13 +706,16 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
           const parentType = getParentType(parentId);
           this._validateChildType(parentType, nodeType.type);
 
+          // Apply defaults to node data
+          const mergedData = applyDefaults(nodeType.data as AnyPrimitive, data as Partial<InferTreeNodeDataState<TNode>>) as InferTreeNodeDataState<TNode>;
+
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.insert, {
               id,
               type: nodeType.type,
               parentId,
               pos,
-              data,
+              data: mergedData,
             })
           );
 
@@ -890,6 +954,29 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive>
           return nodeType.data._internal.createProxy(env, nodePath) as InferProxy<TNode["data"]>;
         },
 
+        updateAt: <TNode extends AnyTreeNodePrimitive>(
+          id: string,
+          nodeType: TNode,
+          value: TreeNodeUpdateValue<TNode>
+        ): void => {
+          // Get the node to verify its type
+          const state = getCurrentState();
+          const node = state.find(n => n.id === id);
+          if (!node) {
+            throw new ValidationError(`Node not found: ${id}`);
+          }
+          if (node.type !== nodeType.type) {
+            throw new ValidationError(
+              `Node is of type "${node.type}", not "${nodeType.type}"`
+            );
+          }
+
+          const nodePath = operationPath.append(id);
+          const dataProxy = nodeType.data._internal.createProxy(env, nodePath);
+          // Delegate to the data proxy's update method
+          (dataProxy as { update: (v: unknown) => void }).update(value);
+        },
+
         toSnapshot: (): TreeNodeSnapshot<TRoot> | undefined => {
           const state = getCurrentState();
           const rootNode = state.find(n => n.parentId === null);
@@ -1111,7 +1198,7 @@ export interface TreeOptions<TRoot extends AnyTreeNodePrimitive> {
 /** Creates a new TreePrimitive with the given root node type */
 export const Tree = <TRoot extends AnyTreeNodePrimitive>(
   options: TreeOptions<TRoot>
-): TreePrimitive<TRoot> =>
+): TreePrimitive<TRoot, false, false> =>
   new TreePrimitive({
     required: false,
     defaultValue: undefined,