@voidhash/mimic 0.0.2 → 0.0.3

package/dist/primitives/Either.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Either.mjs","names":["OperationDefinition.make","Operation.fromDefinition","OperationPath.pathsOverlap","syntheticOp: Operation.Operation<any, any, any>"],"sources":["../../src/primitives/Either.ts"],"sourcesContent":["import { 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, InferState, NeedsValue } from \"./shared\";\nimport { ValidationError } from \"./shared\";\nimport { StringPrimitive } from \"./String\";\nimport { NumberPrimitive } from \"./Number\";\nimport { BooleanPrimitive } from \"./Boolean\";\nimport { LiteralPrimitive, LiteralValue } from \"./Literal\";\n\n// =============================================================================\n// Either Primitive - Simple Type Union\n// =============================================================================\n\ntype InferSetInput<TVariants extends readonly ScalarPrimitive[], TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<InferEitherState<TVariants>, TRequired, THasDefault>\ntype InferUpdateInput<TVariants extends readonly ScalarPrimitive[], TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<InferEitherState<TVariants>, TRequired, THasDefault>\n\n/**\n * Scalar primitives that can be used as variants in Either\n */\nexport type ScalarPrimitive =\n  | StringPrimitive<any, any>\n  | NumberPrimitive<any, any>\n  | BooleanPrimitive<any, any>\n  | LiteralPrimitive<any, any, any>;\n\n/**\n * Infer the union state type from a tuple of scalar primitives\n */\nexport type InferEitherState<TVariants extends readonly ScalarPrimitive[]> =\n  InferState<TVariants[number]>;\n\n/**\n * Infer the union snapshot type from a tuple of scalar primitives\n */\nexport type InferEitherSnapshot<TVariants extends readonly ScalarPrimitive[]> =\n  InferState<TVariants[number]>;\n\n/**\n * Match handlers for Either - optional handlers for each scalar type\n */\nexport interface EitherMatchHandlers<R> {\n  string?: (value: string) => R;\n  number?: (value: number) => R;\n  boolean?: (value: boolean) => R;\n  literal?: (value: LiteralValue) => R;\n}\n\n/**\n * Proxy for accessing Either values\n */\nexport interface EitherProxy<TVariants extends readonly ScalarPrimitive[], TRequired extends boolean = false, THasDefault extends boolean = false> {\n  /** Gets the current value */\n  get(): MaybeUndefined<InferEitherState<TVariants>, TRequired, THasDefault>;\n\n  /** Sets the value to any of the allowed variant types */\n  set(value: InferSetInput<TVariants, TRequired, THasDefault>): void;\n\n  /** This is the same as set. Updates the value, generating an either.set operation */\n  update(value: InferUpdateInput<TVariants, TRequired, THasDefault>): void;\n\n  /** Pattern match on the value type */\n  match<R>(handlers: EitherMatchHandlers<R>): R | undefined;\n\n  /** Returns a readonly snapshot of the value for rendering */\n  toSnapshot(): MaybeUndefined<InferEitherSnapshot<TVariants>, TRequired, THasDefault>;\n}\n\ninterface EitherPrimitiveSchema<TVariants extends readonly ScalarPrimitive[]> {\n  readonly required: boolean;\n  readonly defaultValue: InferEitherState<TVariants> | undefined;\n  readonly variants: TVariants;\n}\n\nexport class EitherPrimitive<TVariants extends readonly ScalarPrimitive[], TRequired extends boolean = false, THasDefault extends boolean = false>\n  implements Primitive<InferEitherState<TVariants>, EitherProxy<TVariants, TRequired, THasDefault>, TRequired, THasDefault, InferSetInput<TVariants, TRequired, THasDefault>, InferUpdateInput<TVariants, TRequired, THasDefault>>\n{\n  readonly _tag = \"EitherPrimitive\" as const;\n  readonly _State!: InferEitherState<TVariants>;\n  readonly _Proxy!: EitherProxy<TVariants, TRequired, THasDefault>;\n  readonly _TRequired!: TRequired;\n  readonly _THasDefault!: THasDefault;\n  readonly TUpdateInput!: InferUpdateInput<TVariants, TRequired, THasDefault>;\n  readonly TSetInput!: InferSetInput<TVariants, TRequired, THasDefault>;\n\n  private readonly _schema: EitherPrimitiveSchema<TVariants>;\n\n  private readonly _opDefinitions = {\n    set: OperationDefinition.make({\n      kind: \"either.set\" as const,\n      payload: Schema.Unknown,\n      target: Schema.Unknown,\n      apply: (payload) => payload,\n    }),\n  };\n\n  constructor(schema: EitherPrimitiveSchema<TVariants>) {\n    this._schema = schema;\n  }\n\n  /** Mark this either as required */\n  required(): EitherPrimitive<TVariants, true, THasDefault> {\n    return new EitherPrimitive({\n      ...this._schema,\n      required: true,\n    });\n  }\n\n  /** Set a default value for this either */\n  default(defaultValue: InferEitherState<TVariants>): EitherPrimitive<TVariants, TRequired, true> {\n    return new EitherPrimitive({\n      ...this._schema,\n      defaultValue,\n    });\n  }\n\n  /** Get the variants */\n  get variants(): TVariants {\n    return this._schema.variants;\n  }\n\n  /**\n   * Determine the type category of a value based on the variants\n   */\n  private _getValueType(value: unknown): \"string\" | \"number\" | \"boolean\" | \"literal\" | undefined {\n    const valueType = typeof value;\n\n    // Check for literal matches first (they take priority)\n    for (const variant of this._schema.variants) {\n      if (variant._tag === \"LiteralPrimitive\") {\n        const literalVariant = variant as LiteralPrimitive<any, any, any>;\n        if (value === literalVariant.literal) {\n          return \"literal\";\n        }\n      }\n    }\n\n    // Check for type matches\n    if (valueType === \"string\") {\n      for (const variant of this._schema.variants) {\n        if (variant._tag === \"StringPrimitive\") {\n          return \"string\";\n        }\n      }\n    }\n\n    if (valueType === \"number\") {\n      for (const variant of this._schema.variants) {\n        if (variant._tag === \"NumberPrimitive\") {\n          return \"number\";\n        }\n      }\n    }\n\n    if (valueType === \"boolean\") {\n      for (const variant of this._schema.variants) {\n        if (variant._tag === \"BooleanPrimitive\") {\n          return \"boolean\";\n        }\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Find the matching variant for a value.\n   * For literals, matches exact value. For other types, matches by typeof.\n   */\n  private _findMatchingVariant(value: unknown): ScalarPrimitive | undefined {\n    const valueType = typeof value;\n\n    // Check for literal matches first (they take priority)\n    for (const variant of this._schema.variants) {\n      if (variant._tag === \"LiteralPrimitive\") {\n        const literalVariant = variant as LiteralPrimitive<any, any, any>;\n        if (value === literalVariant.literal) {\n          return variant;\n        }\n      }\n    }\n\n    // Check for type matches\n    if (valueType === \"string\") {\n      for (const variant of this._schema.variants) {\n        if (variant._tag === \"StringPrimitive\") {\n          return variant;\n        }\n      }\n    }\n\n    if (valueType === \"number\") {\n      for (const variant of this._schema.variants) {\n        if (variant._tag === \"NumberPrimitive\") {\n          return variant;\n        }\n      }\n    }\n\n    if (valueType === \"boolean\") {\n      for (const variant of this._schema.variants) {\n        if (variant._tag === \"BooleanPrimitive\") {\n          return variant;\n        }\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Get the operation kind for a variant\n   */\n  private _getVariantOperationKind(variant: ScalarPrimitive): string {\n    switch (variant._tag) {\n      case \"StringPrimitive\":\n        return \"string.set\";\n      case \"NumberPrimitive\":\n        return \"number.set\";\n      case \"BooleanPrimitive\":\n        return \"boolean.set\";\n      case \"LiteralPrimitive\":\n        return \"literal.set\";\n      default:\n        return \"unknown.set\";\n    }\n  }\n\n  /**\n   * Validate a value against the matching variant, including running its validators.\n   * Throws ValidationError if the value doesn't match any variant or fails validation.\n   */\n  private _validateAndApplyToVariant(value: unknown, path: OperationPath.OperationPath): void {\n    const matchingVariant = this._findMatchingVariant(value);\n    \n    if (!matchingVariant) {\n      const allowedTypes = this._schema.variants.map((v) => v._tag).join(\", \");\n      throw new ValidationError(\n        `EitherPrimitive.set requires a value matching one of: ${allowedTypes}, got: ${typeof value}`\n      );\n    }\n\n    // Create a synthetic operation for the variant's applyOperation\n    const variantOpKind = this._getVariantOperationKind(matchingVariant);\n    const syntheticOp: Operation.Operation<any, any, any> = {\n      kind: variantOpKind,\n      path: path,\n      payload: value,\n    };\n\n    // Delegate to the variant's applyOperation which runs its validators\n    // This will throw ValidationError if validation fails\n    matchingVariant._internal.applyOperation(undefined, syntheticOp);\n  }\n\n  readonly _internal: PrimitiveInternal<InferEitherState<TVariants>, EitherProxy<TVariants, TRequired, THasDefault>> = {\n    createProxy: (\n      env: ProxyEnvironment.ProxyEnvironment,\n      operationPath: OperationPath.OperationPath\n    ): EitherProxy<TVariants, TRequired, THasDefault> => {\n      const defaultValue = this._schema.defaultValue;\n\n      return {\n        get: (): MaybeUndefined<InferEitherState<TVariants>, TRequired, THasDefault> => {\n          const state = env.getState(operationPath) as InferEitherState<TVariants> | undefined;\n          return (state ?? defaultValue) as MaybeUndefined<InferEitherState<TVariants>, TRequired, THasDefault>;\n        },\n        set: (value: InferSetInput<TVariants, TRequired, THasDefault>) => {\n          env.addOperation(\n            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)\n          );\n        },\n        update: (value: InferUpdateInput<TVariants, TRequired, THasDefault>) => {\n          env.addOperation(\n            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)\n          );\n        },\n        match: <R,>(handlers: EitherMatchHandlers<R>): R | undefined => {\n          const currentState = env.getState(operationPath) as InferEitherState<TVariants> | undefined;\n          const effectiveState = currentState ?? defaultValue;\n          if (effectiveState === undefined) return undefined;\n\n          const valueType = this._getValueType(effectiveState);\n          if (!valueType) return undefined;\n\n          switch (valueType) {\n            case \"string\":\n              return handlers.string?.(effectiveState as string);\n            case \"number\":\n              return handlers.number?.(effectiveState as number);\n            case \"boolean\":\n              return handlers.boolean?.(effectiveState as boolean);\n            case \"literal\":\n              return handlers.literal?.(effectiveState as LiteralValue);\n            default:\n              return undefined;\n          }\n        },\n        toSnapshot: (): MaybeUndefined<InferEitherSnapshot<TVariants>, TRequired, THasDefault> => {\n          const state = env.getState(operationPath) as InferEitherState<TVariants> | undefined;\n          return (state ?? defaultValue) as MaybeUndefined<InferEitherSnapshot<TVariants>, TRequired, THasDefault>;\n        },\n      };\n    },\n\n    applyOperation: (\n      _state: InferEitherState<TVariants> | undefined,\n      operation: Operation.Operation<any, any, any>\n    ): InferEitherState<TVariants> => {\n      if (operation.kind !== \"either.set\") {\n        throw new ValidationError(`EitherPrimitive cannot apply operation of kind: ${operation.kind}`);\n      }\n\n      const payload = operation.payload;\n\n      // Validate that the payload matches one of the variant types and passes its validators\n      this._validateAndApplyToVariant(payload, operation.path);\n\n      return payload as InferEitherState<TVariants>;\n    },\n\n    getInitialState: (): InferEitherState<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      // If paths don't overlap, no transformation needed\n      if (!OperationPath.pathsOverlap(clientOp.path, serverOp.path)) {\n        return { type: \"transformed\", operation: clientOp };\n      }\n\n      // For same path, client wins (last-write-wins)\n      return { type: \"transformed\", operation: clientOp };\n    },\n  };\n}\n\n/**\n * Creates a new EitherPrimitive with the given scalar variant types.\n * Validators defined on the variants are applied when validating values.\n *\n * @example\n * ```typescript\n * // String or number\n * const value = Either(String(), Number());\n *\n * // String, number, or boolean\n * const status = Either(String(), Number(), Boolean()).default(\"pending\");\n *\n * // With literal types\n * const mode = Either(Literal(\"auto\"), Literal(\"manual\"), Number());\n *\n * // With validators - validates string length and number range\n * const constrained = Either(\n *   String().min(2).max(50),\n *   Number().max(255)\n * );\n * ```\n */\nexport function Either<TVariants extends readonly ScalarPrimitive[]>(\n  ...variants: TVariants\n): EitherPrimitive<TVariants, false, false> {\n  if (variants.length === 0) {\n    throw new ValidationError(\"Either requires at least one variant\");\n  }\n\n  return new EitherPrimitive({\n    required: false,\n    defaultValue: undefined,\n    variants,\n  });\n}\n\n"],"mappings":"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"}

package/dist/primitives/Lazy.cjs

@@ -0,0 +1,46 @@
+const require_defineProperty = require('../_virtual/_@oxc-project_runtime@0.103.0/helpers/defineProperty.cjs');
+
+//#region src/primitives/Lazy.ts
+var LazyPrimitive = class {
+	constructor(thunk) {
+		require_defineProperty._defineProperty(this, "_tag", "LazyPrimitive");
+		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, "_thunk", void 0);
+		require_defineProperty._defineProperty(this, "_resolved", void 0);
+		require_defineProperty._defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				return this._resolve()._internal.createProxy(env, operationPath);
+			},
+			applyOperation: (state, operation) => {
+				return this._resolve()._internal.applyOperation(state, operation);
+			},
+			getInitialState: () => {
+				return this._resolve()._internal.getInitialState();
+			},
+			transformOperation: (clientOp, serverOp) => {
+				return this._resolve()._internal.transformOperation(clientOp, serverOp);
+			}
+		});
+		this._thunk = thunk;
+	}
+	/** Resolve and cache the lazy primitive */
+	_resolve() {
+		if (this._resolved === void 0) this._resolved = this._thunk();
+		return this._resolved;
+	}
+	/** Mark this lazy primitive as required (delegates to resolved) */
+	required() {
+		return this;
+	}
+};
+/** Creates a new LazyPrimitive with the given thunk */
+const Lazy = (thunk) => new LazyPrimitive(thunk);
+
+//#endregion
+exports.Lazy = Lazy;
+exports.LazyPrimitive = LazyPrimitive;

package/dist/primitives/Lazy.d.cts

@@ -0,0 +1,46 @@
+import { AnyPrimitive, InferProxy, InferSetInput, InferSnapshot, InferState, InferUpdateInput, Primitive, PrimitiveInternal } from "./shared.cjs";
+
+//#region src/primitives/Lazy.d.ts
+
+/**
+ * Type to infer SetInput from a lazy thunk
+ */
+type InferLazySetInput<T extends () => AnyPrimitive> = InferSetInput<ReturnType<T>>;
+/**
+ * Type to infer UpdateInput from a lazy thunk
+ */
+type InferLazyUpdateInput<T extends () => AnyPrimitive> = InferUpdateInput<ReturnType<T>>;
+/**
+ * Type to infer state from a lazy thunk
+ */
+type InferLazyState<T extends () => AnyPrimitive> = InferState<ReturnType<T>>;
+/**
+ * Type to infer proxy from a lazy thunk
+ */
+type InferLazyProxy<T extends () => AnyPrimitive> = InferProxy<ReturnType<T>>;
+/**
+ * Type to infer snapshot from a lazy thunk
+ */
+type InferLazySnapshot<T extends () => AnyPrimitive> = InferSnapshot<ReturnType<T>>;
+declare class LazyPrimitive<TThunk extends () => AnyPrimitive> implements Primitive<InferLazyState<TThunk>, InferLazyProxy<TThunk>, false, false, InferLazySetInput<TThunk>, InferLazyUpdateInput<TThunk>> {
+  readonly _tag: "LazyPrimitive";
+  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;
+  private _resolved;
+  constructor(thunk: TThunk);
+  /** Resolve and cache the lazy primitive */
+  private _resolve;
+  /** Mark this lazy primitive as required (delegates to resolved) */
+  required(): LazyPrimitive<TThunk>;
+  readonly _internal: PrimitiveInternal<InferLazyState<TThunk>, InferLazyProxy<TThunk>>;
+}
+/** Creates a new LazyPrimitive with the given thunk */
+declare const Lazy: <TThunk extends () => AnyPrimitive>(thunk: TThunk) => LazyPrimitive<TThunk>;
+//#endregion
+export { InferLazyProxy, InferLazySetInput, InferLazySnapshot, InferLazyState, InferLazyUpdateInput, Lazy, LazyPrimitive };
+//# sourceMappingURL=Lazy.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Lazy.d.cts","names":[],"sources":["../../src/primitives/Lazy.ts"],"sourcesContent":[],"mappings":";;;;;;AAaA;AAA8C,KAAlC,iBAAkC,CAAA,UAAA,GAAA,GAAA,YAAA,CAAA,GAAgB,aAAhB,CAA8B,UAA9B,CAAyC,CAAzC,CAAA,CAAA;;;;AAA6B,KAK/D,oBAL+D,CAAA,UAAA,GAAA,GAK1B,YAL0B,CAAA,GAKV,gBALU,CAKO,UALP,CAKkB,CALlB,CAAA,CAAA;AAK3E;;;AAAkF,KAMtE,cANsE,CAAA,UAAA,GAAA,GAMvC,YANuC,CAAA,GAMvB,UANuB,CAMZ,UANY,CAMD,CANC,CAAA,CAAA;;;AAMlF;AAA2C,KAK/B,cAL+B,CAAA,UAAA,GAAA,GAKA,YALA,CAAA,GAKgB,UALhB,CAK2B,UAL3B,CAKsC,CALtC,CAAA,CAAA;;;;AAA0B,KAUzD,iBAVyD,CAAA,UAAA,GAAA,GAUvB,YAVuB,CAAA,GAUP,aAVO,CAUO,UAVP,CAUkB,CAVlB,CAAA,CAAA;AAKzD,cAOC,aAPa,CAAA,eAAA,GAAA,GAOsB,YAPtB,CAAA,YAQb,SARa,CAQH,cARG,CAQY,MARZ,CAAA,EAQqB,cARrB,CAQoC,MARpC,CAAA,EAAA,KAAA,EAAA,KAAA,EAQ2D,iBAR3D,CAQ6E,MAR7E,CAAA,EAQsF,oBARtF,CAQ2G,MAR3G,CAAA,CAAA,CAAA;EAAiB,SAAA,IAAA,EAAA,eAAA;EAAsC,SAAA,MAAA,EAW7D,cAX6D,CAW9C,MAX8C,CAAA;EAAX,SAAA,MAAA,EAYlD,cAZkD,CAYnC,MAZmC,CAAA;EAAX,SAAA,UAAA,EAAA,KAAA;EAAU,SAAA,YAAA,EAAA,KAAA;EAKzD,SAAA,SAAA,EAUW,iBAVM,CAUY,MAVZ,CAAA;EAAiB,SAAA,YAAA,EAWpB,oBAXoB,CAWC,MAXD,CAAA;EAAyC,iBAAA,MAAA;EAAX,QAAA,SAAA;EAAd,WAAA,CAAA,KAAA,EAgBzC,MAhByC;EAAa;EAE9D,QAAA,QAAa;EAAsB;EACV,QAAA,CAAA,CAAA,EA0BxB,aA1BwB,CA0BV,MA1BU,CAAA;EAAf,SAAA,SAAA,EAgCD,iBAhCC,CAgCiB,cAhCjB,CAgCgC,MAhChC,CAAA,EAgCyC,cAhCzC,CAgCwD,MAhCxD,CAAA,CAAA;;;AAAgF,cA+D1F,IA/D0F,EAAA,CAAA,eAAA,GAAA,GA+D7D,YA/D6D,CAAA,CAAA,KAAA,EA+DxC,MA/DwC,EAAA,GA+D/B,aA/D+B,CA+DjB,MA/DiB,CAAA"}

package/dist/primitives/Lazy.d.mts

@@ -0,0 +1,46 @@
+import { AnyPrimitive, InferProxy, InferSetInput, InferSnapshot, InferState, InferUpdateInput, Primitive, PrimitiveInternal } from "./shared.mjs";
+import "../Primitive.mjs";
+
+//#region src/primitives/Lazy.d.ts
+/**
+ * Type to infer SetInput from a lazy thunk
+ */
+type InferLazySetInput<T extends () => AnyPrimitive> = InferSetInput<ReturnType<T>>;
+/**
+ * Type to infer UpdateInput from a lazy thunk
+ */
+type InferLazyUpdateInput<T extends () => AnyPrimitive> = InferUpdateInput<ReturnType<T>>;
+/**
+ * Type to infer state from a lazy thunk
+ */
+type InferLazyState<T extends () => AnyPrimitive> = InferState<ReturnType<T>>;
+/**
+ * Type to infer proxy from a lazy thunk
+ */
+type InferLazyProxy<T extends () => AnyPrimitive> = InferProxy<ReturnType<T>>;
+/**
+ * Type to infer snapshot from a lazy thunk
+ */
+type InferLazySnapshot<T extends () => AnyPrimitive> = InferSnapshot<ReturnType<T>>;
+declare class LazyPrimitive<TThunk extends () => AnyPrimitive> implements Primitive<InferLazyState<TThunk>, InferLazyProxy<TThunk>, false, false, InferLazySetInput<TThunk>, InferLazyUpdateInput<TThunk>> {
+  readonly _tag: "LazyPrimitive";
+  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;
+  private _resolved;
+  constructor(thunk: TThunk);
+  /** Resolve and cache the lazy primitive */
+  private _resolve;
+  /** Mark this lazy primitive as required (delegates to resolved) */
+  required(): LazyPrimitive<TThunk>;
+  readonly _internal: PrimitiveInternal<InferLazyState<TThunk>, InferLazyProxy<TThunk>>;
+}
+/** Creates a new LazyPrimitive with the given thunk */
+declare const Lazy: <TThunk extends () => AnyPrimitive>(thunk: TThunk) => LazyPrimitive<TThunk>;
+//#endregion
+export { InferLazyProxy, InferLazySetInput, InferLazySnapshot, InferLazyState, InferLazyUpdateInput, Lazy, LazyPrimitive };
+//# sourceMappingURL=Lazy.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Lazy.d.mts","names":[],"sources":["../../src/primitives/Lazy.ts"],"sourcesContent":[],"mappings":";;;;;;;AAaY,KAAA,iBAAiB,CAAA,UAAA,GAAA,GAAiB,YAAjB,CAAA,GAAiC,aAAjC,CAA+C,UAA/C,CAA0D,CAA1D,CAAA,CAAA;;;;AAAiC,KAKlD,oBALkD,CAAA,UAAA,GAAA,GAKb,YALa,CAAA,GAKG,gBALH,CAKoB,UALpB,CAK+B,CAL/B,CAAA,CAAA;;AAK9D;;AAA6F,KAMjF,cANiF,CAAA,UAAA,GAAA,GAMlD,YANkD,CAAA,GAMlC,UANkC,CAMvB,UANuB,CAMZ,CANY,CAAA,CAAA;;;;AAMjF,KAKA,cALc,CAAA,UAAA,GAAA,GAKiB,YALjB,CAAA,GAKiC,UALjC,CAK4C,UAL5C,CAKuD,CALvD,CAAA,CAAA;;;;AAAiC,KAU/C,iBAV+C,CAAA,UAAA,GAAA,GAUb,YAVa,CAAA,GAUG,aAVH,CAUiB,UAVjB,CAU4B,CAV5B,CAAA,CAAA;AAAU,cAYxD,aAZwD,CAAA,eAAA,GAAA,GAYrB,YAZqB,CAAA,YAaxD,SAbwD,CAa9C,cAb8C,CAa/B,MAb+B,CAAA,EAatB,cAbsB,CAaP,MAbO,CAAA,EAAA,KAAA,EAAA,KAAA,EAagB,iBAbhB,CAakC,MAblC,CAAA,EAa2C,oBAb3C,CAagE,MAbhE,CAAA,CAAA,CAAA;EAKzD,SAAA,IAAA,EAAA,eAAc;EAAiB,SAAA,MAAA,EAWvB,cAXuB,CAWR,MAXQ,CAAA;EAAsC,SAAA,MAAA,EAY7D,cAZ6D,CAY9C,MAZ8C,CAAA;EAAX,SAAA,UAAA,EAAA,KAAA;EAAX,SAAA,YAAA,EAAA,KAAA;EAAU,SAAA,SAAA,EAe9C,iBAf8C,CAe5B,MAf4B,CAAA;EAKzD,SAAA,YAAiB,EAWH,oBAXG,CAWkB,MAXlB,CAAA;EAAiB,iBAAA,MAAA;EAAyC,QAAA,SAAA;EAAX,WAAA,CAAA,KAAA,EAgBvD,MAhBuD;EAAd;EAAa,QAAA,QAAA;EAE9D;EAAmC,QAAA,CAAA,CAAA,EA2BlC,aA3BkC,CA2BpB,MA3BoB,CAAA;EACV,SAAA,SAAA,EAgChB,iBAhCgB,CAgCE,cAhCF,CAgCiB,MAhCjB,CAAA,EAgC0B,cAhC1B,CAgCyC,MAhCzC,CAAA,CAAA;;;AAAS,cA+DlC,IA/DkC,EAAA,CAAA,eAAA,GAAA,GA+DL,YA/DK,CAAA,CAAA,KAAA,EA+DgB,MA/DhB,EAAA,GA+DyB,aA/DzB,CA+DuC,MA/DvC,CAAA"}

package/dist/primitives/Lazy.mjs

@@ -0,0 +1,46 @@
+import { _defineProperty } from "../_virtual/_@oxc-project_runtime@0.103.0/helpers/defineProperty.mjs";
+
+//#region src/primitives/Lazy.ts
+var LazyPrimitive = class {
+	constructor(thunk) {
+		_defineProperty(this, "_tag", "LazyPrimitive");
+		_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, "_thunk", void 0);
+		_defineProperty(this, "_resolved", void 0);
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				return this._resolve()._internal.createProxy(env, operationPath);
+			},
+			applyOperation: (state, operation) => {
+				return this._resolve()._internal.applyOperation(state, operation);
+			},
+			getInitialState: () => {
+				return this._resolve()._internal.getInitialState();
+			},
+			transformOperation: (clientOp, serverOp) => {
+				return this._resolve()._internal.transformOperation(clientOp, serverOp);
+			}
+		});
+		this._thunk = thunk;
+	}
+	/** Resolve and cache the lazy primitive */
+	_resolve() {
+		if (this._resolved === void 0) this._resolved = this._thunk();
+		return this._resolved;
+	}
+	/** Mark this lazy primitive as required (delegates to resolved) */
+	required() {
+		return this;
+	}
+};
+/** Creates a new LazyPrimitive with the given thunk */
+const Lazy = (thunk) => new LazyPrimitive(thunk);
+
+//#endregion
+export { Lazy, LazyPrimitive };
+//# sourceMappingURL=Lazy.mjs.map

package/dist/primitives/Lazy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Lazy.mjs","names":[],"sources":["../../src/primitives/Lazy.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, AnyPrimitive, InferState, InferProxy, InferSnapshot, InferSetInput, InferUpdateInput } from \"../Primitive\";\nimport { ValidationError } from \"../Primitive\";\nimport { runValidators } from \"./shared\";\n\n/**\n * Type to infer SetInput from a lazy thunk\n */\nexport type InferLazySetInput<T extends () => AnyPrimitive> = InferSetInput<ReturnType<T>>;\n\n/**\n * Type to infer UpdateInput from a lazy thunk\n */\nexport type InferLazyUpdateInput<T extends () => AnyPrimitive> = InferUpdateInput<ReturnType<T>>;\n\n\n/**\n * Type to infer state from a lazy thunk\n */\nexport type InferLazyState<T extends () => AnyPrimitive> = InferState<ReturnType<T>>;\n\n/**\n * Type to infer proxy from a lazy thunk\n */\nexport type InferLazyProxy<T extends () => AnyPrimitive> = InferProxy<ReturnType<T>>;\n\n/**\n * Type to infer snapshot from a lazy thunk\n */\nexport type InferLazySnapshot<T extends () => AnyPrimitive> = InferSnapshot<ReturnType<T>>;\n\nexport class LazyPrimitive<TThunk extends () => AnyPrimitive>\n  implements Primitive<InferLazyState<TThunk>, InferLazyProxy<TThunk>, false, false, InferLazySetInput<TThunk>, InferLazyUpdateInput<TThunk>>\n{\n  readonly _tag = \"LazyPrimitive\" as const;\n  readonly _State!: InferLazyState<TThunk>;\n  readonly _Proxy!: InferLazyProxy<TThunk>;\n  readonly _TRequired!: false;\n  readonly _THasDefault!: false;\n  readonly TSetInput!: InferLazySetInput<TThunk>;\n  readonly TUpdateInput!: InferLazyUpdateInput<TThunk>;\n\n  private readonly _thunk: TThunk;\n  private _resolved: ReturnType<TThunk> | undefined;\n\n  constructor(thunk: TThunk) {\n    this._thunk = thunk;\n  }\n\n  /** Resolve and cache the lazy primitive */\n  private _resolve(): ReturnType<TThunk> {\n    if (this._resolved === undefined) {\n      this._resolved = this._thunk() as ReturnType<TThunk>;\n    }\n    return this._resolved;\n  }\n\n  /** Mark this lazy primitive as required (delegates to resolved) */\n  required(): LazyPrimitive<TThunk> {\n    // Note: For lazy, we can't easily propagate required to the resolved primitive\n    // without resolving it first. This is a limitation.\n    return this;\n  }\n\n  readonly _internal: PrimitiveInternal<InferLazyState<TThunk>, InferLazyProxy<TThunk>> = {\n    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): InferLazyProxy<TThunk> => {\n      const resolved = this._resolve();\n      return resolved._internal.createProxy(env, operationPath) as InferLazyProxy<TThunk>;\n    },\n\n    applyOperation: (\n      state: InferLazyState<TThunk> | undefined,\n      operation: Operation.Operation<any, any, any>\n    ): InferLazyState<TThunk> => {\n      const resolved = this._resolve();\n      return resolved._internal.applyOperation(state, operation) as InferLazyState<TThunk>;\n    },\n\n    getInitialState: (): InferLazyState<TThunk> | undefined => {\n      const resolved = this._resolve();\n      return resolved._internal.getInitialState() as InferLazyState<TThunk> | undefined;\n    },\n\n    transformOperation: (\n      clientOp: Operation.Operation<any, any, any>,\n      serverOp: Operation.Operation<any, any, any>\n    ): Transform.TransformResult => {\n      // Delegate to resolved primitive\n      const resolved = this._resolve();\n      return resolved._internal.transformOperation(clientOp, serverOp);\n    },\n  };\n}\n\n/** Creates a new LazyPrimitive with the given thunk */\nexport const Lazy = <TThunk extends () => AnyPrimitive>(thunk: TThunk): LazyPrimitive<TThunk> =>\n  new LazyPrimitive(thunk);\n\n"],"mappings":";;;AAoCA,IAAa,gBAAb,MAEA;CAYE,YAAY,OAAe;wBAXlB,QAAO;wBACP;wBACA;wBACA;wBACA;wBACA;wBACA;wBAEQ;wBACT;wBAqBC,aAA+E;GACtF,cAAc,KAAwC,kBAAuE;AAE3H,WADiB,KAAK,UAAU,CAChB,UAAU,YAAY,KAAK,cAAc;;GAG3D,iBACE,OACA,cAC2B;AAE3B,WADiB,KAAK,UAAU,CAChB,UAAU,eAAe,OAAO,UAAU;;GAG5D,uBAA2D;AAEzD,WADiB,KAAK,UAAU,CAChB,UAAU,iBAAiB;;GAG7C,qBACE,UACA,aAC8B;AAG9B,WADiB,KAAK,UAAU,CAChB,UAAU,mBAAmB,UAAU,SAAS;;GAEnE;AA7CC,OAAK,SAAS;;;CAIhB,AAAQ,WAA+B;AACrC,MAAI,KAAK,cAAc,OACrB,MAAK,YAAY,KAAK,QAAQ;AAEhC,SAAO,KAAK;;;CAId,WAAkC;AAGhC,SAAO;;;;AAkCX,MAAa,QAA2C,UACtD,IAAI,cAAc,MAAM"}

package/dist/primitives/Literal.cjs

@@ -0,0 +1,91 @@
+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');
+let effect = require("effect");
+
+//#region src/primitives/Literal.ts
+var LiteralPrimitive = class LiteralPrimitive {
+	constructor(schema) {
+		require_defineProperty._defineProperty(this, "_tag", "LiteralPrimitive");
+		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, "TUpdateInput", void 0);
+		require_defineProperty._defineProperty(this, "TSetInput", void 0);
+		require_defineProperty._defineProperty(this, "_schema", void 0);
+		require_defineProperty._defineProperty(this, "_opDefinitions", { set: require_OperationDefinition.make({
+			kind: "literal.set",
+			payload: effect.Schema.Unknown,
+			target: effect.Schema.Unknown,
+			apply: (payload) => payload
+		}) });
+		require_defineProperty._defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const defaultValue = this._schema.defaultValue;
+				return {
+					get: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					},
+					set: (value) => {
+						env.addOperation(require_Operation.fromDefinition(operationPath, this._opDefinitions.set, value));
+					},
+					update: (value) => {
+						env.addOperation(require_Operation.fromDefinition(operationPath, this._opDefinitions.set, value));
+					},
+					toSnapshot: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					}
+				};
+			},
+			applyOperation: (_state, operation) => {
+				if (operation.kind !== "literal.set") throw new require_shared.ValidationError(`LiteralPrimitive cannot apply operation of kind: ${operation.kind}`);
+				const payload = operation.payload;
+				if (payload !== this._schema.literal) throw new require_shared.ValidationError(`LiteralPrimitive.set requires the exact literal value "${globalThis.String(this._schema.literal)}", got: "${globalThis.String(payload)}"`);
+				return payload;
+			},
+			getInitialState: () => {
+				return this._schema.defaultValue;
+			},
+			transformOperation: (clientOp, serverOp) => {
+				if (!require_OperationPath.pathsOverlap(clientOp.path, serverOp.path)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this literal as required */
+	required() {
+		return new LiteralPrimitive(require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this literal */
+	default(defaultValue) {
+		return new LiteralPrimitive(require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Get the literal value this primitive represents */
+	get literal() {
+		return this._schema.literal;
+	}
+};
+/** Creates a new LiteralPrimitive with the given literal value */
+const Literal = (literal) => new LiteralPrimitive({
+	required: false,
+	defaultValue: void 0,
+	literal
+});
+
+//#endregion
+exports.Literal = Literal;
+exports.LiteralPrimitive = LiteralPrimitive;

package/dist/primitives/Literal.d.cts

@@ -0,0 +1,46 @@
+import { MaybeUndefined, NeedsValue, Primitive, PrimitiveInternal } from "./shared.cjs";
+
+//#region src/primitives/Literal.d.ts
+/** Valid literal types */
+type LiteralValue = string | number | boolean | null;
+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>;
+interface LiteralProxy<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> {
+  /** Gets the current literal value */
+  get(): MaybeUndefined<T, TRequired, THasDefault>;
+  /** Sets the literal value (must match the exact literal type) */
+  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, TRequired, THasDefault>;
+}
+interface LiteralPrimitiveSchema<T extends LiteralValue> {
+  readonly required: boolean;
+  readonly defaultValue: T | undefined;
+  readonly literal: T;
+}
+declare 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";
+  readonly _State: T;
+  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;
+  private readonly _opDefinitions;
+  constructor(schema: LiteralPrimitiveSchema<T>);
+  /** Mark this literal as required */
+  required(): LiteralPrimitive<T, true, THasDefault>;
+  /** Set a default value for this literal */
+  default(defaultValue: T): LiteralPrimitive<T, TRequired, true>;
+  /** Get the literal value this primitive represents */
+  get literal(): T;
+  readonly _internal: PrimitiveInternal<T, LiteralProxy<T, TRequired, THasDefault>>;
+}
+/** Creates a new LiteralPrimitive with the given literal value */
+declare const Literal: <T extends LiteralValue>(literal: T) => LiteralPrimitive<T, false, false>;
+//#endregion
+export { Literal, LiteralPrimitive, LiteralProxy, LiteralValue };
+//# sourceMappingURL=Literal.d.cts.map

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

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

package/dist/primitives/Literal.d.mts

@@ -0,0 +1,46 @@
+import { MaybeUndefined, NeedsValue, Primitive, PrimitiveInternal } from "./shared.mjs";
+
+//#region src/primitives/Literal.d.ts
+/** Valid literal types */
+type LiteralValue = string | number | boolean | null;
+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>;
+interface LiteralProxy<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> {
+  /** Gets the current literal value */
+  get(): MaybeUndefined<T, TRequired, THasDefault>;
+  /** Sets the literal value (must match the exact literal type) */
+  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, TRequired, THasDefault>;
+}
+interface LiteralPrimitiveSchema<T extends LiteralValue> {
+  readonly required: boolean;
+  readonly defaultValue: T | undefined;
+  readonly literal: T;
+}
+declare 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";
+  readonly _State: T;
+  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;
+  private readonly _opDefinitions;
+  constructor(schema: LiteralPrimitiveSchema<T>);
+  /** Mark this literal as required */
+  required(): LiteralPrimitive<T, true, THasDefault>;
+  /** Set a default value for this literal */
+  default(defaultValue: T): LiteralPrimitive<T, TRequired, true>;
+  /** Get the literal value this primitive represents */
+  get literal(): T;
+  readonly _internal: PrimitiveInternal<T, LiteralProxy<T, TRequired, THasDefault>>;
+}
+/** Creates a new LiteralPrimitive with the given literal value */
+declare const Literal: <T extends LiteralValue>(literal: T) => LiteralPrimitive<T, false, false>;
+//#endregion
+export { Literal, LiteralPrimitive, LiteralProxy, LiteralValue };
+//# sourceMappingURL=Literal.d.mts.map

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

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

package/dist/primitives/Literal.mjs

@@ -0,0 +1,90 @@
+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 } from "./shared.mjs";
+import { make } from "../OperationDefinition.mjs";
+import { pathsOverlap } from "../OperationPath.mjs";
+import { fromDefinition } from "../Operation.mjs";
+import { Schema } from "effect";
+
+//#region src/primitives/Literal.ts
+var LiteralPrimitive = class LiteralPrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "LiteralPrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_TRequired", void 0);
+		_defineProperty(this, "_THasDefault", void 0);
+		_defineProperty(this, "TUpdateInput", void 0);
+		_defineProperty(this, "TSetInput", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make({
+			kind: "literal.set",
+			payload: Schema.Unknown,
+			target: Schema.Unknown,
+			apply: (payload) => payload
+		}) });
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const defaultValue = this._schema.defaultValue;
+				return {
+					get: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					},
+					set: (value) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, value));
+					},
+					update: (value) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, value));
+					},
+					toSnapshot: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					}
+				};
+			},
+			applyOperation: (_state, operation) => {
+				if (operation.kind !== "literal.set") throw new ValidationError(`LiteralPrimitive cannot apply operation of kind: ${operation.kind}`);
+				const payload = operation.payload;
+				if (payload !== this._schema.literal) throw new ValidationError(`LiteralPrimitive.set requires the exact literal value "${globalThis.String(this._schema.literal)}", got: "${globalThis.String(payload)}"`);
+				return payload;
+			},
+			getInitialState: () => {
+				return this._schema.defaultValue;
+			},
+			transformOperation: (clientOp, serverOp) => {
+				if (!pathsOverlap(clientOp.path, serverOp.path)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this literal as required */
+	required() {
+		return new LiteralPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this literal */
+	default(defaultValue) {
+		return new LiteralPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Get the literal value this primitive represents */
+	get literal() {
+		return this._schema.literal;
+	}
+};
+/** Creates a new LiteralPrimitive with the given literal value */
+const Literal = (literal) => new LiteralPrimitive({
+	required: false,
+	defaultValue: void 0,
+	literal
+});
+
+//#endregion
+export { Literal, LiteralPrimitive };
+//# sourceMappingURL=Literal.mjs.map

package/dist/primitives/Literal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Literal.mjs","names":["OperationDefinition.make","Operation.fromDefinition","OperationPath.pathsOverlap"],"sources":["../../src/primitives/Literal.ts"],"sourcesContent":["import { 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, Validator, NeedsValue } from \"./shared\";\nimport { ValidationError, runValidators, isCompatibleOperation } from \"./shared\";\n\n\n/** Valid literal types */\nexport type LiteralValue = string | number | boolean | null;\n\ntype InferSetInput<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<T, TRequired, THasDefault>\ntype InferUpdateInput<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<T, TRequired, THasDefault>\n\nexport interface LiteralProxy<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> {\n  /** Gets the current literal value */\n  get(): MaybeUndefined<T, TRequired, THasDefault>;\n  /** Sets the literal value (must match the exact literal type) */\n  set(value: InferSetInput<T, TRequired, THasDefault>): void;\n  /** This is the same as set. Updates the literal value, generating a literal.set operation */\n  update(value: InferUpdateInput<T, TRequired, THasDefault>): void;\n  /** Returns a readonly snapshot of the literal value for rendering */\n  toSnapshot(): MaybeUndefined<T, TRequired, THasDefault>;\n}\n\ninterface LiteralPrimitiveSchema<T extends LiteralValue> {\n  readonly required: boolean;\n  readonly defaultValue: T | undefined;\n  readonly literal: T;\n}\n\nexport 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>> {\n  readonly _tag = \"LiteralPrimitive\" as const;\n  readonly _State!: T;\n  readonly _Proxy!: LiteralProxy<T, TRequired, THasDefault>;\n  readonly _TRequired!: TRequired;\n  readonly _THasDefault!: THasDefault;\n  readonly TUpdateInput!: InferUpdateInput<T, TRequired, THasDefault>;\n  readonly TSetInput!: InferSetInput<T, TRequired, THasDefault>;\n\n  private readonly _schema: LiteralPrimitiveSchema<T>;\n\n  private readonly _opDefinitions = {\n    set: OperationDefinition.make({\n      kind: \"literal.set\" as const,\n      payload: Schema.Unknown,\n      target: Schema.Unknown,\n      apply: (payload) => payload,\n    }),\n  };\n\n  constructor(schema: LiteralPrimitiveSchema<T>) {\n    this._schema = schema;\n  }\n\n  /** Mark this literal as required */\n  required(): LiteralPrimitive<T, true, THasDefault> {\n    return new LiteralPrimitive({\n      ...this._schema,\n      required: true,\n    });\n  }\n\n  /** Set a default value for this literal */\n  default(defaultValue: T): LiteralPrimitive<T, TRequired, true> {\n    return new LiteralPrimitive({\n      ...this._schema,\n      defaultValue,\n    });\n  }\n\n  /** Get the literal value this primitive represents */\n  get literal(): T {\n    return this._schema.literal;\n  }\n\n  readonly _internal: PrimitiveInternal<T, LiteralProxy<T, TRequired, THasDefault>> = {\n    createProxy: (env: ProxyEnvironment.ProxyEnvironment, operationPath: OperationPath.OperationPath): LiteralProxy<T, TRequired, THasDefault> => {\n      const defaultValue = this._schema.defaultValue;\n      return {\n        get: (): MaybeUndefined<T, TRequired, THasDefault> => {\n          const state = env.getState(operationPath) as T | undefined;\n          return (state ?? defaultValue) as MaybeUndefined<T, TRequired, THasDefault>;\n        },\n        set: (value: InferSetInput<T, TRequired, THasDefault>) => {\n          env.addOperation(\n            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)\n          );\n        },\n        update: (value: InferUpdateInput<T, TRequired, THasDefault>) => {\n          env.addOperation(\n            Operation.fromDefinition(operationPath, this._opDefinitions.set, value)\n          );\n        },\n        toSnapshot: (): MaybeUndefined<T, TRequired, THasDefault> => {\n          const state = env.getState(operationPath) as T | undefined;\n          return (state ?? defaultValue) as MaybeUndefined<T, TRequired, THasDefault>;\n        },\n      };\n    },\n\n    applyOperation: (_state: T | undefined, operation: Operation.Operation<any, any, any>): T => {\n      if (operation.kind !== \"literal.set\") {\n        throw new ValidationError(`LiteralPrimitive cannot apply operation of kind: ${operation.kind}`);\n      }\n\n      const payload = operation.payload;\n      if (payload !== this._schema.literal) {\n        throw new ValidationError(\n          `LiteralPrimitive.set requires the exact literal value \"${globalThis.String(this._schema.literal)}\", got: \"${globalThis.String(payload)}\"`\n        );\n      }\n\n      return payload as T;\n    },\n\n    getInitialState: (): T | 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      // If paths don't overlap, no transformation needed\n      if (!OperationPath.pathsOverlap(clientOp.path, serverOp.path)) {\n        return { type: \"transformed\", operation: clientOp };\n      }\n\n      // For same path, client wins (last-write-wins)\n      return { type: \"transformed\", operation: clientOp };\n    },\n  };\n}\n\n/** Creates a new LiteralPrimitive with the given literal value */\nexport const Literal = <T extends LiteralValue>(literal: T): LiteralPrimitive<T, false, false> =>\n  new LiteralPrimitive({ required: false, defaultValue: undefined, literal });\n\n"],"mappings":";;;;;;;;;AAiCA,IAAa,mBAAb,MAAa,iBAAiS;CAoB5S,YAAY,QAAmC;wBAnBtC,QAAO;wBACP;wBACA;wBACA;wBACA;wBACA;wBACA;wBAEQ;wBAEA,kBAAiB,EAChC,KAAKA,KAAyB;GAC5B,MAAM;GACN,SAAS,OAAO;GAChB,QAAQ,OAAO;GACf,QAAQ,YAAY;GACrB,CAAC,EACH;wBA2BQ,aAA2E;GAClF,cAAc,KAAwC,kBAAwF;IAC5I,MAAM,eAAe,KAAK,QAAQ;AAClC,WAAO;KACL,WAAsD;MACpD,MAAM,QAAQ,IAAI,SAAS,cAAc;AACzC,aAAQ,6CAAS;;KAEnB,MAAM,UAAoD;AACxD,UAAI,aACFC,eAAyB,eAAe,KAAK,eAAe,KAAK,MAAM,CACxE;;KAEH,SAAS,UAAuD;AAC9D,UAAI,aACFA,eAAyB,eAAe,KAAK,eAAe,KAAK,MAAM,CACxE;;KAEH,kBAA6D;MAC3D,MAAM,QAAQ,IAAI,SAAS,cAAc;AACzC,aAAQ,6CAAS;;KAEpB;;GAGH,iBAAiB,QAAuB,cAAqD;AAC3F,QAAI,UAAU,SAAS,cACrB,OAAM,IAAI,gBAAgB,oDAAoD,UAAU,OAAO;IAGjG,MAAM,UAAU,UAAU;AAC1B,QAAI,YAAY,KAAK,QAAQ,QAC3B,OAAM,IAAI,gBACR,0DAA0D,WAAW,OAAO,KAAK,QAAQ,QAAQ,CAAC,WAAW,WAAW,OAAO,QAAQ,CAAC,GACzI;AAGH,WAAO;;GAGT,uBAAsC;AACpC,WAAO,KAAK,QAAQ;;GAGtB,qBACE,UACA,aAC8B;AAE9B,QAAI,CAACC,aAA2B,SAAS,MAAM,SAAS,KAAK,CAC3D,QAAO;KAAE,MAAM;KAAe,WAAW;KAAU;AAIrD,WAAO;KAAE,MAAM;KAAe,WAAW;KAAU;;GAEtD;AAhFC,OAAK,UAAU;;;CAIjB,WAAmD;AACjD,SAAO,IAAI,mDACN,KAAK,gBACR,UAAU,QACV;;;CAIJ,QAAQ,cAAuD;AAC7D,SAAO,IAAI,mDACN,KAAK,gBACR,gBACA;;;CAIJ,IAAI,UAAa;AACf,SAAO,KAAK,QAAQ;;;;AA+DxB,MAAa,WAAmC,YAC9C,IAAI,iBAAiB;CAAE,UAAU;CAAO,cAAc;CAAW;CAAS,CAAC"}