@voidhash/mimic 0.0.1 → 0.0.3

package/dist/primitives/Union.cjs

@@ -0,0 +1,170 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_defineProperty = require('../_virtual/_@oxc-project_runtime@0.103.0/helpers/defineProperty.cjs');
+const require_objectSpread2 = require('../_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.cjs');
+const require_shared = require('./shared.cjs');
+const require_OperationDefinition = require('../OperationDefinition.cjs');
+const require_OperationPath = require('../OperationPath.cjs');
+const require_Operation = require('../Operation.cjs');
+require('../Primitive.cjs');
+let effect = require("effect");
+
+//#region src/primitives/Union.ts
+var UnionPrimitive = class UnionPrimitive {
+	constructor(schema) {
+		require_defineProperty._defineProperty(this, "_tag", "UnionPrimitive");
+		require_defineProperty._defineProperty(this, "_State", void 0);
+		require_defineProperty._defineProperty(this, "_Proxy", void 0);
+		require_defineProperty._defineProperty(this, "_TRequired", void 0);
+		require_defineProperty._defineProperty(this, "_THasDefault", void 0);
+		require_defineProperty._defineProperty(this, "TSetInput", void 0);
+		require_defineProperty._defineProperty(this, "TUpdateInput", void 0);
+		require_defineProperty._defineProperty(this, "_schema", void 0);
+		require_defineProperty._defineProperty(this, "_opDefinitions", { set: require_OperationDefinition.make({
+			kind: "union.set",
+			payload: effect.Schema.Unknown,
+			target: effect.Schema.Unknown,
+			apply: (payload) => payload
+		}) });
+		require_defineProperty._defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const variants = this._schema.variants;
+				const defaultValue = this._schema.defaultValue;
+				return {
+					get: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					},
+					set: (value) => {
+						const merged = this._applyVariantDefaults(value);
+						env.addOperation(require_Operation.fromDefinition(operationPath, this._opDefinitions.set, merged));
+					},
+					as: (variant) => {
+						const variantPrimitive = variants[variant];
+						if (!variantPrimitive) throw new require_shared.ValidationError(`Unknown variant: ${globalThis.String(variant)}`);
+						return variantPrimitive._internal.createProxy(env, operationPath);
+					},
+					match: (handlers) => {
+						const state = env.getState(operationPath);
+						if (!state) return void 0;
+						const variantKey = this._findVariantKey(state);
+						if (!variantKey) return void 0;
+						const handler = handlers[variantKey];
+						if (!handler) return void 0;
+						return handler(variants[variantKey]._internal.createProxy(env, operationPath));
+					},
+					toSnapshot: () => {
+						const state = env.getState(operationPath);
+						const effectiveState = state !== null && state !== void 0 ? state : defaultValue;
+						if (!effectiveState) return;
+						const variantKey = this._findVariantKey(effectiveState);
+						if (!variantKey) return;
+						return variants[variantKey]._internal.createProxy(env, operationPath).toSnapshot();
+					}
+				};
+			},
+			applyOperation: (state, operation) => {
+				if (operation.path.toTokens().filter((t) => t !== "").length === 0) {
+					if (operation.kind !== "union.set") throw new require_shared.ValidationError(`UnionPrimitive root cannot apply operation of kind: ${operation.kind}`);
+					const payload = operation.payload;
+					if (typeof payload !== "object" || payload === null) throw new require_shared.ValidationError(`UnionPrimitive.set requires an object payload`);
+					if (payload[this._schema.discriminator] === void 0) throw new require_shared.ValidationError(`UnionPrimitive.set requires a "${this._schema.discriminator}" discriminator field`);
+					return payload;
+				}
+				if (state === void 0) throw new require_shared.ValidationError(`Cannot apply nested operation to undefined union state`);
+				const variantKey = this._findVariantKey(state);
+				if (variantKey === void 0) throw new require_shared.ValidationError(`Cannot determine active variant from state`);
+				return this._schema.variants[variantKey]._internal.applyOperation(state, operation);
+			},
+			getInitialState: () => {
+				return this._schema.defaultValue;
+			},
+			transformOperation: (clientOp, serverOp) => {
+				const clientPath = clientOp.path;
+				const serverPath = serverOp.path;
+				if (!require_OperationPath.pathsOverlap(clientPath, serverPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				const clientTokens = clientPath.toTokens().filter((t) => t !== "");
+				const serverTokens = serverPath.toTokens().filter((t) => t !== "");
+				if (clientTokens.length === 0 && serverTokens.length === 0) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverTokens.length === 0 && serverOp.kind === "union.set") return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (clientTokens.length === 0 && clientOp.kind === "union.set") return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (clientTokens.length > 0 && serverTokens.length > 0) {
+					if (clientTokens[0] !== serverTokens[0]) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					const variantKeys = Object.keys(this._schema.variants);
+					if (variantKeys.length === 0) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					return this._schema.variants[variantKeys[0]]._internal.transformOperation(clientOp, serverOp);
+				}
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this union as required */
+	required() {
+		return new UnionPrimitive(require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this union */
+	default(defaultValue) {
+		const merged = this._applyVariantDefaults(defaultValue);
+		return new UnionPrimitive(require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, this._schema), {}, { defaultValue: merged }));
+	}
+	/** Get the discriminator field name */
+	get discriminator() {
+		return this._schema.discriminator;
+	}
+	/** Get the variants */
+	get variants() {
+		return this._schema.variants;
+	}
+	/** Find the variant key from a state value */
+	_findVariantKey(state) {
+		if (typeof state !== "object" || state === null) return;
+		const discriminatorValue = state[this._schema.discriminator];
+		for (const key in this._schema.variants) {
+			const discriminatorField = this._schema.variants[key].fields[this._schema.discriminator];
+			if (discriminatorField && discriminatorField._tag === "LiteralPrimitive") {
+				if (discriminatorField.literal === discriminatorValue) return key;
+			}
+		}
+	}
+	/** Apply defaults to a variant value based on the discriminator */
+	_applyVariantDefaults(value) {
+		const variantKey = this._findVariantKey(value);
+		if (!variantKey) return value;
+		const variantPrimitive = this._schema.variants[variantKey];
+		return require_shared.applyDefaults(variantPrimitive, value);
+	}
+};
+function Union(options) {
+	var _options$discriminato;
+	return new UnionPrimitive({
+		required: false,
+		defaultValue: void 0,
+		discriminator: (_options$discriminato = options.discriminator) !== null && _options$discriminato !== void 0 ? _options$discriminato : "type",
+		variants: options.variants
+	});
+}
+
+//#endregion
+exports.Union = Union;
+exports.UnionPrimitive = UnionPrimitive;

package/dist/primitives/Union.d.cts

@@ -0,0 +1,81 @@
+import { InferProxy, InferSetInput, InferSnapshot, InferState, MaybeUndefined, Primitive, PrimitiveInternal } from "./shared.cjs";
+import { StructPrimitive } from "./Struct.cjs";
+
+//#region src/primitives/Union.d.ts
+
+/**
+ * Type constraint for union variants - must be struct primitives
+ */
+type UnionVariants = Record<string, StructPrimitive<any, any, any>>;
+/**
+ * Infer the union state type from variants
+ */
+type InferUnionState<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferState<TVariants[K]> }[keyof TVariants];
+/**
+ * Infer the union snapshot type from variants
+ */
+type InferUnionSnapshot<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferSnapshot<TVariants[K]> }[keyof TVariants];
+/**
+ * Compute the input type for union.set() operations.
+ * Uses each variant's TSetInput type.
+ */
+type UnionSetInput<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferSetInput<TVariants[K]> }[keyof TVariants];
+/**
+ * Proxy for accessing union variants
+ */
+interface UnionProxy<TVariants extends UnionVariants, _TDiscriminator extends string, TRequired extends boolean = false, THasDefault extends boolean = false> {
+  /** Gets the current union value */
+  get(): MaybeUndefined<InferUnionState<TVariants>, TRequired, THasDefault>;
+  /** Sets the entire union value (applies defaults for variant fields) */
+  set(value: UnionSetInput<TVariants>): void;
+  /** Access a specific variant's proxy (assumes the variant is active) */
+  as<K$1 extends keyof TVariants>(variant: K$1): InferProxy<TVariants[K$1]>;
+  /** Pattern match on the variant type */
+  match<R>(handlers: { [K in keyof TVariants]: (proxy: InferProxy<TVariants[K$1]>) => R }): R | undefined;
+  /** Returns a readonly snapshot of the union for rendering */
+  toSnapshot(): MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault>;
+}
+interface UnionPrimitiveSchema<TVariants extends UnionVariants, TDiscriminator extends string> {
+  readonly required: boolean;
+  readonly defaultValue: InferUnionState<TVariants> | undefined;
+  readonly discriminator: TDiscriminator;
+  readonly variants: TVariants;
+}
+declare class UnionPrimitive<TVariants extends UnionVariants, TDiscriminator extends string = "type", TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>, TRequired, THasDefault, UnionSetInput<TVariants>, UnionSetInput<TVariants>> {
+  readonly _tag: "UnionPrimitive";
+  readonly _State: InferUnionState<TVariants>;
+  readonly _Proxy: UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>;
+  readonly _TRequired: TRequired;
+  readonly _THasDefault: THasDefault;
+  readonly TSetInput: UnionSetInput<TVariants>;
+  readonly TUpdateInput: UnionSetInput<TVariants>;
+  private readonly _schema;
+  private readonly _opDefinitions;
+  constructor(schema: UnionPrimitiveSchema<TVariants, TDiscriminator>);
+  /** Mark this union as required */
+  required(): UnionPrimitive<TVariants, TDiscriminator, true, THasDefault>;
+  /** Set a default value for this union */
+  default(defaultValue: UnionSetInput<TVariants>): UnionPrimitive<TVariants, TDiscriminator, true, true>;
+  /** Get the discriminator field name */
+  get discriminator(): TDiscriminator;
+  /** Get the variants */
+  get variants(): TVariants;
+  /** Find the variant key from a state value */
+  private _findVariantKey;
+  /** Apply defaults to a variant value based on the discriminator */
+  private _applyVariantDefaults;
+  readonly _internal: PrimitiveInternal<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>>;
+}
+/** Options for creating a Union primitive */
+interface UnionOptions<TVariants extends UnionVariants, TDiscriminator extends string> {
+  /** The field name used to discriminate between variants (defaults to "type") */
+  readonly discriminator?: TDiscriminator;
+  /** The variant struct primitives */
+  readonly variants: TVariants;
+}
+/** Creates a new UnionPrimitive with the given variants */
+declare function Union<TVariants extends UnionVariants>(options: UnionOptions<TVariants, "type">): UnionPrimitive<TVariants, "type", false, false>;
+declare function Union<TVariants extends UnionVariants, TDiscriminator extends string>(options: UnionOptions<TVariants, TDiscriminator>): UnionPrimitive<TVariants, TDiscriminator, false, false>;
+//#endregion
+export { InferUnionSnapshot, InferUnionState, Union, UnionOptions, UnionPrimitive, UnionProxy, UnionSetInput, UnionVariants };
+//# sourceMappingURL=Union.d.cts.map

package/dist/primitives/Union.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Union.d.cts","names":[],"sources":["../../src/primitives/Union.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/primitives/Union.d.mts

@@ -0,0 +1,81 @@
+import { InferProxy, InferSetInput, InferSnapshot, InferState, MaybeUndefined, Primitive, PrimitiveInternal } from "./shared.mjs";
+import { StructPrimitive } from "./Struct.mjs";
+import "../Primitive.mjs";
+
+//#region src/primitives/Union.d.ts
+/**
+ * Type constraint for union variants - must be struct primitives
+ */
+type UnionVariants = Record<string, StructPrimitive<any, any, any>>;
+/**
+ * Infer the union state type from variants
+ */
+type InferUnionState<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferState<TVariants[K]> }[keyof TVariants];
+/**
+ * Infer the union snapshot type from variants
+ */
+type InferUnionSnapshot<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferSnapshot<TVariants[K]> }[keyof TVariants];
+/**
+ * Compute the input type for union.set() operations.
+ * Uses each variant's TSetInput type.
+ */
+type UnionSetInput<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferSetInput<TVariants[K]> }[keyof TVariants];
+/**
+ * Proxy for accessing union variants
+ */
+interface UnionProxy<TVariants extends UnionVariants, _TDiscriminator extends string, TRequired extends boolean = false, THasDefault extends boolean = false> {
+  /** Gets the current union value */
+  get(): MaybeUndefined<InferUnionState<TVariants>, TRequired, THasDefault>;
+  /** Sets the entire union value (applies defaults for variant fields) */
+  set(value: UnionSetInput<TVariants>): void;
+  /** Access a specific variant's proxy (assumes the variant is active) */
+  as<K$1 extends keyof TVariants>(variant: K$1): InferProxy<TVariants[K$1]>;
+  /** Pattern match on the variant type */
+  match<R>(handlers: { [K in keyof TVariants]: (proxy: InferProxy<TVariants[K$1]>) => R }): R | undefined;
+  /** Returns a readonly snapshot of the union for rendering */
+  toSnapshot(): MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault>;
+}
+interface UnionPrimitiveSchema<TVariants extends UnionVariants, TDiscriminator extends string> {
+  readonly required: boolean;
+  readonly defaultValue: InferUnionState<TVariants> | undefined;
+  readonly discriminator: TDiscriminator;
+  readonly variants: TVariants;
+}
+declare class UnionPrimitive<TVariants extends UnionVariants, TDiscriminator extends string = "type", TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>, TRequired, THasDefault, UnionSetInput<TVariants>, UnionSetInput<TVariants>> {
+  readonly _tag: "UnionPrimitive";
+  readonly _State: InferUnionState<TVariants>;
+  readonly _Proxy: UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>;
+  readonly _TRequired: TRequired;
+  readonly _THasDefault: THasDefault;
+  readonly TSetInput: UnionSetInput<TVariants>;
+  readonly TUpdateInput: UnionSetInput<TVariants>;
+  private readonly _schema;
+  private readonly _opDefinitions;
+  constructor(schema: UnionPrimitiveSchema<TVariants, TDiscriminator>);
+  /** Mark this union as required */
+  required(): UnionPrimitive<TVariants, TDiscriminator, true, THasDefault>;
+  /** Set a default value for this union */
+  default(defaultValue: UnionSetInput<TVariants>): UnionPrimitive<TVariants, TDiscriminator, true, true>;
+  /** Get the discriminator field name */
+  get discriminator(): TDiscriminator;
+  /** Get the variants */
+  get variants(): TVariants;
+  /** Find the variant key from a state value */
+  private _findVariantKey;
+  /** Apply defaults to a variant value based on the discriminator */
+  private _applyVariantDefaults;
+  readonly _internal: PrimitiveInternal<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>>;
+}
+/** Options for creating a Union primitive */
+interface UnionOptions<TVariants extends UnionVariants, TDiscriminator extends string> {
+  /** The field name used to discriminate between variants (defaults to "type") */
+  readonly discriminator?: TDiscriminator;
+  /** The variant struct primitives */
+  readonly variants: TVariants;
+}
+/** Creates a new UnionPrimitive with the given variants */
+declare function Union<TVariants extends UnionVariants>(options: UnionOptions<TVariants, "type">): UnionPrimitive<TVariants, "type", false, false>;
+declare function Union<TVariants extends UnionVariants, TDiscriminator extends string>(options: UnionOptions<TVariants, TDiscriminator>): UnionPrimitive<TVariants, TDiscriminator, false, false>;
+//#endregion
+export { InferUnionSnapshot, InferUnionState, Union, UnionOptions, UnionPrimitive, UnionProxy, UnionSetInput, UnionVariants };
+//# sourceMappingURL=Union.d.mts.map

package/dist/primitives/Union.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Union.d.mts","names":[],"sources":["../../src/primitives/Union.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/primitives/Union.mjs

@@ -0,0 +1,169 @@
+import { _defineProperty } from "../_virtual/_@oxc-project_runtime@0.103.0/helpers/defineProperty.mjs";
+import { _objectSpread2 } from "../_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.mjs";
+import { ValidationError, applyDefaults } from "./shared.mjs";
+import { make } from "../OperationDefinition.mjs";
+import { pathsOverlap } from "../OperationPath.mjs";
+import { fromDefinition } from "../Operation.mjs";
+import "../Primitive.mjs";
+import { Schema } from "effect";
+
+//#region src/primitives/Union.ts
+var UnionPrimitive = class UnionPrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "UnionPrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "TUpdateInput", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make({
+			kind: "union.set",
+			payload: Schema.Unknown,
+			target: Schema.Unknown,
+			apply: (payload) => payload
+		}) });
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const variants = this._schema.variants;
+				const defaultValue = this._schema.defaultValue;
+				return {
+					get: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					},
+					set: (value) => {
+						const merged = this._applyVariantDefaults(value);
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, merged));
+					},
+					as: (variant) => {
+						const variantPrimitive = variants[variant];
+						if (!variantPrimitive) throw new ValidationError(`Unknown variant: ${globalThis.String(variant)}`);
+						return variantPrimitive._internal.createProxy(env, operationPath);
+					},
+					match: (handlers) => {
+						const state = env.getState(operationPath);
+						if (!state) return void 0;
+						const variantKey = this._findVariantKey(state);
+						if (!variantKey) return void 0;
+						const handler = handlers[variantKey];
+						if (!handler) return void 0;
+						return handler(variants[variantKey]._internal.createProxy(env, operationPath));
+					},
+					toSnapshot: () => {
+						const state = env.getState(operationPath);
+						const effectiveState = state !== null && state !== void 0 ? state : defaultValue;
+						if (!effectiveState) return;
+						const variantKey = this._findVariantKey(effectiveState);
+						if (!variantKey) return;
+						return variants[variantKey]._internal.createProxy(env, operationPath).toSnapshot();
+					}
+				};
+			},
+			applyOperation: (state, operation) => {
+				if (operation.path.toTokens().filter((t) => t !== "").length === 0) {
+					if (operation.kind !== "union.set") throw new ValidationError(`UnionPrimitive root cannot apply operation of kind: ${operation.kind}`);
+					const payload = operation.payload;
+					if (typeof payload !== "object" || payload === null) throw new ValidationError(`UnionPrimitive.set requires an object payload`);
+					if (payload[this._schema.discriminator] === void 0) throw new ValidationError(`UnionPrimitive.set requires a "${this._schema.discriminator}" discriminator field`);
+					return payload;
+				}
+				if (state === void 0) throw new ValidationError(`Cannot apply nested operation to undefined union state`);
+				const variantKey = this._findVariantKey(state);
+				if (variantKey === void 0) throw new ValidationError(`Cannot determine active variant from state`);
+				return this._schema.variants[variantKey]._internal.applyOperation(state, operation);
+			},
+			getInitialState: () => {
+				return this._schema.defaultValue;
+			},
+			transformOperation: (clientOp, serverOp) => {
+				const clientPath = clientOp.path;
+				const serverPath = serverOp.path;
+				if (!pathsOverlap(clientPath, serverPath)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				const clientTokens = clientPath.toTokens().filter((t) => t !== "");
+				const serverTokens = serverPath.toTokens().filter((t) => t !== "");
+				if (clientTokens.length === 0 && serverTokens.length === 0) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (serverTokens.length === 0 && serverOp.kind === "union.set") return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (clientTokens.length === 0 && clientOp.kind === "union.set") return {
+					type: "transformed",
+					operation: clientOp
+				};
+				if (clientTokens.length > 0 && serverTokens.length > 0) {
+					if (clientTokens[0] !== serverTokens[0]) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					const variantKeys = Object.keys(this._schema.variants);
+					if (variantKeys.length === 0) return {
+						type: "transformed",
+						operation: clientOp
+					};
+					return this._schema.variants[variantKeys[0]]._internal.transformOperation(clientOp, serverOp);
+				}
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this union as required */
+	required() {
+		return new UnionPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this union */
+	default(defaultValue) {
+		const merged = this._applyVariantDefaults(defaultValue);
+		return new UnionPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue: merged }));
+	}
+	/** Get the discriminator field name */
+	get discriminator() {
+		return this._schema.discriminator;
+	}
+	/** Get the variants */
+	get variants() {
+		return this._schema.variants;
+	}
+	/** Find the variant key from a state value */
+	_findVariantKey(state) {
+		if (typeof state !== "object" || state === null) return;
+		const discriminatorValue = state[this._schema.discriminator];
+		for (const key in this._schema.variants) {
+			const discriminatorField = this._schema.variants[key].fields[this._schema.discriminator];
+			if (discriminatorField && discriminatorField._tag === "LiteralPrimitive") {
+				if (discriminatorField.literal === discriminatorValue) return key;
+			}
+		}
+	}
+	/** Apply defaults to a variant value based on the discriminator */
+	_applyVariantDefaults(value) {
+		const variantKey = this._findVariantKey(value);
+		if (!variantKey) return value;
+		const variantPrimitive = this._schema.variants[variantKey];
+		return applyDefaults(variantPrimitive, value);
+	}
+};
+function Union(options) {
+	var _options$discriminato;
+	return new UnionPrimitive({
+		required: false,
+		defaultValue: void 0,
+		discriminator: (_options$discriminato = options.discriminator) !== null && _options$discriminato !== void 0 ? _options$discriminato : "type",
+		variants: options.variants
+	});
+}
+
+//#endregion
+export { Union, UnionPrimitive };
+//# sourceMappingURL=Union.mjs.map

package/dist/primitives/Union.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Union.mjs","names":["OperationDefinition.make","Operation.fromDefinition","OperationPath.pathsOverlap"],"sources":["../../src/primitives/Union.ts"],"sourcesContent":["import { Effect, Schema } from \"effect\";\nimport * as OperationDefinition from \"../OperationDefinition\";\nimport * as Operation from \"../Operation\";\nimport * as OperationPath from \"../OperationPath\";\nimport * as ProxyEnvironment from \"../ProxyEnvironment\";\nimport * as Transform from \"../Transform\";\nimport type { Primitive, PrimitiveInternal, MaybeUndefined, AnyPrimitive, InferState, InferProxy, InferSnapshot, InferSetInput } from \"../Primitive\";\nimport { ValidationError } from \"../Primitive\";\nimport { LiteralPrimitive } from \"./Literal\";\nimport { StructPrimitive, InferStructState } from \"./Struct\";\nimport { runValidators, applyDefaults } from \"./shared\";\n\n\n/**\n * Type constraint for union variants - must be struct primitives\n */\nexport type UnionVariants = Record<string, StructPrimitive<any, any, any>>;\n\n/**\n * Infer the union state type from variants\n */\nexport type InferUnionState<TVariants extends UnionVariants> = {\n  [K in keyof TVariants]: InferState<TVariants[K]>;\n}[keyof TVariants];\n\n/**\n * Infer the union snapshot type from variants\n */\nexport type InferUnionSnapshot<TVariants extends UnionVariants> = {\n  [K in keyof TVariants]: InferSnapshot<TVariants[K]>;\n}[keyof TVariants];\n\n/**\n * Compute the input type for union.set() operations.\n * Uses each variant's TSetInput type.\n */\nexport type UnionSetInput<TVariants extends UnionVariants> = {\n  [K in keyof TVariants]: InferSetInput<TVariants[K]>;\n}[keyof TVariants];\n\n/**\n * Proxy for accessing union variants\n */\nexport interface UnionProxy<TVariants extends UnionVariants, _TDiscriminator extends string, TRequired extends boolean = false, THasDefault extends boolean = false> {\n  /** Gets the current union value */\n  get(): MaybeUndefined<InferUnionState<TVariants>, TRequired, THasDefault>;\n  \n  /** Sets the entire union value (applies defaults for variant fields) */\n  set(value: UnionSetInput<TVariants>): void;\n  \n  /** Access a specific variant's proxy (assumes the variant is active) */\n  as<K extends keyof TVariants>(variant: K): InferProxy<TVariants[K]>;\n  \n  /** Pattern match on the variant type */\n  match<R>(handlers: {\n    [K in keyof TVariants]: (proxy: InferProxy<TVariants[K]>) => R;\n  }): R | undefined;\n  \n  /** Returns a readonly snapshot of the union for rendering */\n  toSnapshot(): MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault>;\n}\n\ninterface UnionPrimitiveSchema<TVariants extends UnionVariants, TDiscriminator extends string> {\n  readonly required: boolean;\n  readonly defaultValue: InferUnionState<TVariants> | undefined;\n  readonly discriminator: TDiscriminator;\n  readonly variants: TVariants;\n}\n\nexport class UnionPrimitive<TVariants extends UnionVariants, TDiscriminator extends string = \"type\", TRequired extends boolean = false, THasDefault extends boolean = false>\n  implements Primitive<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>, TRequired, THasDefault, UnionSetInput<TVariants>, UnionSetInput<TVariants>>\n{\n  readonly _tag = \"UnionPrimitive\" as const;\n  readonly _State!: InferUnionState<TVariants>;\n  readonly _Proxy!: UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>;\n  readonly _TRequired!: TRequired;\n  readonly _THasDefault!: THasDefault;\n  readonly TSetInput!: UnionSetInput<TVariants>;\n  readonly TUpdateInput!: UnionSetInput<TVariants>;\n\n  private readonly _schema: UnionPrimitiveSchema<TVariants, TDiscriminator>;\n\n  private readonly _opDefinitions = {\n    set: OperationDefinition.make({\n      kind: \"union.set\" as const,\n      payload: Schema.Unknown,\n      target: Schema.Unknown,\n      apply: (payload) => payload,\n    }),\n  };\n\n  constructor(schema: UnionPrimitiveSchema<TVariants, TDiscriminator>) {\n    this._schema = schema;\n  }\n\n  /** Mark this union as required */\n  required(): UnionPrimitive<TVariants, TDiscriminator, true, THasDefault> {\n    return new UnionPrimitive({\n      ...this._schema,\n      required: true,\n    });\n  }\n\n  /** Set a default value for this union */\n  default(defaultValue: UnionSetInput<TVariants>): UnionPrimitive<TVariants, TDiscriminator, true, true> {\n    // Apply defaults to the variant\n    const merged = this._applyVariantDefaults(defaultValue as Partial<InferUnionState<TVariants>>);\n    return new UnionPrimitive({\n      ...this._schema,\n      defaultValue: merged,\n    });\n  }\n\n  /** Get the discriminator field name */\n  get discriminator(): TDiscriminator {\n    return this._schema.discriminator;\n  }\n\n  /** Get the variants */\n  get variants(): TVariants {\n    return this._schema.variants;\n  }\n\n  /** Find the variant key from a state value */\n  private _findVariantKey(state: InferUnionState<TVariants>): keyof TVariants | undefined {\n    if (typeof state !== \"object\" || state === null) {\n      return undefined;\n    }\n    const discriminatorValue = (state as Record<string, unknown>)[this._schema.discriminator];\n    \n    // Find the variant that matches this discriminator value\n    for (const key in this._schema.variants) {\n      const variant = this._schema.variants[key]!;\n      const discriminatorField = variant.fields[this._schema.discriminator];\n      if (discriminatorField && discriminatorField._tag === \"LiteralPrimitive\") {\n        const literalPrimitive = discriminatorField as LiteralPrimitive<any, any, any>;\n        if (literalPrimitive.literal === discriminatorValue) {\n          return key;\n        }\n      }\n    }\n    return undefined;\n  }\n\n  /** Apply defaults to a variant value based on the discriminator */\n  private _applyVariantDefaults(value: Partial<InferUnionState<TVariants>>): InferUnionState<TVariants> {\n    const variantKey = this._findVariantKey(value as InferUnionState<TVariants>);\n    if (!variantKey) {\n      return value as InferUnionState<TVariants>;\n    }\n    \n    const variantPrimitive = this._schema.variants[variantKey]!;\n    return applyDefaults(variantPrimitive as AnyPrimitive, value) as InferUnionState<TVariants>;\n  }\n\n  readonly _internal: PrimitiveInternal<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>> = {\n    createProxy: (\n      env: ProxyEnvironment.ProxyEnvironment,\n      operationPath: OperationPath.OperationPath\n    ): UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault> => {\n      const variants = this._schema.variants;\n      const defaultValue = this._schema.defaultValue;\n\n      return {\n        get: (): MaybeUndefined<InferUnionState<TVariants>, TRequired, THasDefault> => {\n          const state = env.getState(operationPath) as InferUnionState<TVariants> | undefined;\n          return (state ?? defaultValue) as MaybeUndefined<InferUnionState<TVariants>, TRequired, THasDefault>;\n        },\n        set: (value: UnionSetInput<TVariants>) => {\n          // Apply defaults for the variant\n          const merged = this._applyVariantDefaults(value as Partial<InferUnionState<TVariants>>);\n          env.addOperation(\n            Operation.fromDefinition(operationPath, this._opDefinitions.set, merged)\n          );\n        },\n        as: <K extends keyof TVariants>(variant: K): InferProxy<TVariants[K]> => {\n          const variantPrimitive = variants[variant];\n          if (!variantPrimitive) {\n            throw new ValidationError(`Unknown variant: ${globalThis.String(variant)}`);\n          }\n          return variantPrimitive._internal.createProxy(env, operationPath) as InferProxy<TVariants[K]>;\n        },\n        match: <R,>(handlers: { [K in keyof TVariants]: (proxy: InferProxy<TVariants[K]>) => R }): R | undefined => {\n          const state = env.getState(operationPath) as InferUnionState<TVariants> | undefined;\n          if (!state) return undefined;\n          \n          const variantKey = this._findVariantKey(state);\n          if (!variantKey) return undefined;\n          \n          const handler = handlers[variantKey];\n          if (!handler) return undefined;\n          \n          const variantProxy = variants[variantKey]!._internal.createProxy(env, operationPath) as InferProxy<TVariants[typeof variantKey]>;\n          return handler(variantProxy);\n        },\n        toSnapshot: (): MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault> => {\n          const state = env.getState(operationPath) as InferUnionState<TVariants> | undefined;\n          const effectiveState = state ?? defaultValue;\n          if (!effectiveState) {\n            return undefined as MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault>;\n          }\n          \n          const variantKey = this._findVariantKey(effectiveState);\n          if (!variantKey) {\n            return undefined as MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault>;\n          }\n          \n          const variantPrimitive = variants[variantKey]!;\n          const variantProxy = variantPrimitive._internal.createProxy(env, operationPath);\n          return (variantProxy as unknown as { toSnapshot(): InferUnionSnapshot<TVariants> }).toSnapshot() as MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault>;\n        },\n      };\n    },\n\n    applyOperation: (\n      state: InferUnionState<TVariants> | undefined,\n      operation: Operation.Operation<any, any, any>\n    ): InferUnionState<TVariants> => {\n      const path = operation.path;\n      const tokens = path.toTokens().filter((t: string) => t !== \"\");\n\n      // If path is empty, this is a union-level operation\n      if (tokens.length === 0) {\n        if (operation.kind !== \"union.set\") {\n          throw new ValidationError(`UnionPrimitive root cannot apply operation of kind: ${operation.kind}`);\n        }\n\n        const payload = operation.payload;\n        if (typeof payload !== \"object\" || payload === null) {\n          throw new ValidationError(`UnionPrimitive.set requires an object payload`);\n        }\n\n        // Validate that the discriminator field exists and matches a variant\n        const discriminatorValue = (payload as Record<string, unknown>)[this._schema.discriminator];\n        if (discriminatorValue === undefined) {\n          throw new ValidationError(`UnionPrimitive.set requires a \"${this._schema.discriminator}\" discriminator field`);\n        }\n\n        return payload as InferUnionState<TVariants>;\n      }\n\n      // Otherwise, delegate to the active variant\n      // We need to determine which variant is active based on current state\n      if (state === undefined) {\n        throw new ValidationError(`Cannot apply nested operation to undefined union state`);\n      }\n\n      const variantKey = this._findVariantKey(state);\n      if (variantKey === undefined) {\n        throw new ValidationError(`Cannot determine active variant from state`);\n      }\n\n      const variantPrimitive = this._schema.variants[variantKey]!;\n      const newState = variantPrimitive._internal.applyOperation(\n        state as InferState<typeof variantPrimitive>,\n        operation\n      );\n\n      return newState as InferUnionState<TVariants>;\n    },\n\n    getInitialState: (): InferUnionState<TVariants> | undefined => {\n      return this._schema.defaultValue;\n    },\n\n    transformOperation: (\n      clientOp: Operation.Operation<any, any, any>,\n      serverOp: Operation.Operation<any, any, any>\n    ): Transform.TransformResult => {\n      const clientPath = clientOp.path;\n      const serverPath = serverOp.path;\n\n      // If paths don't overlap at all, no transformation needed\n      if (!OperationPath.pathsOverlap(clientPath, serverPath)) {\n        return { type: \"transformed\", operation: clientOp };\n      }\n\n      const clientTokens = clientPath.toTokens().filter((t: string) => t !== \"\");\n      const serverTokens = serverPath.toTokens().filter((t: string) => t !== \"\");\n\n      // If both are at root level (union.set operations)\n      if (clientTokens.length === 0 && serverTokens.length === 0) {\n        // Client wins (last-write-wins)\n        return { type: \"transformed\", operation: clientOp };\n      }\n\n      // If server set entire union and client is updating a field\n      if (serverTokens.length === 0 && serverOp.kind === \"union.set\") {\n        // Client's field operation proceeds - optimistic update\n        // Server will validate/reject if needed\n        return { type: \"transformed\", operation: clientOp };\n      }\n\n      // If client set entire union and server is updating a field\n      if (clientTokens.length === 0 && clientOp.kind === \"union.set\") {\n        // Client's union.set supersedes server's field update\n        return { type: \"transformed\", operation: clientOp };\n      }\n\n      // Both operations target fields within the union\n      // Since union variants are struct primitives, delegate to the first variant\n      // that matches (they all should have the same field structure for the overlapping field)\n      if (clientTokens.length > 0 && serverTokens.length > 0) {\n        const clientField = clientTokens[0];\n        const serverField = serverTokens[0];\n\n        // Different fields - no conflict\n        if (clientField !== serverField) {\n          return { type: \"transformed\", operation: clientOp };\n        }\n\n        // Same field - delegate to a variant (use first variant as they share structure)\n        const variantKeys = Object.keys(this._schema.variants);\n        if (variantKeys.length === 0) {\n          return { type: \"transformed\", operation: clientOp };\n        }\n\n        const firstVariant = this._schema.variants[variantKeys[0]!]!;\n        const result = firstVariant._internal.transformOperation(clientOp, serverOp);\n\n        return result;\n      }\n\n      // Default: no transformation needed\n      return { type: \"transformed\", operation: clientOp };\n    },\n  };\n}\n\n/** Options for creating a Union primitive */\nexport interface UnionOptions<TVariants extends UnionVariants, TDiscriminator extends string> {\n  /** The field name used to discriminate between variants (defaults to \"type\") */\n  readonly discriminator?: TDiscriminator;\n  /** The variant struct primitives */\n  readonly variants: TVariants;\n}\n\n/** Creates a new UnionPrimitive with the given variants */\nexport function Union<TVariants extends UnionVariants>(\n  options: UnionOptions<TVariants, \"type\">\n): UnionPrimitive<TVariants, \"type\", false, false>;\nexport function Union<TVariants extends UnionVariants, TDiscriminator extends string>(\n  options: UnionOptions<TVariants, TDiscriminator>\n): UnionPrimitive<TVariants, TDiscriminator, false, false>;\nexport function Union<TVariants extends UnionVariants, TDiscriminator extends string = \"type\">(\n  options: UnionOptions<TVariants, TDiscriminator>\n): UnionPrimitive<TVariants, TDiscriminator, false, false> {\n  const discriminator = (options.discriminator ?? \"type\") as TDiscriminator;\n  return new UnionPrimitive({\n    required: false,\n    defaultValue: undefined,\n    discriminator,\n    variants: options.variants,\n  });\n}\n\n"],"mappings":"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"}

package/dist/primitives/shared.cjs

@@ -0,0 +1,60 @@
+const require_defineProperty = require('../_virtual/_@oxc-project_runtime@0.103.0/helpers/defineProperty.cjs');
+const require_objectSpread2 = require('../_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.cjs');
+
+//#region src/primitives/shared.ts
+var ValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		require_defineProperty._defineProperty(this, "_tag", "ValidationError");
+		this.name = "ValidationError";
+	}
+};
+/**
+* Runs all validators against a value, throwing ValidationError if any fail.
+*/
+function runValidators(value, validators) {
+	for (const validator of validators) if (!validator.validate(value)) throw new ValidationError(validator.message);
+}
+/**
+* Checks if an operation is compatible with the given operation definitions.
+* @param operation - The operation to check.
+* @param operationDefinitions - The operation definitions to check against.
+* @returns True if the operation is compatible, false otherwise.
+*/
+function isCompatibleOperation(operation, operationDefinitions) {
+	return Object.values(operationDefinitions).some((value) => value.kind === operation.kind);
+}
+/**
+* Applies default values to a partial input, recursively handling nested structs.
+* 
+* Uses a two-layer approach:
+* 1. First, get the struct's initial state (which includes struct-level defaults)
+* 2. Then, layer the provided values on top
+* 3. Finally, ensure nested structs are recursively processed
+* 
+* @param primitive - The primitive definition containing field information
+* @param value - The partial value provided by the user
+* @returns The value with defaults applied for missing fields
+*/
+function applyDefaults(primitive, value) {
+	if (primitive._tag === "StructPrimitive") {
+		var _structPrimitive$_int;
+		const structPrimitive = primitive;
+		const result = require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, (_structPrimitive$_int = structPrimitive._internal.getInitialState()) !== null && _structPrimitive$_int !== void 0 ? _structPrimitive$_int : {}), value);
+		for (const key in structPrimitive.fields) {
+			const fieldPrimitive = structPrimitive.fields[key];
+			if (result[key] === void 0) {
+				const fieldDefault = fieldPrimitive._internal.getInitialState();
+				if (fieldDefault !== void 0) result[key] = fieldDefault;
+			} else if (fieldPrimitive._tag === "StructPrimitive" && typeof result[key] === "object" && result[key] !== null) result[key] = applyDefaults(fieldPrimitive, result[key]);
+		}
+		return result;
+	}
+	return value;
+}
+
+//#endregion
+exports.ValidationError = ValidationError;
+exports.applyDefaults = applyDefaults;
+exports.isCompatibleOperation = isCompatibleOperation;
+exports.runValidators = runValidators;