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

package/dist/server/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["Document.make","_transactionOrder: string[]","Transaction.isEmpty"],"sources":["../../src/server/ServerDocument.ts","../../src/server/errors.ts"],"sourcesContent":["import * as Document from \"../Document\";\nimport * as Transaction from \"../Transaction\";\nimport type * as Primitive from \"../Primitive\";\n\n// =============================================================================\n// Server Message Types (matching client's Transport expectations)\n// =============================================================================\n\n/**\n * Message sent when broadcasting a committed transaction.\n */\nexport interface TransactionMessage {\n  readonly type: \"transaction\";\n  readonly transaction: Transaction.Transaction;\n  /** Server-assigned version number for ordering */\n  readonly version: number;\n}\n\n/**\n * Message sent when a transaction is rejected.\n */\nexport interface ErrorMessage {\n  readonly type: \"error\";\n  readonly transactionId: string;\n  readonly reason: string;\n}\n\n/**\n * Message sent as a full state snapshot.\n */\nexport interface SnapshotMessage {\n  readonly type: \"snapshot\";\n  readonly state: unknown;\n  readonly version: number;\n}\n\n/**\n * Union of all server messages that can be broadcast.\n */\nexport type ServerMessage = TransactionMessage | ErrorMessage | SnapshotMessage;\n\n// =============================================================================\n// Submit Result Types\n// =============================================================================\n\n/**\n * Result of submitting a transaction to the server.\n */\nexport type SubmitResult =\n  | { readonly success: true; readonly version: number }\n  | { readonly success: false; readonly reason: string };\n\n// =============================================================================\n// Server Document Types\n// =============================================================================\n\n/**\n * Options for creating a ServerDocument.\n */\nexport interface ServerDocumentOptions<TSchema extends Primitive.AnyPrimitive> {\n  /** The schema defining the document structure */\n  readonly schema: TSchema;\n  /** Initial state (optional, will use schema defaults if not provided) */\n  readonly initialState?: Primitive.InferState<TSchema>;\n  /** Initial version number (optional, defaults to 0) */\n  readonly initialVersion?: number;\n  /** Called when a transaction is successfully applied and should be broadcast */\n  readonly onBroadcast: (message: TransactionMessage) => void;\n  /** Called when a transaction is rejected (optional, for logging/metrics) */\n  readonly onRejection?: (transactionId: string, reason: string) => void;\n  /** Maximum number of processed transaction IDs to track for deduplication */\n  readonly maxTransactionHistory?: number;\n}\n\n/**\n * A ServerDocument maintains the authoritative state and processes client transactions.\n */\nexport interface ServerDocument<TSchema extends Primitive.AnyPrimitive> {\n  /** The schema defining this document's structure */\n  readonly schema: TSchema;\n\n  /** Returns the current authoritative state */\n  get(): Primitive.InferState<TSchema> | undefined;\n\n  /** Returns the current version number */\n  getVersion(): number;\n\n  /**\n   * Submits a transaction for processing.\n   * Validates and applies the transaction if valid, or rejects it with a reason.\n   * @param transaction - The transaction to process\n   * @returns SubmitResult indicating success with version or failure with reason\n   */\n  submit(transaction: Transaction.Transaction): SubmitResult;\n\n  /**\n   * Returns a snapshot of the current state and version.\n   * Used to initialize new clients or resync after drift.\n   */\n  getSnapshot(): SnapshotMessage;\n\n  /**\n   * Checks if a transaction has already been processed.\n   * @param transactionId - The transaction ID to check\n   */\n  hasProcessed(transactionId: string): boolean;\n}\n\n// =============================================================================\n// Server Document Implementation\n// =============================================================================\n\n/**\n * Creates a new ServerDocument for the given schema.\n */\nexport const make = <TSchema extends Primitive.AnyPrimitive>(\n  options: ServerDocumentOptions<TSchema>\n): ServerDocument<TSchema> => {\n  const {\n    schema,\n    initialState,\n    initialVersion = 0,\n    onBroadcast,\n    onRejection,\n    maxTransactionHistory = 1000,\n  } = options;\n\n  // ==========================================================================\n  // Internal State\n  // ==========================================================================\n\n  // The authoritative document\n  let _document = Document.make(schema, { initial: initialState });\n\n  // Current version number (incremented on each successful transaction)\n  let _version = initialVersion;\n\n  // Track processed transaction IDs for deduplication\n  const _processedTransactions = new Set<string>();\n  const _transactionOrder: string[] = [];\n\n  // ==========================================================================\n  // Helper Functions\n  // ==========================================================================\n\n  /**\n   * Records a transaction as processed, maintaining the history limit.\n   */\n  const recordTransaction = (transactionId: string): void => {\n    _processedTransactions.add(transactionId);\n    _transactionOrder.push(transactionId);\n\n    // Evict oldest transactions if over limit\n    while (_transactionOrder.length > maxTransactionHistory) {\n      const oldest = _transactionOrder.shift();\n      if (oldest) {\n        _processedTransactions.delete(oldest);\n      }\n    }\n  };\n\n  /**\n   * Validates that the transaction can be applied to the current state.\n   * Creates a temporary document and attempts to apply the operations.\n   */\n  const validateTransaction = (\n    transaction: Transaction.Transaction\n  ): { valid: true } | { valid: false; reason: string } => {\n    // Check for empty transaction\n    if (Transaction.isEmpty(transaction)) {\n      return { valid: false, reason: \"Transaction is empty\" };\n    }\n\n    // Check for duplicate transaction\n    if (_processedTransactions.has(transaction.id)) {\n      return { valid: false, reason: \"Transaction has already been processed\" };\n    }\n\n    // Create a temporary document with current state to test the operations\n    const currentState = _document.get();\n    const tempDoc = Document.make(schema, { initial: currentState });\n\n    try {\n      // Attempt to apply all operations\n      tempDoc.apply(transaction.ops);\n      return { valid: true };\n    } catch (error) {\n      // Operations failed to apply\n      const message = error instanceof Error ? error.message : String(error);\n      return { valid: false, reason: message };\n    }\n  };\n\n  // ==========================================================================\n  // Public API\n  // ==========================================================================\n\n  const serverDocument: ServerDocument<TSchema> = {\n    schema,\n\n    get: (): Primitive.InferState<TSchema> | undefined => {\n      return _document.get();\n    },\n\n    getVersion: (): number => {\n      return _version;\n    },\n\n    submit: (transaction: Transaction.Transaction): SubmitResult => {\n      // Validate the transaction\n      const validation = validateTransaction(transaction);\n\n      if (!validation.valid) {\n        // Notify rejection callback if provided\n        onRejection?.(transaction.id, validation.reason);\n\n        return {\n          success: false,\n          reason: validation.reason,\n        };\n      }\n\n      // Apply the transaction to the authoritative state\n      try {\n        _document.apply(transaction.ops);\n      } catch (error) {\n        // This shouldn't happen since we validated, but handle gracefully\n        const reason = error instanceof Error ? error.message : String(error);\n        onRejection?.(transaction.id, reason);\n        return { success: false, reason };\n      }\n\n      // Increment version\n      _version += 1;\n\n      // Record as processed\n      recordTransaction(transaction.id);\n\n      // Broadcast the confirmed transaction\n      const message: TransactionMessage = {\n        type: \"transaction\",\n        transaction,\n        version: _version,\n      };\n      onBroadcast(message);\n\n      return {\n        success: true,\n        version: _version,\n      };\n    },\n\n    getSnapshot: (): SnapshotMessage => {\n      return {\n        type: \"snapshot\",\n        state: _document.get(),\n        version: _version,\n      };\n    },\n\n    hasProcessed: (transactionId: string): boolean => {\n      return _processedTransactions.has(transactionId);\n    },\n  };\n\n  return serverDocument;\n};\n","import type * as Transaction from \"../Transaction\";\n\n// =============================================================================\n// Server Errors\n// =============================================================================\n\n/**\n * Base error class for all mimic-server errors.\n */\nexport class MimicServerError extends Error {\n  readonly _tag: string = \"MimicServerError\";\n  constructor(message: string) {\n    super(message);\n    this.name = \"MimicServerError\";\n  }\n}\n\n/**\n * Error thrown when a transaction fails validation.\n */\nexport class ValidationError extends MimicServerError {\n  override readonly _tag = \"ValidationError\";\n  readonly transactionId: string;\n\n  constructor(transactionId: string, message: string) {\n    super(`Transaction ${transactionId} validation failed: ${message}`);\n    this.name = \"ValidationError\";\n    this.transactionId = transactionId;\n  }\n}\n\n/**\n * Error thrown when an operation is invalid for the current schema.\n */\nexport class InvalidOperationError extends MimicServerError {\n  override readonly _tag = \"InvalidOperationError\";\n  readonly operationKind: string;\n  readonly path: string;\n\n  constructor(operationKind: string, path: string, message: string) {\n    super(`Invalid operation ${operationKind} at path \"${path}\": ${message}`);\n    this.name = \"InvalidOperationError\";\n    this.operationKind = operationKind;\n    this.path = path;\n  }\n}\n\n/**\n * Error thrown when an operation cannot be applied to the current state.\n */\nexport class StateValidationError extends MimicServerError {\n  override readonly _tag = \"StateValidationError\";\n  readonly transactionId: string;\n  override readonly cause?: Error;\n\n  constructor(transactionId: string, message: string, cause?: Error) {\n    super(`Transaction ${transactionId} cannot be applied to current state: ${message}`);\n    this.name = \"StateValidationError\";\n    this.transactionId = transactionId;\n    this.cause = cause;\n  }\n}\n\n/**\n * Error thrown when attempting to apply an empty transaction.\n */\nexport class EmptyTransactionError extends MimicServerError {\n  override readonly _tag = \"EmptyTransactionError\";\n  readonly transactionId: string;\n\n  constructor(transactionId: string) {\n    super(`Transaction ${transactionId} is empty and cannot be applied`);\n    this.name = \"EmptyTransactionError\";\n    this.transactionId = transactionId;\n  }\n}\n\n/**\n * Error thrown when a duplicate transaction is submitted.\n */\nexport class DuplicateTransactionError extends MimicServerError {\n  override readonly _tag = \"DuplicateTransactionError\";\n  readonly transactionId: string;\n\n  constructor(transactionId: string) {\n    super(`Transaction ${transactionId} has already been processed`);\n    this.name = \"DuplicateTransactionError\";\n    this.transactionId = transactionId;\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidhash/mimic",
-  "version": "0.0.1-alpha.7",
+  "version": "0.0.1-alpha.9",
   "type": "module",
   "repository": {
     "type": "git",
@@ -9,9 +9,21 @@
   },
   "main": "./src/index.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./server": "./src/server/index.ts",
-    "./client": "./src/client/index.ts"
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts",
+      "require": "./dist/index.cjs"
+    },
+    "./server": {
+      "import": "./dist/server/index.mjs",
+      "types": "./dist/server/index.d.mts",
+      "require": "./dist/server/index.cjs"
+    },
+    "./client": {
+      "import": "./dist/client/index.mjs",
+      "types": "./dist/client/index.d.mts",
+      "require": "./dist/client/index.cjs"
+    }
   },
   "devDependencies": {
     "@effect/vitest": "^0.27.0",
@@ -19,7 +31,7 @@
     "typescript": "5.8.3",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@voidhash/tsconfig": "0.0.1-alpha.7"
+    "@voidhash/tsconfig": "0.0.1-alpha.9"
   },
   "peerDependencies": {
     "effect": "^3.19.12"

package/src/primitives/Array.ts

@@ -5,10 +5,10 @@ import * as OperationPath from "../OperationPath";
 import * as ProxyEnvironment from "../ProxyEnvironment";
 import * as Transform from "../Transform";
 import * as FractionalIndex from "../FractionalIndex";
-import type { Primitive, PrimitiveInternal, MaybeUndefined, AnyPrimitive, Validator, InferState, InferProxy, InferSnapshot } from "../Primitive";
+import type { Primitive, PrimitiveInternal, MaybeUndefined, AnyPrimitive, Validator, InferState, InferProxy, InferSnapshot, InferSetInput } from "../Primitive";
 import { ValidationError } from "../Primitive";
-import { runValidators, applyDefaults, StructSetInput } from "./shared";
-import type { StructPrimitive } from "./Struct";
+import { runValidators, applyDefaults } from "./shared";
+import { StructPrimitive, StructSetInput } from "./Struct";
 
 
 /**
@@ -49,13 +49,16 @@ export type ArraySnapshot<TElement extends AnyPrimitive> = readonly ArrayEntrySn
 
 /**
  * Compute the input type for array element values.
- * If the element is a struct, uses StructSetInput (partial with defaults).
- * Otherwise uses the full state type.
+ * Uses StructSetInput directly for struct elements so that:
+ * - Fields that are required AND have no default must be provided
+ * - Fields that are optional OR have defaults can be omitted
+ * 
+ * For non-struct elements, falls back to InferSetInput.
  */
-export type ArrayElementSetInput<TElement extends AnyPrimitive> =
+export type ArrayElementSetInput<TElement extends AnyPrimitive> = 
   TElement extends StructPrimitive<infer TFields, any, any>
     ? StructSetInput<TFields>
-    : InferState<TElement>;
+    : InferSetInput<TElement>;
 
 export interface ArrayProxy<TElement extends AnyPrimitive> {
   /** Gets the current array entries (sorted by position) */
@@ -88,14 +91,22 @@ interface ArrayPrimitiveSchema<TElement extends AnyPrimitive> {
   readonly validators: readonly Validator<ArrayState<TElement>>[];
 }
 
-export class ArrayPrimitive<TElement extends AnyPrimitive, TDefined extends boolean = false, THasDefault extends boolean = false>
-  implements Primitive<ArrayState<TElement>, ArrayProxy<TElement>, TDefined, THasDefault>
+/** Input type for array set() - an array of element set inputs */
+export type ArraySetInput<TElement extends AnyPrimitive> = readonly ArrayElementSetInput<TElement>[];
+
+/** Input type for array update() - same as set() for arrays */
+export type ArrayUpdateInput<TElement extends AnyPrimitive> = readonly ArrayElementSetInput<TElement>[];
+
+export class ArrayPrimitive<TElement extends AnyPrimitive, TRequired extends boolean = false, THasDefault extends boolean = false>
+  implements Primitive<ArrayState<TElement>, ArrayProxy<TElement>, TRequired, THasDefault, ArraySetInput<TElement>, ArrayUpdateInput<TElement>>
 {
   readonly _tag = "ArrayPrimitive" as const;
   readonly _State!: ArrayState<TElement>;
   readonly _Proxy!: ArrayProxy<TElement>;
-  readonly _TDefined!: TDefined;
+  readonly _TRequired!: TRequired;
   readonly _THasDefault!: THasDefault;
+  readonly TSetInput!: ArraySetInput<TElement>;
+  readonly TUpdateInput!: ArrayUpdateInput<TElement>;
 
   private readonly _schema: ArrayPrimitiveSchema<TElement>;
 
@@ -139,7 +150,7 @@ export class ArrayPrimitive<TElement extends AnyPrimitive, TDefined extends bool
   }
 
   /** Set a default value for this array */
-  default(defaultValue: ArrayState<TElement>): ArrayPrimitive<TElement, true, true> {
+  default(defaultValue: ArrayState<TElement>): ArrayPrimitive<TElement, TRequired, true> {
     return new ArrayPrimitive({
       ...this._schema,
       defaultValue,
@@ -152,7 +163,7 @@ export class ArrayPrimitive<TElement extends AnyPrimitive, TDefined extends bool
   }
 
   /** Add a custom validation rule */
-  refine(fn: (value: ArrayState<TElement>) => boolean, message: string): ArrayPrimitive<TElement, TDefined, THasDefault> {
+  refine(fn: (value: ArrayState<TElement>) => boolean, message: string): ArrayPrimitive<TElement, TRequired, THasDefault> {
     return new ArrayPrimitive({
       ...this._schema,
       validators: [...this._schema.validators, { validate: fn, message }],
@@ -160,7 +171,7 @@ export class ArrayPrimitive<TElement extends AnyPrimitive, TDefined extends bool
   }
 
   /** Minimum array length */
-  minLength(length: number): ArrayPrimitive<TElement, TDefined, THasDefault> {
+  minLength(length: number): ArrayPrimitive<TElement, TRequired, THasDefault> {
     return this.refine(
       (v) => v.length >= length,
       `Array must have at least ${length} elements`
@@ -168,7 +179,7 @@ export class ArrayPrimitive<TElement extends AnyPrimitive, TDefined extends bool
   }
 
   /** Maximum array length */
-  maxLength(length: number): ArrayPrimitive<TElement, TDefined, THasDefault> {
+  maxLength(length: number): ArrayPrimitive<TElement, TRequired, THasDefault> {
     return this.refine(
       (v) => v.length <= length,
       `Array must have at most ${length} elements`

package/src/primitives/Boolean.ts

@@ -4,17 +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, Validator } from "./shared";
+import type { Primitive, PrimitiveInternal, MaybeUndefined, Validator, NeedsValue } from "./shared";
 import { runValidators, isCompatibleOperation, ValidationError } from "./shared";
 
 
-export interface BooleanProxy<TDefined extends boolean = false> {
+type InferSetInput<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<boolean, TRequired, THasDefault>
+type InferUpdateInput<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<boolean, TRequired, THasDefault>
+
+export interface BooleanProxy<TRequired extends boolean = false, THasDefault extends boolean = false> {
   /** Gets the current boolean value */
-  get(): MaybeUndefined<boolean, TDefined>;
+  get(): MaybeUndefined<boolean, TRequired, THasDefault>;
   /** Sets the boolean value, generating a boolean.set operation */
-  set(value: boolean): void;
+  set(value: InferSetInput<TRequired, THasDefault>): void;
+  /** This is the same as set. Updates the boolean value, generating a boolean.set operation */
+  update(value: InferUpdateInput<TRequired, THasDefault>): void;
   /** Returns a readonly snapshot of the boolean value for rendering */
-  toSnapshot(): MaybeUndefined<boolean, TDefined>;
+  toSnapshot(): MaybeUndefined<boolean, TRequired, THasDefault>;
 }
 
 interface BooleanPrimitiveSchema {
@@ -23,12 +28,14 @@ interface BooleanPrimitiveSchema {
   readonly validators: readonly Validator<boolean>[];
 }
 
-export class BooleanPrimitive<TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<boolean, BooleanProxy<TDefined>, TDefined, THasDefault> {
+export class BooleanPrimitive<TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<boolean, BooleanProxy<TRequired, THasDefault>, TRequired, THasDefault, InferSetInput<TRequired, THasDefault>, InferUpdateInput<TRequired, THasDefault>> {
   readonly _tag = "BooleanPrimitive" as const;
   readonly _State!: boolean;
-  readonly _Proxy!: BooleanProxy<TDefined>;
-  readonly _TDefined!: TDefined;
+  readonly _Proxy!: BooleanProxy<TRequired, THasDefault>;
+  readonly _TRequired!: TRequired;
   readonly _THasDefault!: THasDefault;
+  readonly TUpdateInput!: InferUpdateInput<TRequired, THasDefault>;
+  readonly TSetInput!: InferSetInput<TRequired, THasDefault>;
 
   private readonly _schema: BooleanPrimitiveSchema;
 
@@ -54,7 +61,7 @@ export class BooleanPrimitive<TDefined extends boolean = false, THasDefault exte
   }
 
   /** Set a default value for this boolean */
-  default(defaultValue: boolean): BooleanPrimitive<true, true> {
+  default(defaultValue: boolean): BooleanPrimitive<TRequired, true> {
     return new BooleanPrimitive({
       ...this._schema,
       defaultValue,
@@ -62,29 +69,34 @@ export class BooleanPrimitive<TDefined extends boolean = false, THasDefault exte
   }
 
   /** Add a custom validation rule */
-  refine(fn: (value: boolean) => boolean, message: string): BooleanPrimitive<TDefined, THasDefault> {
+  refine(fn: (value: boolean) => boolean, message: string): BooleanPrimitive<TRequired, THasDefault> {
     return new BooleanPrimitive({
       ...this._schema,
       validators: [...this._schema.validators, { validate: fn, message }],
     });
   }
 
-  readonly _internal: PrimitiveInternal<boolean, BooleanProxy<TDefined>> = {
-    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): BooleanProxy<TDefined> => {
+  readonly _internal: PrimitiveInternal<boolean, BooleanProxy<TRequired, THasDefault>> = {
+    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): BooleanProxy<TRequired, THasDefault> => {
       const defaultValue = this._schema.defaultValue;
       return {
-        get: (): MaybeUndefined<boolean, TDefined> => {
+        get: (): MaybeUndefined<boolean, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as boolean | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<boolean, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<boolean, TRequired, THasDefault>;
+        },
+        set: (value: InferSetInput<TRequired, THasDefault>) => {
+          env.addOperation(
+            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
+          );
         },
-        set: (value: boolean) => {
+        update: (value: InferUpdateInput<TRequired, THasDefault>) => {
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
           );
         },
-        toSnapshot: (): MaybeUndefined<boolean, TDefined> => {
+        toSnapshot: (): MaybeUndefined<boolean, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as boolean | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<boolean, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<boolean, TRequired, THasDefault>;
         },
       };
     },

package/src/primitives/Either.ts

@@ -4,7 +4,7 @@ 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, InferState } from "./shared";
+import type { Primitive, PrimitiveInternal, MaybeUndefined, InferState, NeedsValue } from "./shared";
 import { ValidationError } from "./shared";
 import { StringPrimitive } from "./String";
 import { NumberPrimitive } from "./Number";
@@ -15,6 +15,9 @@ import { LiteralPrimitive, LiteralValue } from "./Literal";
 // Either Primitive - Simple Type Union
 // =============================================================================
 
+type InferSetInput<TVariants extends readonly ScalarPrimitive[], TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<InferEitherState<TVariants>, TRequired, THasDefault>
+type InferUpdateInput<TVariants extends readonly ScalarPrimitive[], TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<InferEitherState<TVariants>, TRequired, THasDefault>
+
 /**
  * Scalar primitives that can be used as variants in Either
  */
@@ -49,18 +52,21 @@ export interface EitherMatchHandlers<R> {
 /**
  * Proxy for accessing Either values
  */
-export interface EitherProxy<TVariants extends readonly ScalarPrimitive[], TDefined extends boolean = false> {
+export interface EitherProxy<TVariants extends readonly ScalarPrimitive[], TRequired extends boolean = false, THasDefault extends boolean = false> {
   /** Gets the current value */
-  get(): MaybeUndefined<InferEitherState<TVariants>, TDefined>;
+  get(): MaybeUndefined<InferEitherState<TVariants>, TRequired, THasDefault>;
 
   /** Sets the value to any of the allowed variant types */
-  set(value: InferEitherState<TVariants>): void;
+  set(value: InferSetInput<TVariants, TRequired, THasDefault>): void;
+
+  /** This is the same as set. Updates the value, generating an either.set operation */
+  update(value: InferUpdateInput<TVariants, TRequired, THasDefault>): void;
 
   /** Pattern match on the value type */
   match<R>(handlers: EitherMatchHandlers<R>): R | undefined;
 
   /** Returns a readonly snapshot of the value for rendering */
-  toSnapshot(): MaybeUndefined<InferEitherSnapshot<TVariants>, TDefined>;
+  toSnapshot(): MaybeUndefined<InferEitherSnapshot<TVariants>, TRequired, THasDefault>;
 }
 
 interface EitherPrimitiveSchema<TVariants extends readonly ScalarPrimitive[]> {
@@ -69,14 +75,16 @@ interface EitherPrimitiveSchema<TVariants extends readonly ScalarPrimitive[]> {
   readonly variants: TVariants;
 }
 
-export class EitherPrimitive<TVariants extends readonly ScalarPrimitive[], TDefined extends boolean = false, THasDefault extends boolean = false>
-  implements Primitive<InferEitherState<TVariants>, EitherProxy<TVariants, TDefined>, TDefined, THasDefault>
+export class EitherPrimitive<TVariants extends readonly ScalarPrimitive[], TRequired extends boolean = false, THasDefault extends boolean = false>
+  implements Primitive<InferEitherState<TVariants>, EitherProxy<TVariants, TRequired, THasDefault>, TRequired, THasDefault, InferSetInput<TVariants, TRequired, THasDefault>, InferUpdateInput<TVariants, TRequired, THasDefault>>
 {
   readonly _tag = "EitherPrimitive" as const;
   readonly _State!: InferEitherState<TVariants>;
-  readonly _Proxy!: EitherProxy<TVariants, TDefined>;
-  readonly _TDefined!: TDefined;
+  readonly _Proxy!: EitherProxy<TVariants, TRequired, THasDefault>;
+  readonly _TRequired!: TRequired;
   readonly _THasDefault!: THasDefault;
+  readonly TUpdateInput!: InferUpdateInput<TVariants, TRequired, THasDefault>;
+  readonly TSetInput!: InferSetInput<TVariants, TRequired, THasDefault>;
 
   private readonly _schema: EitherPrimitiveSchema<TVariants>;
 
@@ -102,7 +110,7 @@ export class EitherPrimitive<TVariants extends readonly ScalarPrimitive[], TDefi
   }
 
   /** Set a default value for this either */
-  default(defaultValue: InferEitherState<TVariants>): EitherPrimitive<TVariants, true, true> {
+  default(defaultValue: InferEitherState<TVariants>): EitherPrimitive<TVariants, TRequired, true> {
     return new EitherPrimitive({
       ...this._schema,
       defaultValue,
@@ -248,19 +256,24 @@ export class EitherPrimitive<TVariants extends readonly ScalarPrimitive[], TDefi
     matchingVariant._internal.applyOperation(undefined, syntheticOp);
   }
 
-  readonly _internal: PrimitiveInternal<InferEitherState<TVariants>, EitherProxy<TVariants, TDefined>> = {
+  readonly _internal: PrimitiveInternal<InferEitherState<TVariants>, EitherProxy<TVariants, TRequired, THasDefault>> = {
     createProxy: (
       env: ProxyEnvironment.ProxyEnvironment,
       operationPath: OperationPath.OperationPath
-    ): EitherProxy<TVariants, TDefined> => {
+    ): EitherProxy<TVariants, TRequired, THasDefault> => {
       const defaultValue = this._schema.defaultValue;
 
       return {
-        get: (): MaybeUndefined<InferEitherState<TVariants>, TDefined> => {
+        get: (): MaybeUndefined<InferEitherState<TVariants>, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as InferEitherState<TVariants> | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<InferEitherState<TVariants>, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<InferEitherState<TVariants>, TRequired, THasDefault>;
+        },
+        set: (value: InferSetInput<TVariants, TRequired, THasDefault>) => {
+          env.addOperation(
+            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
+          );
         },
-        set: (value: InferEitherState<TVariants>) => {
+        update: (value: InferUpdateInput<TVariants, TRequired, THasDefault>) => {
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
           );
@@ -286,9 +299,9 @@ export class EitherPrimitive<TVariants extends readonly ScalarPrimitive[], TDefi
               return undefined;
           }
         },
-        toSnapshot: (): MaybeUndefined<InferEitherSnapshot<TVariants>, TDefined> => {
+        toSnapshot: (): MaybeUndefined<InferEitherSnapshot<TVariants>, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as InferEitherState<TVariants> | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<InferEitherSnapshot<TVariants>, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<InferEitherSnapshot<TVariants>, TRequired, THasDefault>;
         },
       };
     },

package/src/primitives/Lazy.ts

@@ -4,10 +4,20 @@ import * as Operation from "../Operation";
 import * as OperationPath from "../OperationPath";
 import * as ProxyEnvironment from "../ProxyEnvironment";
 import * as Transform from "../Transform";
-import type { Primitive, PrimitiveInternal, AnyPrimitive, InferState, InferProxy, InferSnapshot } from "../Primitive";
+import type { Primitive, PrimitiveInternal, AnyPrimitive, InferState, InferProxy, InferSnapshot, InferSetInput, InferUpdateInput } from "../Primitive";
 import { ValidationError } from "../Primitive";
 import { runValidators } from "./shared";
 
+/**
+ * Type to infer SetInput from a lazy thunk
+ */
+export type InferLazySetInput<T extends () => AnyPrimitive> = InferSetInput<ReturnType<T>>;
+
+/**
+ * Type to infer UpdateInput from a lazy thunk
+ */
+export type InferLazyUpdateInput<T extends () => AnyPrimitive> = InferUpdateInput<ReturnType<T>>;
+
 
 /**
  * Type to infer state from a lazy thunk
@@ -25,11 +35,15 @@ export type InferLazyProxy<T extends () => AnyPrimitive> = InferProxy<ReturnType
 export type InferLazySnapshot<T extends () => AnyPrimitive> = InferSnapshot<ReturnType<T>>;
 
 export class LazyPrimitive<TThunk extends () => AnyPrimitive>
-  implements Primitive<InferLazyState<TThunk>, InferLazyProxy<TThunk>>
+  implements Primitive<InferLazyState<TThunk>, InferLazyProxy<TThunk>, false, false, InferLazySetInput<TThunk>, InferLazyUpdateInput<TThunk>>
 {
   readonly _tag = "LazyPrimitive" as const;
   readonly _State!: InferLazyState<TThunk>;
   readonly _Proxy!: InferLazyProxy<TThunk>;
+  readonly _TRequired!: false;
+  readonly _THasDefault!: false;
+  readonly TSetInput!: InferLazySetInput<TThunk>;
+  readonly TUpdateInput!: InferLazyUpdateInput<TThunk>;
 
   private readonly _thunk: TThunk;
   private _resolved: ReturnType<TThunk> | undefined;

package/src/primitives/Literal.ts

@@ -4,21 +4,25 @@ 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";
 
 
 /** Valid literal types */
 export type LiteralValue = string | number | boolean | null;
 
-export interface LiteralProxy<T extends LiteralValue, TDefined extends boolean = false> {
+type InferSetInput<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<T, TRequired, THasDefault>
+type InferUpdateInput<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<T, TRequired, THasDefault>
+
+export interface LiteralProxy<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> {
   /** Gets the current literal value */
-  get(): MaybeUndefined<T, TDefined>;
+  get(): MaybeUndefined<T, TRequired, THasDefault>;
   /** Sets the literal value (must match the exact literal type) */
-  set(value: T): void;
+  set(value: InferSetInput<T, TRequired, THasDefault>): void;
+  /** This is the same as set. Updates the literal value, generating a literal.set operation */
+  update(value: InferUpdateInput<T, TRequired, THasDefault>): void;
   /** Returns a readonly snapshot of the literal value for rendering */
-  toSnapshot(): MaybeUndefined<T, TDefined>;
+  toSnapshot(): MaybeUndefined<T, TRequired, THasDefault>;
 }
 
 interface LiteralPrimitiveSchema<T extends LiteralValue> {
@@ -27,12 +31,14 @@ interface LiteralPrimitiveSchema<T extends LiteralValue> {
   readonly literal: T;
 }
 
-export class LiteralPrimitive<T extends LiteralValue, TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<T, LiteralProxy<T, TDefined>, TDefined, THasDefault> {
+export class LiteralPrimitive<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<T, LiteralProxy<T, TRequired, THasDefault>, TRequired, THasDefault, InferSetInput<T, TRequired, THasDefault>, InferUpdateInput<T, TRequired, THasDefault>> {
   readonly _tag = "LiteralPrimitive" as const;
   readonly _State!: T;
-  readonly _Proxy!: LiteralProxy<T, TDefined>;
-  readonly _TDefined!: TDefined;
+  readonly _Proxy!: LiteralProxy<T, TRequired, THasDefault>;
+  readonly _TRequired!: TRequired;
   readonly _THasDefault!: THasDefault;
+  readonly TUpdateInput!: InferUpdateInput<T, TRequired, THasDefault>;
+  readonly TSetInput!: InferSetInput<T, TRequired, THasDefault>;
 
   private readonly _schema: LiteralPrimitiveSchema<T>;
 
@@ -58,7 +64,7 @@ export class LiteralPrimitive<T extends LiteralValue, TDefined extends boolean =
   }
 
   /** Set a default value for this literal */
-  default(defaultValue: T): LiteralPrimitive<T, true, true> {
+  default(defaultValue: T): LiteralPrimitive<T, TRequired, true> {
     return new LiteralPrimitive({
       ...this._schema,
       defaultValue,
@@ -70,22 +76,27 @@ export class LiteralPrimitive<T extends LiteralValue, TDefined extends boolean =
     return this._schema.literal;
   }
 
-  readonly _internal: PrimitiveInternal<T, LiteralProxy<T, TDefined>> = {
-    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): LiteralProxy<T, TDefined> => {
+  readonly _internal: PrimitiveInternal<T, LiteralProxy<T, TRequired, THasDefault>> = {
+    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): LiteralProxy<T, TRequired, THasDefault> => {
       const defaultValue = this._schema.defaultValue;
       return {
-        get: (): MaybeUndefined<T, TDefined> => {
+        get: (): MaybeUndefined<T, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as T | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<T, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<T, TRequired, THasDefault>;
+        },
+        set: (value: InferSetInput<T, TRequired, THasDefault>) => {
+          env.addOperation(
+            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
+          );
         },
-        set: (value: T) => {
+        update: (value: InferUpdateInput<T, TRequired, THasDefault>) => {
           env.addOperation(
             Operation.fromDefinition(operationPath, this._opDefinitions.set, value)
           );
         },
-        toSnapshot: (): MaybeUndefined<T, TDefined> => {
+        toSnapshot: (): MaybeUndefined<T, TRequired, THasDefault> => {
           const state = env.getState(operationPath) as T | undefined;
-          return (state ?? defaultValue) as MaybeUndefined<T, TDefined>;
+          return (state ?? defaultValue) as MaybeUndefined<T, TRequired, THasDefault>;
         },
       };
     },