@voidhash/mimic 0.0.1-alpha.7 → 0.0.1-alpha.8

package/src/primitives/Number.ts

@@ -4,18 +4,22 @@ 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 } from "../Primitive";
-import { ValidationError } from "../Primitive";
-import { runValidators, isCompatibleOperation } from "./shared";
+import type { Primitive, PrimitiveInternal, MaybeUndefined, AnyPrimitive, Validator, NeedsValue } from "./shared";
+import { ValidationError, runValidators, isCompatibleOperation } from "./shared";
 
 
-export interface NumberProxy<TDefined extends boolean = false> {
+type InferSetInput<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<number, TRequired, THasDefault>
+type InferUpdateInput<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<number, TRequired, THasDefault>
+
+export interface NumberProxy<TRequired extends boolean = false, THasDefault extends boolean = false> {
   /** Gets the current number value */
-  get(): MaybeUndefined<number, TDefined>;
+  get(): MaybeUndefined<number, TRequired, THasDefault>;
   /** Sets the number value, generating a number.set operation */
-  set(value: number): void;
+  set(value: InferSetInput<TRequired, THasDefault>): void;
+  /** This is the same as set. Updates the number value, generating a number.set operation */
+  update(value: InferUpdateInput<TRequired, THasDefault>): void;
   /** Returns a readonly snapshot of the number value for rendering */
-  toSnapshot(): MaybeUndefined<number, TDefined>;
+  toSnapshot(): MaybeUndefined<number, TRequired, THasDefault>;
 }
 
 interface NumberPrimitiveSchema {
@@ -24,12 +28,14 @@ interface NumberPrimitiveSchema {
   readonly validators: readonly Validator<number>[];
 }
 
-export class NumberPrimitive<TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<number, NumberProxy<TDefined>, TDefined, THasDefault> {
+export class NumberPrimitive<TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<number, NumberProxy<TRequired, THasDefault>, TRequired, THasDefault, InferSetInput<TRequired, THasDefault>, InferUpdateInput<TRequired, THasDefault>> {
   readonly _tag = "NumberPrimitive" as const;
   readonly _State!: number;
-  readonly _Proxy!: NumberProxy<TDefined>;
-  readonly _TDefined!: TDefined;
+  readonly _Proxy!: NumberProxy<TRequired, THasDefault>;
+  readonly _TRequired!: TRequired;
   readonly _THasDefault!: THasDefault;
+  readonly TUpdateInput!: InferUpdateInput<TRequired, THasDefault>;
+  readonly TSetInput!: InferSetInput<TRequired, THasDefault>;
 
   private readonly _schema: NumberPrimitiveSchema;
 
@@ -55,7 +61,7 @@ export class NumberPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Set a default value for this number */
-  default(defaultValue: number): NumberPrimitive<true, true> {
+  default(defaultValue: number): NumberPrimitive<TRequired, true> {
     return new NumberPrimitive({
       ...this._schema,
       defaultValue,
@@ -63,7 +69,7 @@ export class NumberPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Add a custom validation rule */
-  refine(fn: (value: number) => boolean, message: string): NumberPrimitive<TDefined, THasDefault> {
+  refine(fn: (value: number) => boolean, message: string): NumberPrimitive<TRequired, THasDefault> {
     return new NumberPrimitive({
       ...this._schema,
       validators: [...this._schema.validators, { validate: fn, message }],
@@ -71,7 +77,7 @@ export class NumberPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Minimum value (inclusive) */
-  min(value: number): NumberPrimitive<TDefined, THasDefault> {
+  min(value: number): NumberPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v >= value,
       `Number must be at least ${value}`
@@ -79,7 +85,7 @@ export class NumberPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Maximum value (inclusive) */
-  max(value: number): NumberPrimitive<TDefined, THasDefault> {
+  max(value: number): NumberPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v <= value,
       `Number must be at most ${value}`
@@ -87,7 +93,7 @@ export class NumberPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Must be positive (> 0) */
-  positive(): NumberPrimitive<TDefined, THasDefault> {
+  positive(): NumberPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v > 0,
       "Number must be positive"
@@ -95,7 +101,7 @@ export class NumberPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Must be negative (< 0) */
-  negative(): NumberPrimitive<TDefined, THasDefault> {
+  negative(): NumberPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v < 0,
       "Number must be negative"
@@ -103,29 +109,34 @@ export class NumberPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Must be an integer */
-  int(): NumberPrimitive<TDefined, THasDefault> {
+  int(): NumberPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => globalThis.Number.isInteger(v),
       "Number must be an integer"
     );
   }
 
-  readonly _internal: PrimitiveInternal<number, NumberProxy<TDefined>> = {
-    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): NumberProxy<TDefined> => {
+  readonly _internal: PrimitiveInternal<number, NumberProxy<TRequired, THasDefault>> = {
+    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): NumberProxy<TRequired, THasDefault> => {
       const defaultValue = this._schema.defaultValue;
       return {
-        get: (): MaybeUndefined<number, TDefined> => {
+        get: (): MaybeUndefined<number, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as number | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<number, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<number, TRequired, THasDefault>;
+        },
+        set: (value: InferSetInput<TRequired, THasDefault>) => {
+          env.addOperation(
+            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
+          );
         },
-        set: (value: number) => {
+        update: (value: InferUpdateInput<TRequired, THasDefault>) => {
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
           );
         },
-        toSnapshot: (): MaybeUndefined<number, TDefined> => {
+        toSnapshot: (): MaybeUndefined<number, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as number | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<number, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<number, TRequired, THasDefault>;
         },
       };
     },

package/src/primitives/String.ts

@@ -4,20 +4,26 @@ 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, Validator } from "./shared";
+import type { Primitive, PrimitiveInternal, MaybeUndefined, Validator, NeedsValue } from "./shared";
 import { runValidators, isCompatibleOperation, ValidationError } from "./shared";
 
+
+type InferSetInput<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<string, TRequired, THasDefault>
+type InferUpdateInput<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<string, TRequired, THasDefault>
+
 // =============================================================================
 // String Primitive
 // =============================================================================
 
-export interface StringProxy<TDefined extends boolean = false> {
+export interface StringProxy<TRequired extends boolean = false, THasDefault extends boolean = false> {
   /** Gets the current string value */
-  get(): MaybeUndefined<string, TDefined>;
+  get(): MaybeUndefined<string, TRequired, THasDefault>;
   /** Sets the string value, generating a string.set operation */
-  set(value: string): void;
+  set(value: InferSetInput<TRequired, THasDefault>): void;
+  /** This is the same as set. Updates the string value, generating a string.set operation */
+  update(value: InferUpdateInput<TRequired, THasDefault>): void;
   /** Returns a readonly snapshot of the string value for rendering */
-  toSnapshot(): MaybeUndefined<string, TDefined>;
+  toSnapshot(): MaybeUndefined<string, TRequired, THasDefault>;
 }
 
 interface StringPrimitiveSchema {
@@ -26,12 +32,14 @@ interface StringPrimitiveSchema {
   readonly validators: readonly Validator<string>[];
 }
 
-export class StringPrimitive<TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<string, StringProxy<TDefined>, TDefined, THasDefault> {
+export class StringPrimitive<TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<string, StringProxy<TRequired, THasDefault>, TRequired, THasDefault, InferSetInput<TRequired, THasDefault>, InferUpdateInput<TRequired, THasDefault>> {
   readonly _tag = "StringPrimitive" as const;
   readonly _State!: string;
-  readonly _Proxy!: StringProxy<TDefined>;
-  readonly _TDefined!: TDefined;
+  readonly _Proxy!: StringProxy<TRequired, THasDefault>;
+  readonly _TRequired!: TRequired;
   readonly _THasDefault!: THasDefault;
+  readonly TUpdateInput!: InferUpdateInput<TRequired, THasDefault>;
+  readonly TSetInput!: InferSetInput<TRequired, THasDefault>;
 
   private readonly _schema: StringPrimitiveSchema;
 
@@ -57,7 +65,7 @@ export class StringPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Set a default value for this string */
-  default(defaultValue: string): StringPrimitive<true, true> {
+  default(defaultValue: string): StringPrimitive<TRequired, true> {
     return new StringPrimitive({
       ...this._schema,
       defaultValue,
@@ -65,7 +73,7 @@ export class StringPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Add a custom validation rule */
-  refine(fn: (value: string) => boolean, message: string): StringPrimitive<TDefined, THasDefault> {
+  refine(fn: (value: string) => boolean, message: string): StringPrimitive<TRequired, THasDefault> {
     return new StringPrimitive({
       ...this._schema,
       validators: [...this._schema.validators, { validate: fn, message }],
@@ -73,7 +81,7 @@ export class StringPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Minimum string length */
-  min(length: number): StringPrimitive<TDefined, THasDefault> {
+  min(length: number): StringPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v.length >= length,
       `String must be at least ${length} characters`
@@ -81,7 +89,7 @@ export class StringPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Maximum string length */
-  max(length: number): StringPrimitive<TDefined, THasDefault> {
+  max(length: number): StringPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v.length <= length,
       `String must be at most ${length} characters`
@@ -89,7 +97,7 @@ export class StringPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Exact string length */
-  length(exact: number): StringPrimitive<TDefined, THasDefault> {
+  length(exact: number): StringPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => v.length === exact,
       `String must be exactly ${exact} characters`
@@ -97,7 +105,7 @@ export class StringPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Match a regex pattern */
-  regex(pattern: RegExp, message?: string): StringPrimitive<TDefined, THasDefault> {
+  regex(pattern: RegExp, message?: string): StringPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => pattern.test(v),
       message ?? `String must match pattern ${pattern}`
@@ -105,7 +113,7 @@ export class StringPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Validate as email format */
-  email(): StringPrimitive<TDefined, THasDefault> {
+  email(): StringPrimitive<TRequired, THasDefault> {
     // Simple email regex - covers most common cases
     const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
     return this.refine(
@@ -115,7 +123,7 @@ export class StringPrimitive<TDefined extends boolean = false, THasDefault exten
   }
 
   /** Validate as URL format */
-  url(): StringPrimitive<TDefined, THasDefault> {
+  url(): StringPrimitive<TRequired, THasDefault> {
     return this.refine(
       (v) => {
         try {
@@ -129,22 +137,27 @@ export class StringPrimitive<TDefined extends boolean = false, THasDefault exten
     );
   }
 
-  readonly _internal: PrimitiveInternal<string, StringProxy<TDefined>> = {
-    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): StringProxy<TDefined> => {
+  readonly _internal: PrimitiveInternal<string, StringProxy<TRequired, THasDefault>> = {
+    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): StringProxy<TRequired, THasDefault> => {
       const defaultValue = this._schema.defaultValue;
       return {
-        get: (): MaybeUndefined<string, TDefined> => {
+        get: (): MaybeUndefined<string, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as string | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<string, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<string, TRequired, THasDefault>;
+        },
+        set: (value: InferSetInput<TRequired, THasDefault>) => {
+          env.addOperation(
+            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
+          );
         },
-        set: (value: string) => {
+        update: (value: InferUpdateInput<TRequired, THasDefault>) => {
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
           );
         },
-        toSnapshot: (): MaybeUndefined<string, TDefined> => {
+        toSnapshot: (): MaybeUndefined<string, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as string | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<string, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<string, TRequired, THasDefault>;
         },
       };
     },

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, applyDefaults, StructSetInput } 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>;
 
 
 /**
@@ -27,29 +75,27 @@ export type InferStructSnapshot<TFields extends Record<string, AnyPrimitive>> =
 
 /**
  * Maps a schema definition to a partial update type.
- * For nested structs, allows recursive partial updates.
+ * Uses each field's TUpdateInput type, which handles nested updates recursively.
  */
 export type StructUpdateValue<TFields extends Record<string, AnyPrimitive>> = {
-  readonly [K in keyof TFields]?: TFields[K] extends StructPrimitive<infer F, any>
-    ? StructUpdateValue<F> | InferState<TFields[K]>
-    : InferState<TFields[K]>;
+  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>;
+  get(): MaybeUndefined<InferStructState<TFields>, TRequired, THasDefault>;
   /** Sets the entire struct value (only fields that are required without defaults must be provided) */
-  set(value: StructSetInput<TFields>): void;
+  set(value: InferStructSetInput<TFields, TRequired, THasDefault>): void;
   /** Updates only the specified fields (partial update, handles nested structs recursively) */
-  update(value: StructUpdateValue<TFields>): void;
+  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>> {
@@ -59,14 +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, THasDefault extends boolean = false>
-  implements Primitive<InferStructState<TFields>, StructProxy<TFields, TDefined>, TDefined, THasDefault>
+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 _TDefined!: 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>;
 
@@ -92,7 +140,7 @@ export class StructPrimitive<TFields extends Record<string, AnyPrimitive>, TDefi
   }
 
   /** Set a default value for this struct */
-  default(defaultValue: StructSetInput<TFields>): StructPrimitive<TFields, true, 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({
@@ -107,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, THasDefault> {
+  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;
 
@@ -148,18 +196,18 @@ export class StructPrimitive<TFields extends Record<string, AnyPrimitive>, TDefi
 
       // 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: StructSetInput<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, merged)
           );
         },
-        update: (value: StructUpdateValue<TFields>) => {
+        update: (value: InferStructUpdateInput<TFields>) => {
           for (const key in value) {
             if (Object.prototype.hasOwnProperty.call(value, key)) {
               const fieldValue = value[key as keyof TFields];
@@ -187,14 +235,14 @@ export class StructPrimitive<TFields extends Record<string, AnyPrimitive>, TDefi
             }
           }
         },
-        toSnapshot: (): MaybeUndefined<InferStructSnapshot<TFields>, TDefined> => {
+        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>, {
+      return new globalThis.Proxy(base as StructProxy<TFields, TRequired, THasDefault>, {
         get: (target, prop, _receiver) => {
           // Return base methods (get, set, update, toSnapshot)
           if (prop === "get") {

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, AnyPrimitive, StructSetInput } 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, StructUpdateValue, StructPrimitive } from "./Struct";
+import { InferStructState, StructSetInput, StructUpdateValue } from "./Struct";
+import { StructPrimitive } from "./Struct";
 
 
 /**
@@ -106,21 +107,28 @@ 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
+ * 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> =
+export type TreeNodeUpdateValue<TNode extends AnyTreeNodePrimitive> = 
   TNode["data"] extends StructPrimitive<infer TFields, any, any>
     ? StructUpdateValue<TFields>
-    : never;
+    : InferUpdateInput<TNode["data"]>;
 
 /**
- * Helper type to infer the input type for node data (with defaults applied).
- * Uses StructSetInput for struct data, making fields with defaults optional.
+ * 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> =
+export type TreeNodeDataSetInput<TNode extends AnyTreeNodePrimitive> = 
   TNode["data"] extends StructPrimitive<infer TFields, any, any>
     ? StructSetInput<TFields>
-    : InferTreeNodeDataState<TNode>;
+    : InferSetInput<TNode["data"]>;
 
 /**
  * Typed proxy for a specific node type - provides type-safe data access
@@ -255,14 +263,22 @@ interface TreePrimitiveSchema<TRoot extends AnyTreeNodePrimitive> {
   readonly validators: readonly Validator<TreeState<TRoot>>[];
 }
 
-export class TreePrimitive<TRoot extends AnyTreeNodePrimitive, TDefined extends boolean = false, THasDefault extends boolean = false>
-  implements Primitive<TreeState<TRoot>, TreeProxy<TRoot>, TDefined, THasDefault>
+/** 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 _TDefined!: TDefined;
+  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;
@@ -307,7 +323,7 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive, TDefined extends
   }
 
   /** Set a default value for this tree */
-  default(defaultValue: TreeState<TRoot>): TreePrimitive<TRoot, true, true> {
+  default(defaultValue: TreeState<TRoot>): TreePrimitive<TRoot, TRequired, true> {
     return new TreePrimitive({
       ...this._schema,
       defaultValue,
@@ -320,7 +336,7 @@ export class TreePrimitive<TRoot extends AnyTreeNodePrimitive, TDefined extends
   }
 
   /** Add a custom validation rule */
-  refine(fn: (value: TreeState<TRoot>) => boolean, message: string): TreePrimitive<TRoot, TDefined, THasDefault> {
+  refine(fn: (value: TreeState<TRoot>) => boolean, message: string): TreePrimitive<TRoot, TRequired, THasDefault> {
     return new TreePrimitive({
       ...this._schema,
       validators: [...this._schema.validators, { validate: fn, message }],