@voidhash/mimic 1.0.0-beta.15 → 1.0.0-beta.17

package/dist/primitives/shared.d.cts

@@ -123,6 +123,8 @@ declare class ValidationError extends Error {
 interface Validator<T> {
   readonly validate: (value: T) => boolean;
   readonly message: string;
+  readonly kind?: string;
+  readonly params?: unknown;
 }
 /**
  * Runs all validators against a value, throwing ValidationError if any fail.
@@ -131,10 +133,6 @@ declare function runValidators<T>(value: T, validators: readonly {
   validate: (value: T) => boolean;
   message: string;
 }[]): void;
-/**
- * Returns true if a primitive can represent null as a meaningful value.
- * This is used to avoid pruning explicit null values for null-capable scalar unions.
- */
 declare function primitiveAllowsNullValue(primitive: AnyPrimitive): boolean;
 /**
  * Checks if an operation is compatible with the given operation definitions.

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

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

package/dist/primitives/shared.d.mts

@@ -123,6 +123,8 @@ declare class ValidationError extends Error {
 interface Validator<T> {
   readonly validate: (value: T) => boolean;
   readonly message: string;
+  readonly kind?: string;
+  readonly params?: unknown;
 }
 /**
  * Runs all validators against a value, throwing ValidationError if any fail.
@@ -131,10 +133,6 @@ declare function runValidators<T>(value: T, validators: readonly {
   validate: (value: T) => boolean;
   message: string;
 }[]): void;
-/**
- * Returns true if a primitive can represent null as a meaningful value.
- * This is used to avoid pruning explicit null values for null-capable scalar unions.
- */
 declare function primitiveAllowsNullValue(primitive: AnyPrimitive): boolean;
 /**
  * Checks if an operation is compatible with the given operation definitions.

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

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

package/dist/primitives/shared.mjs

@@ -15,12 +15,9 @@ var ValidationError = class extends Error {
 function runValidators(value, validators) {
 	for (const validator of validators) if (!validator.validate(value)) throw new ValidationError(validator.message);
 }
-/**
-* Returns true if a primitive can represent null as a meaningful value.
-* This is used to avoid pruning explicit null values for null-capable scalar unions.
-*/
+const isLiteralPrimitive = (primitive) => primitive._tag === "LiteralPrimitive" && "literal" in primitive;
 function primitiveAllowsNullValue(primitive) {
-	if (primitive._tag === "LiteralPrimitive") return primitive.literal === null;
+	if (isLiteralPrimitive(primitive)) return primitive.literal === null;
 	if (primitive._tag === "EitherPrimitive") {
 		var _schema;
 		const variants = (_schema = primitive._schema) === null || _schema === void 0 ? void 0 : _schema.variants;

package/dist/primitives/shared.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"shared.mjs","names":["result: Record<string, unknown>","matchingVariantKey: string | undefined"],"sources":["../../src/primitives/shared.ts"],"sourcesContent":["import * as Operation from \"../Operation\";\nimport * as OperationDefinition from \"../OperationDefinition\";\nimport * as ProxyEnvironment from \"../ProxyEnvironment\";\nimport * as OperationPath from \"../OperationPath\";\nimport * as Transform from \"../Transform\";\n\n// =============================================================================\n// Primitive Interface & Type Utilities\n// =============================================================================\n\n/**\n * Base interface that all primitives must implement.\n * Provides type inference helpers and internal operations.\n * \n * @typeParam TState - The state type this primitive holds\n * @typeParam TProxy - The proxy type for interacting with this primitive\n * @typeParam TDefined - Whether the value is guaranteed to be defined (via required() or default())\n * @typeParam THasDefault - Whether this primitive has a default value\n */\nexport interface Primitive<TState, TProxy, TRequired extends boolean = false, THasDefault extends boolean = false, TSetInput = unknown, TUpdateInput = unknown> {\n    readonly _tag: string;\n    readonly _State: TState;\n    readonly _Proxy: TProxy;\n    readonly _TRequired: TRequired;\n    readonly _THasDefault: THasDefault;\n    readonly _internal: PrimitiveInternal<TState, TProxy>;\n    readonly TSetInput: TSetInput;\n    readonly TUpdateInput: TUpdateInput;\n  }\n  \n  /**\n   * Internal operations that each primitive must provide.\n   */\n  export interface PrimitiveInternal<TState, TProxy> {\n    /** Creates a proxy for generating operations */\n    readonly createProxy: (env: ProxyEnvironment.ProxyEnvironment, path: OperationPath.OperationPath) => TProxy;\n    /** Applies an operation to the current state, returning the new state */\n    readonly applyOperation: (state: TState | undefined, operation: Operation.Operation<any, any, any>) => TState;\n    /** Returns the initial/default state for this primitive */\n    readonly getInitialState: () => TState | undefined;\n    /**\n     * Converts a set input value to state format.\n     * For most primitives, this is a simple pass-through with defaults applied.\n     * For Tree primitives, this converts nested input to flat TreeState.\n     *\n     * @param input - The set input value\n     * @returns The corresponding state value\n     */\n    readonly convertSetInputToState?: (input: unknown) => TState;\n    /**\n     * Transforms a client operation against a server operation.\n     * Used for operational transformation (OT) conflict resolution.\n     *\n     * @param clientOp - The client's operation to transform\n     * @param serverOp - The server's operation that has already been applied\n     * @returns TransformResult indicating how the client operation should be handled\n     */\n    readonly transformOperation: (\n      clientOp: Operation.Operation<any, any, any>,\n      serverOp: Operation.Operation<any, any, any>\n    ) => Transform.TransformResult;\n  }\n  \n  /**\n   * Any primitive type - used for generic constraints.\n   */\n  export type AnyPrimitive = Primitive<any, any, any, any>;\n  \n  /**\n   * Infer the state type from a primitive.\n   */\n  export type InferState<T> = T extends Primitive<infer S, any, any, any> ? S : never;\n  \n  /**\n   * Infer the proxy type from a primitive.\n   */\n  export type InferProxy<T> = T extends Primitive<any, infer P, any, any> ? P : never;\n\n  /**\n   * Infer the SetInput type from a primitive.\n   * Works with both Primitive interface types and types with a TSetInput property (like TreeNodePrimitive).\n   */\n  export type InferSetInput<T> = \n    T extends Primitive<any, any, any, any, infer S, any> ? S : \n    T extends { TSetInput: infer S } ? S : \n    never;\n\n  /**\n   * Infer the UpdateInput type from a primitive.\n   * Works with both Primitive interface types and types with a TUpdateInput property (like TreeNodePrimitive).\n   */\n  export type InferUpdateInput<T> = \n    T extends Primitive<any, any, any, any, any, infer U> ? U : \n    T extends { TUpdateInput: infer U } ? U : \n    never;\n  \n  /**\n   * Helper type to conditionally add undefined based on TRequired and THasDefault.\n   * When TRequired is false and THasDefault is false, the value may be undefined.\n   * Otherwise, the value is guaranteed to be defined.\n   */\n  export type MaybeUndefined<T, TRequired extends boolean, THasDefault extends boolean> = TRequired extends false ? THasDefault extends false ? Optional<T> : T : T;\n\n  export type Optional<T> = T | undefined;\n\n  /**\n   * Helper type to conditionally add undefined based on TRequired and THasDefault.\n   * When TRequired is true and THasDefault is false, the value must be provided.\n   * Otherwise, the value may be undefined.\n   */\n  export type NeedsValue<T, TRequired extends boolean, THasDefault extends boolean> = TRequired extends true ? THasDefault extends false ? T : Optional<T> : Optional<T>;\n  \n  /**\n   * Infer the snapshot type from a primitive.\n   * The snapshot is a readonly, type-safe structure suitable for rendering.\n   */\n  export type InferSnapshot<T> = T extends Primitive<any, infer P, any, any>\n    ? P extends { toSnapshot(): infer S } ? S : never\n    : never;\n\n  /**\n   * Extract THasDefault from a primitive.\n   */\n  export type HasDefault<T> = T extends Primitive<any, any, any, infer H> ? H : false;\n\n  /**\n   * Extract TDefined from a primitive.\n   */\n  export type IsDefined<T> = T extends Primitive<any, any, infer D, any> ? D : false;\n\n  /**\n   * Infer whether a primitive is required.\n   * Alias for IsDefined for clarity.\n   */\n  export type IsRequired<T> = IsDefined<T>;\n\n\n  // =============================================================================\n  // Validation Errors\n  // =============================================================================\n  \n  export class ValidationError extends Error {\n    readonly _tag = \"ValidationError\";\n    constructor(message: string) {\n      super(message);\n      this.name = \"ValidationError\";\n    }\n  }\n  \n  // =============================================================================\n  // Validation Infrastructure\n  // =============================================================================\n  \n  /**\n   * A validator that checks a value and returns whether it's valid.\n   */\n  export interface Validator<T> {\n    readonly validate: (value: T) => boolean;\n    readonly message: string;\n  }\n  \n\n/**\n * Runs all validators against a value, throwing ValidationError if any fail.\n */\nexport function runValidators<T>(value: T, validators: readonly { validate: (value: T) => boolean; message: string }[]): void {\n  for (const validator of validators) {\n    if (!validator.validate(value)) {\n      throw new ValidationError(validator.message);\n    }\n  }\n}\n\n/**\n * Returns true if a primitive can represent null as a meaningful value.\n * This is used to avoid pruning explicit null values for null-capable scalar unions.\n */\nexport function primitiveAllowsNullValue(primitive: AnyPrimitive): boolean {\n  if (primitive._tag === \"LiteralPrimitive\") {\n    return (primitive as { literal: unknown }).literal === null;\n  }\n\n  if (primitive._tag === \"EitherPrimitive\") {\n    const variants = (primitive as { _schema?: { variants?: readonly AnyPrimitive[] } })._schema?.variants;\n    return Array.isArray(variants) && variants.some((variant) => primitiveAllowsNullValue(variant));\n  }\n\n  return false;\n}\n\n/**\n * Checks if an operation is compatible with the given operation definitions.\n * @param operation - The operation to check.\n * @param operationDefinitions - The operation definitions to check against.\n * @returns True if the operation is compatible, false otherwise.\n */\nexport function isCompatibleOperation(operation: Operation.Operation<any, any, any>, operationDefinitions: Record<string, OperationDefinition.OperationDefinition<any, any, any>>) {\n  const values = Object.values(operationDefinitions);\n  return values.some(value => value.kind === operation.kind);\n}\n\n// =============================================================================\n// Default Value Utilities\n// =============================================================================\n\n/**\n * Applies default values to a partial input, recursively handling nested structs and unions.\n * \n * Uses a two-layer approach:\n * 1. First, get the struct's initial state (which includes struct-level defaults)\n * 2. Then, layer the provided values on top\n * 3. Finally, ensure nested structs and unions are recursively processed\n * \n * @param primitive - The primitive definition containing field information\n * @param value - The partial value provided by the user\n * @returns The value with defaults applied for missing fields\n */\nexport function applyDefaults<T extends AnyPrimitive>(\n  primitive: T,\n  value: Partial<InferState<T>>\n): InferState<T> {\n  // Handle StructPrimitive\n  if (primitive._tag === \"StructPrimitive\") {\n    const structPrimitive = primitive as unknown as { \n      fields: Record<string, AnyPrimitive>;\n      _internal: { getInitialState: () => Record<string, unknown> | undefined };\n    };\n    \n    // Start with the struct's initial state (struct-level default or field defaults)\n    const structInitialState = structPrimitive._internal.getInitialState() ?? {};\n    \n    // Layer the provided values on top of initial state\n    const result: Record<string, unknown> = { ...structInitialState, ...value };\n    const inputObject =\n      typeof value === \"object\" && value !== null\n        ? (value as Record<string, unknown>)\n        : undefined;\n    \n    for (const key in structPrimitive.fields) {\n      const fieldPrimitive = structPrimitive.fields[key]!;\n      const hasExplicitKey = inputObject !== undefined && Object.prototype.hasOwnProperty.call(inputObject, key);\n      const explicitValue = hasExplicitKey ? inputObject[key] : undefined;\n      const fieldDefault = fieldPrimitive._internal.getInitialState();\n      const isRequiredWithoutDefault =\n        (fieldPrimitive as { _schema?: { required?: boolean } })._schema?.required === true &&\n        fieldDefault === undefined;\n\n      // Explicit undefined values always prune optional keys.\n      // Explicit null values prune optional keys unless null is a valid semantic value for this field.\n      // Required fields without defaults reject nullish values.\n      const shouldPruneExplicitNullish =\n        hasExplicitKey &&\n        (\n          explicitValue === undefined ||\n          (explicitValue === null && !primitiveAllowsNullValue(fieldPrimitive))\n        );\n      if (shouldPruneExplicitNullish) {\n        if (isRequiredWithoutDefault) {\n          throw new ValidationError(`Field \"${key}\" is required and cannot be null or undefined`);\n        }\n        delete result[key];\n        continue;\n      }\n      \n      if (!hasExplicitKey && result[key] === undefined) {\n        // Field still not provided after merging - try individual field default\n        if (fieldDefault !== undefined) {\n          result[key] = fieldDefault;\n        }\n      } else if (\n        hasExplicitKey &&\n        typeof explicitValue === \"object\" &&\n        explicitValue !== null\n      ) {\n        // Recursively apply defaults to nested structs and unions\n        if (fieldPrimitive._tag === \"StructPrimitive\" || fieldPrimitive._tag === \"UnionPrimitive\") {\n          result[key] = applyDefaults(fieldPrimitive, explicitValue as Partial<InferState<typeof fieldPrimitive>>);\n        }\n      }\n    }\n    \n    return result as InferState<T>;\n  }\n  \n  // Handle UnionPrimitive\n  if (primitive._tag === \"UnionPrimitive\") {\n    const unionPrimitive = primitive as unknown as {\n      _schema: {\n        discriminator: string;\n        variants: Record<string, AnyPrimitive>;\n      };\n    };\n    \n    // Validate that value is an object\n    if (typeof value !== \"object\" || value === null) {\n      return value as InferState<T>;\n    }\n    \n    const discriminator = unionPrimitive._schema.discriminator;\n    const discriminatorValue = (value as Record<string, unknown>)[discriminator];\n    \n    // Find the matching variant based on discriminator value\n    let matchingVariantKey: string | undefined;\n    for (const variantKey in unionPrimitive._schema.variants) {\n      const variant = unionPrimitive._schema.variants[variantKey]!;\n      // Variants are structs - check if the discriminator field's literal matches\n      if (variant._tag === \"StructPrimitive\") {\n        const variantStruct = variant as unknown as {\n          fields: Record<string, AnyPrimitive>;\n        };\n        const discriminatorField = variantStruct.fields[discriminator];\n        if (discriminatorField && discriminatorField._tag === \"LiteralPrimitive\") {\n          const literalPrimitive = discriminatorField as unknown as { literal: unknown };\n          if (literalPrimitive.literal === discriminatorValue) {\n            matchingVariantKey = variantKey;\n            break;\n          }\n        }\n      }\n    }\n    \n    if (!matchingVariantKey) {\n      // No matching variant found - return value as-is\n      return value as InferState<T>;\n    }\n    \n    // Apply defaults using the matching variant's struct\n    const variantPrimitive = unionPrimitive._schema.variants[matchingVariantKey]!;\n    return applyDefaults(variantPrimitive, value as Partial<InferState<typeof variantPrimitive>>) as InferState<T>;\n  }\n  \n  // For other primitives, return the value as-is\n  return value as InferState<T>;\n}\n"],"mappings":";;;;AA6IE,IAAa,kBAAb,cAAqC,MAAM;CAEzC,YAAY,SAAiB;AAC3B,QAAM,QAAQ;wBAFP,QAAO;AAGd,OAAK,OAAO;;;;;;AAoBlB,SAAgB,cAAiB,OAAU,YAAmF;AAC5H,MAAK,MAAM,aAAa,WACtB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,gBAAgB,UAAU,QAAQ;;;;;;AASlD,SAAgB,yBAAyB,WAAkC;AACzE,KAAI,UAAU,SAAS,mBACrB,QAAQ,UAAmC,YAAY;AAGzD,KAAI,UAAU,SAAS,mBAAmB;;EACxC,MAAM,sBAAY,UAAmE,2DAAS;AAC9F,SAAO,MAAM,QAAQ,SAAS,IAAI,SAAS,MAAM,YAAY,yBAAyB,QAAQ,CAAC;;AAGjG,QAAO;;;;;;;;AAST,SAAgB,sBAAsB,WAA+C,sBAA8F;AAEjL,QADe,OAAO,OAAO,qBAAqB,CACpC,MAAK,UAAS,MAAM,SAAS,UAAU,KAAK;;;;;;;;;;;;;;AAmB5D,SAAgB,cACd,WACA,OACe;AAEf,KAAI,UAAU,SAAS,mBAAmB;;EACxC,MAAM,kBAAkB;EASxB,MAAMA,oEAHqB,gBAAgB,UAAU,iBAAiB,yEAAI,EAAE,GAGR;EACpE,MAAM,cACJ,OAAO,UAAU,YAAY,UAAU,OAClC,QACD;AAEN,OAAK,MAAM,OAAO,gBAAgB,QAAQ;;GACxC,MAAM,iBAAiB,gBAAgB,OAAO;GAC9C,MAAM,iBAAiB,gBAAgB,UAAa,OAAO,UAAU,eAAe,KAAK,aAAa,IAAI;GAC1G,MAAM,gBAAgB,iBAAiB,YAAY,OAAO;GAC1D,MAAM,eAAe,eAAe,UAAU,iBAAiB;GAC/D,MAAM,wCACH,eAAwD,6DAAS,cAAa,QAC/E,iBAAiB;AAWnB,OALE,mBAEE,kBAAkB,UACjB,kBAAkB,QAAQ,CAAC,yBAAyB,eAAe,GAExC;AAC9B,QAAI,yBACF,OAAM,IAAI,gBAAgB,UAAU,IAAI,+CAA+C;AAEzF,WAAO,OAAO;AACd;;AAGF,OAAI,CAAC,kBAAkB,OAAO,SAAS,QAErC;QAAI,iBAAiB,OACnB,QAAO,OAAO;cAGhB,kBACA,OAAO,kBAAkB,YACzB,kBAAkB,MAGlB;QAAI,eAAe,SAAS,qBAAqB,eAAe,SAAS,iBACvE,QAAO,OAAO,cAAc,gBAAgB,cAA4D;;;AAK9G,SAAO;;AAIT,KAAI,UAAU,SAAS,kBAAkB;EACvC,MAAM,iBAAiB;AAQvB,MAAI,OAAO,UAAU,YAAY,UAAU,KACzC,QAAO;EAGT,MAAM,gBAAgB,eAAe,QAAQ;EAC7C,MAAM,qBAAsB,MAAkC;EAG9D,IAAIC;AACJ,OAAK,MAAM,cAAc,eAAe,QAAQ,UAAU;GACxD,MAAM,UAAU,eAAe,QAAQ,SAAS;AAEhD,OAAI,QAAQ,SAAS,mBAAmB;IAItC,MAAM,qBAHgB,QAGmB,OAAO;AAChD,QAAI,sBAAsB,mBAAmB,SAAS,oBAEpD;SADyB,mBACJ,YAAY,oBAAoB;AACnD,2BAAqB;AACrB;;;;;AAMR,MAAI,CAAC,mBAEH,QAAO;EAIT,MAAM,mBAAmB,eAAe,QAAQ,SAAS;AACzD,SAAO,cAAc,kBAAkB,MAAsD;;AAI/F,QAAO"}
+{"version":3,"file":"shared.mjs","names":["result: Record<string, unknown>","matchingVariantKey: string | undefined"],"sources":["../../src/primitives/shared.ts"],"sourcesContent":["import * as Operation from \"../Operation\";\nimport * as OperationDefinition from \"../OperationDefinition\";\nimport * as ProxyEnvironment from \"../ProxyEnvironment\";\nimport * as OperationPath from \"../OperationPath\";\nimport * as Transform from \"../Transform\";\n\n// =============================================================================\n// Primitive Interface & Type Utilities\n// =============================================================================\n\n/**\n * Base interface that all primitives must implement.\n * Provides type inference helpers and internal operations.\n * \n * @typeParam TState - The state type this primitive holds\n * @typeParam TProxy - The proxy type for interacting with this primitive\n * @typeParam TDefined - Whether the value is guaranteed to be defined (via required() or default())\n * @typeParam THasDefault - Whether this primitive has a default value\n */\nexport interface Primitive<TState, TProxy, TRequired extends boolean = false, THasDefault extends boolean = false, TSetInput = unknown, TUpdateInput = unknown> {\n    readonly _tag: string;\n    readonly _State: TState;\n    readonly _Proxy: TProxy;\n    readonly _TRequired: TRequired;\n    readonly _THasDefault: THasDefault;\n    readonly _internal: PrimitiveInternal<TState, TProxy>;\n    readonly TSetInput: TSetInput;\n    readonly TUpdateInput: TUpdateInput;\n  }\n  \n  /**\n   * Internal operations that each primitive must provide.\n   */\n  export interface PrimitiveInternal<TState, TProxy> {\n    /** Creates a proxy for generating operations */\n    readonly createProxy: (env: ProxyEnvironment.ProxyEnvironment, path: OperationPath.OperationPath) => TProxy;\n    /** Applies an operation to the current state, returning the new state */\n    readonly applyOperation: (state: TState | undefined, operation: Operation.Operation<any, any, any>) => TState;\n    /** Returns the initial/default state for this primitive */\n    readonly getInitialState: () => TState | undefined;\n    /**\n     * Converts a set input value to state format.\n     * For most primitives, this is a simple pass-through with defaults applied.\n     * For Tree primitives, this converts nested input to flat TreeState.\n     *\n     * @param input - The set input value\n     * @returns The corresponding state value\n     */\n    readonly convertSetInputToState?: (input: unknown) => TState;\n    /**\n     * Transforms a client operation against a server operation.\n     * Used for operational transformation (OT) conflict resolution.\n     *\n     * @param clientOp - The client's operation to transform\n     * @param serverOp - The server's operation that has already been applied\n     * @returns TransformResult indicating how the client operation should be handled\n     */\n    readonly transformOperation: (\n      clientOp: Operation.Operation<any, any, any>,\n      serverOp: Operation.Operation<any, any, any>\n    ) => Transform.TransformResult;\n  }\n  \n  /**\n   * Any primitive type - used for generic constraints.\n   */\n  export type AnyPrimitive = Primitive<any, any, any, any>;\n  \n  /**\n   * Infer the state type from a primitive.\n   */\n  export type InferState<T> = T extends Primitive<infer S, any, any, any> ? S : never;\n  \n  /**\n   * Infer the proxy type from a primitive.\n   */\n  export type InferProxy<T> = T extends Primitive<any, infer P, any, any> ? P : never;\n\n  /**\n   * Infer the SetInput type from a primitive.\n   * Works with both Primitive interface types and types with a TSetInput property (like TreeNodePrimitive).\n   */\n  export type InferSetInput<T> = \n    T extends Primitive<any, any, any, any, infer S, any> ? S : \n    T extends { TSetInput: infer S } ? S : \n    never;\n\n  /**\n   * Infer the UpdateInput type from a primitive.\n   * Works with both Primitive interface types and types with a TUpdateInput property (like TreeNodePrimitive).\n   */\n  export type InferUpdateInput<T> = \n    T extends Primitive<any, any, any, any, any, infer U> ? U : \n    T extends { TUpdateInput: infer U } ? U : \n    never;\n  \n  /**\n   * Helper type to conditionally add undefined based on TRequired and THasDefault.\n   * When TRequired is false and THasDefault is false, the value may be undefined.\n   * Otherwise, the value is guaranteed to be defined.\n   */\n  export type MaybeUndefined<T, TRequired extends boolean, THasDefault extends boolean> = TRequired extends false ? THasDefault extends false ? Optional<T> : T : T;\n\n  export type Optional<T> = T | undefined;\n\n  /**\n   * Helper type to conditionally add undefined based on TRequired and THasDefault.\n   * When TRequired is true and THasDefault is false, the value must be provided.\n   * Otherwise, the value may be undefined.\n   */\n  export type NeedsValue<T, TRequired extends boolean, THasDefault extends boolean> = TRequired extends true ? THasDefault extends false ? T : Optional<T> : Optional<T>;\n  \n  /**\n   * Infer the snapshot type from a primitive.\n   * The snapshot is a readonly, type-safe structure suitable for rendering.\n   */\n  export type InferSnapshot<T> = T extends Primitive<any, infer P, any, any>\n    ? P extends { toSnapshot(): infer S } ? S : never\n    : never;\n\n  /**\n   * Extract THasDefault from a primitive.\n   */\n  export type HasDefault<T> = T extends Primitive<any, any, any, infer H> ? H : false;\n\n  /**\n   * Extract TDefined from a primitive.\n   */\n  export type IsDefined<T> = T extends Primitive<any, any, infer D, any> ? D : false;\n\n  /**\n   * Infer whether a primitive is required.\n   * Alias for IsDefined for clarity.\n   */\n  export type IsRequired<T> = IsDefined<T>;\n\n\n  // =============================================================================\n  // Validation Errors\n  // =============================================================================\n  \n  export class ValidationError extends Error {\n    readonly _tag = \"ValidationError\";\n    constructor(message: string) {\n      super(message);\n      this.name = \"ValidationError\";\n    }\n  }\n  \n  // =============================================================================\n  // Validation Infrastructure\n  // =============================================================================\n  \n  /**\n   * A validator that checks a value and returns whether it's valid.\n   */\n  export interface Validator<T> {\n    readonly validate: (value: T) => boolean;\n    readonly message: string;\n    readonly kind?: string;\n    readonly params?: unknown;\n  }\n  \n\n/**\n * Runs all validators against a value, throwing ValidationError if any fail.\n */\nexport function runValidators<T>(value: T, validators: readonly { validate: (value: T) => boolean; message: string }[]): void {\n  for (const validator of validators) {\n    if (!validator.validate(value)) {\n      throw new ValidationError(validator.message);\n    }\n  }\n}\n\n/**\n * Returns true if a primitive can represent null as a meaningful value.\n * This is used to avoid pruning explicit null values for null-capable scalar unions.\n */\ntype PrimitiveWithLiteral = AnyPrimitive & {\n  readonly _tag: \"LiteralPrimitive\";\n  readonly literal: unknown;\n};\n\nconst isLiteralPrimitive = (primitive: AnyPrimitive): primitive is PrimitiveWithLiteral =>\n  primitive._tag === \"LiteralPrimitive\" && \"literal\" in primitive;\n\nexport function primitiveAllowsNullValue(primitive: AnyPrimitive): boolean {\n  if (isLiteralPrimitive(primitive)) {\n    return primitive.literal === null;\n  }\n\n  if (primitive._tag === \"EitherPrimitive\") {\n    const variants = (primitive as { _schema?: { variants?: readonly AnyPrimitive[] } })._schema?.variants;\n    return Array.isArray(variants) && variants.some((variant) => primitiveAllowsNullValue(variant));\n  }\n\n  return false;\n}\n\n/**\n * Checks if an operation is compatible with the given operation definitions.\n * @param operation - The operation to check.\n * @param operationDefinitions - The operation definitions to check against.\n * @returns True if the operation is compatible, false otherwise.\n */\nexport function isCompatibleOperation(operation: Operation.Operation<any, any, any>, operationDefinitions: Record<string, OperationDefinition.OperationDefinition<any, any, any>>) {\n  const values = Object.values(operationDefinitions);\n  return values.some(value => value.kind === operation.kind);\n}\n\n// =============================================================================\n// Default Value Utilities\n// =============================================================================\n\n/**\n * Applies default values to a partial input, recursively handling nested structs and unions.\n * \n * Uses a two-layer approach:\n * 1. First, get the struct's initial state (which includes struct-level defaults)\n * 2. Then, layer the provided values on top\n * 3. Finally, ensure nested structs and unions are recursively processed\n * \n * @param primitive - The primitive definition containing field information\n * @param value - The partial value provided by the user\n * @returns The value with defaults applied for missing fields\n */\nexport function applyDefaults<T extends AnyPrimitive>(\n  primitive: T,\n  value: Partial<InferState<T>>\n): InferState<T> {\n  // Handle StructPrimitive\n  if (primitive._tag === \"StructPrimitive\") {\n    const structPrimitive = primitive as unknown as { \n      fields: Record<string, AnyPrimitive>;\n      _internal: { getInitialState: () => Record<string, unknown> | undefined };\n    };\n    \n    // Start with the struct's initial state (struct-level default or field defaults)\n    const structInitialState = structPrimitive._internal.getInitialState() ?? {};\n    \n    // Layer the provided values on top of initial state\n    const result: Record<string, unknown> = { ...structInitialState, ...value };\n    const inputObject =\n      typeof value === \"object\" && value !== null\n        ? (value as Record<string, unknown>)\n        : undefined;\n    \n    for (const key in structPrimitive.fields) {\n      const fieldPrimitive = structPrimitive.fields[key]!;\n      const hasExplicitKey = inputObject !== undefined && Object.prototype.hasOwnProperty.call(inputObject, key);\n      const explicitValue = hasExplicitKey ? inputObject[key] : undefined;\n      const fieldDefault = fieldPrimitive._internal.getInitialState();\n      const isRequiredWithoutDefault =\n        (fieldPrimitive as { _schema?: { required?: boolean } })._schema?.required === true &&\n        fieldDefault === undefined;\n\n      // Explicit undefined values always prune optional keys.\n      // Explicit null values prune optional keys unless null is a valid semantic value for this field.\n      // Required fields without defaults reject nullish values.\n      const shouldPruneExplicitNullish =\n        hasExplicitKey &&\n        (\n          explicitValue === undefined ||\n          (explicitValue === null && !primitiveAllowsNullValue(fieldPrimitive))\n        );\n      if (shouldPruneExplicitNullish) {\n        if (isRequiredWithoutDefault) {\n          throw new ValidationError(`Field \"${key}\" is required and cannot be null or undefined`);\n        }\n        delete result[key];\n        continue;\n      }\n      \n      if (!hasExplicitKey && result[key] === undefined) {\n        // Field still not provided after merging - try individual field default\n        if (fieldDefault !== undefined) {\n          result[key] = fieldDefault;\n        }\n      } else if (\n        hasExplicitKey &&\n        typeof explicitValue === \"object\" &&\n        explicitValue !== null\n      ) {\n        // Recursively apply defaults to nested structs and unions\n        if (fieldPrimitive._tag === \"StructPrimitive\" || fieldPrimitive._tag === \"UnionPrimitive\") {\n          result[key] = applyDefaults(fieldPrimitive, explicitValue as Partial<InferState<typeof fieldPrimitive>>);\n        }\n      }\n    }\n    \n    return result as InferState<T>;\n  }\n  \n  // Handle UnionPrimitive\n  if (primitive._tag === \"UnionPrimitive\") {\n    const unionPrimitive = primitive as unknown as {\n      _schema: {\n        discriminator: string;\n        variants: Record<string, AnyPrimitive>;\n      };\n    };\n    \n    // Validate that value is an object\n    if (typeof value !== \"object\" || value === null) {\n      return value as InferState<T>;\n    }\n    \n    const discriminator = unionPrimitive._schema.discriminator;\n    const discriminatorValue = (value as Record<string, unknown>)[discriminator];\n    \n    // Find the matching variant based on discriminator value\n    let matchingVariantKey: string | undefined;\n    for (const variantKey in unionPrimitive._schema.variants) {\n      const variant = unionPrimitive._schema.variants[variantKey]!;\n      // Variants are structs - check if the discriminator field's literal matches\n      if (variant._tag === \"StructPrimitive\") {\n        const variantStruct = variant as unknown as {\n          fields: Record<string, AnyPrimitive>;\n        };\n        const discriminatorField = variantStruct.fields[discriminator];\n        if (discriminatorField && discriminatorField._tag === \"LiteralPrimitive\") {\n          const literalPrimitive = discriminatorField as unknown as { literal: unknown };\n          if (literalPrimitive.literal === discriminatorValue) {\n            matchingVariantKey = variantKey;\n            break;\n          }\n        }\n      }\n    }\n    \n    if (!matchingVariantKey) {\n      // No matching variant found - return value as-is\n      return value as InferState<T>;\n    }\n    \n    // Apply defaults using the matching variant's struct\n    const variantPrimitive = unionPrimitive._schema.variants[matchingVariantKey]!;\n    return applyDefaults(variantPrimitive, value as Partial<InferState<typeof variantPrimitive>>) as InferState<T>;\n  }\n  \n  // For other primitives, return the value as-is\n  return value as InferState<T>;\n}\n"],"mappings":";;;;AA6IE,IAAa,kBAAb,cAAqC,MAAM;CAEzC,YAAY,SAAiB;AAC3B,QAAM,QAAQ;wBAFP,QAAO;AAGd,OAAK,OAAO;;;;;;AAsBlB,SAAgB,cAAiB,OAAU,YAAmF;AAC5H,MAAK,MAAM,aAAa,WACtB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,gBAAgB,UAAU,QAAQ;;AAclD,MAAM,sBAAsB,cAC1B,UAAU,SAAS,sBAAsB,aAAa;AAExD,SAAgB,yBAAyB,WAAkC;AACzE,KAAI,mBAAmB,UAAU,CAC/B,QAAO,UAAU,YAAY;AAG/B,KAAI,UAAU,SAAS,mBAAmB;;EACxC,MAAM,sBAAY,UAAmE,2DAAS;AAC9F,SAAO,MAAM,QAAQ,SAAS,IAAI,SAAS,MAAM,YAAY,yBAAyB,QAAQ,CAAC;;AAGjG,QAAO;;;;;;;;AAST,SAAgB,sBAAsB,WAA+C,sBAA8F;AAEjL,QADe,OAAO,OAAO,qBAAqB,CACpC,MAAK,UAAS,MAAM,SAAS,UAAU,KAAK;;;;;;;;;;;;;;AAmB5D,SAAgB,cACd,WACA,OACe;AAEf,KAAI,UAAU,SAAS,mBAAmB;;EACxC,MAAM,kBAAkB;EASxB,MAAMA,oEAHqB,gBAAgB,UAAU,iBAAiB,yEAAI,EAAE,GAGR;EACpE,MAAM,cACJ,OAAO,UAAU,YAAY,UAAU,OAClC,QACD;AAEN,OAAK,MAAM,OAAO,gBAAgB,QAAQ;;GACxC,MAAM,iBAAiB,gBAAgB,OAAO;GAC9C,MAAM,iBAAiB,gBAAgB,UAAa,OAAO,UAAU,eAAe,KAAK,aAAa,IAAI;GAC1G,MAAM,gBAAgB,iBAAiB,YAAY,OAAO;GAC1D,MAAM,eAAe,eAAe,UAAU,iBAAiB;GAC/D,MAAM,wCACH,eAAwD,6DAAS,cAAa,QAC/E,iBAAiB;AAWnB,OALE,mBAEE,kBAAkB,UACjB,kBAAkB,QAAQ,CAAC,yBAAyB,eAAe,GAExC;AAC9B,QAAI,yBACF,OAAM,IAAI,gBAAgB,UAAU,IAAI,+CAA+C;AAEzF,WAAO,OAAO;AACd;;AAGF,OAAI,CAAC,kBAAkB,OAAO,SAAS,QAErC;QAAI,iBAAiB,OACnB,QAAO,OAAO;cAGhB,kBACA,OAAO,kBAAkB,YACzB,kBAAkB,MAGlB;QAAI,eAAe,SAAS,qBAAqB,eAAe,SAAS,iBACvE,QAAO,OAAO,cAAc,gBAAgB,cAA4D;;;AAK9G,SAAO;;AAIT,KAAI,UAAU,SAAS,kBAAkB;EACvC,MAAM,iBAAiB;AAQvB,MAAI,OAAO,UAAU,YAAY,UAAU,KACzC,QAAO;EAGT,MAAM,gBAAgB,eAAe,QAAQ;EAC7C,MAAM,qBAAsB,MAAkC;EAG9D,IAAIC;AACJ,OAAK,MAAM,cAAc,eAAe,QAAQ,UAAU;GACxD,MAAM,UAAU,eAAe,QAAQ,SAAS;AAEhD,OAAI,QAAQ,SAAS,mBAAmB;IAItC,MAAM,qBAHgB,QAGmB,OAAO;AAChD,QAAI,sBAAsB,mBAAmB,SAAS,oBAEpD;SADyB,mBACJ,YAAY,oBAAoB;AACnD,2BAAqB;AACrB;;;;;AAMR,MAAI,CAAC,mBAEH,QAAO;EAIT,MAAM,mBAAmB,eAAe,QAAQ,SAAS;AACzD,SAAO,cAAc,kBAAkB,MAAsD;;AAI/F,QAAO"}

package/package.json

@@ -1,45 +1,52 @@
 {
   "name": "@voidhash/mimic",
-  "version": "1.0.0-beta.15",
+  "version": "1.0.0-beta.17",
   "type": "module",
   "repository": {
     "type": "git",
     "url": "https://github.com/voidhashcom/voidhash",
     "directory": "packages/mimic"
   },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
   "main": "./src/index.ts",
   "exports": {
     ".": {
+      "types": "./src/index.ts",
       "import": "./dist/index.mjs",
-      "types": "./dist/index.d.mts",
       "require": "./dist/index.cjs"
     },
     "./server": {
+      "types": "./src/server/index.ts",
       "import": "./dist/server/index.mjs",
-      "types": "./dist/server/index.d.mts",
       "require": "./dist/server/index.cjs"
     },
     "./client": {
+      "types": "./src/client/index.ts",
       "import": "./dist/client/index.mjs",
-      "types": "./dist/client/index.d.mts",
       "require": "./dist/client/index.cjs"
     }
   },
   "devDependencies": {
-    "@effect/vitest": "^0.27.0",
+    "@effect/vitest": "4.0.0-beta.21",
     "tsdown": "^0.18.2",
     "typescript": "5.8.3",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@voidhash/tsconfig": "1.0.0-beta.15"
+    "@voidhash/tsconfig": "1.0.0-beta.17"
   },
   "peerDependencies": {
-    "effect": "^3.19.12"
+    "effect": "4.0.0-beta.21"
   },
   "scripts": {
     "build": "tsdown",
     "lint": "biome check .",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsgo --noEmit",
     "test": "vitest run -c vitest.mts"
   }
 }

package/src/Document.ts

@@ -115,12 +115,21 @@ export const make = <TSchema extends Primitive.AnyPrimitive>(
   /**
    * An ops buffer that maintains a dedup index for O(1) lookups by path:kind.
    */
-  const makeOpsBuffer = () => {
-    let ops: Operation.Operation<any, any, any>[] = [];
+  type BufferedOperation = Operation.Operation<any, any, any>;
+  interface OpsBuffer {
+    push(op: BufferedOperation): void;
+    drain(): BufferedOperation[];
+    mergeFrom(other: OpsBuffer): void;
+    toArray(): readonly BufferedOperation[];
+    reset(): void;
+  }
+
+  const makeOpsBuffer = (): OpsBuffer => {
+    let ops: BufferedOperation[] = [];
     // Maps "encodedPath:kind" → array index for deduplicable ops
     let index = new Map<string, number>();
 
-    const dedupKey = (op: Operation.Operation<any, any, any>): string =>
+    const dedupKey = (op: BufferedOperation): string =>
       `${OperationPath.encode(op.path)}:${String(op.kind)}`;
 
     return {
@@ -151,7 +160,7 @@ export const make = <TSchema extends Primitive.AnyPrimitive>(
         return result;
       },
       /** Appends all ops from another buffer (used on tx commit). */
-      mergeFrom(other: ReturnType<typeof makeOpsBuffer>): void {
+      mergeFrom(other: OpsBuffer): void {
         for (const op of other.toArray()) {
           this.push(op);
         }

package/src/EffectSchema.ts

@@ -229,7 +229,7 @@ function buildUnionSetSchema(unionPrimitive: UnionPrimitive<UnionVariants, any,
     return variantSchemas[0]!;
   }
   
-  return Schema.Union(...variantSchemas as [Schema.Schema<any>, Schema.Schema<any>, ...Schema.Schema<any>[]]);
+  return Schema.Union(variantSchemas as any);
 }
 
 /**
@@ -252,7 +252,7 @@ function buildEitherSchema(eitherPrimitive: EitherPrimitive<readonly ScalarPrimi
     return variantSchemas[0]!;
   }
   
-  return Schema.Union(...variantSchemas as [Schema.Schema<any>, Schema.Schema<any>, ...Schema.Schema<any>[]]);
+  return Schema.Union(variantSchemas as any);
 }
 
 /**
@@ -276,7 +276,7 @@ function buildUnionUpdateSchema(unionPrimitive: UnionPrimitive<UnionVariants, an
     return variantSchemas[0]!;
   }
   
-  return Schema.Union(...variantSchemas as [Schema.Schema<any>, Schema.Schema<any>, ...Schema.Schema<any>[]]);
+  return Schema.Union(variantSchemas as any);
 }
 
 /**

package/src/FractionalIndex.ts

@@ -729,7 +729,7 @@ export function decrementInteger(
 export function jitterString(
   orderKey: string,
   charSet: IndexedCharacterSet
-): Effect.Effect<string, Error, Random.Random> {
+): Effect.Effect<string, Error, typeof Random.Random> {
   return Effect.gen(function* () {
     const randomValue = yield* Random.next
     const shift = yield* encodeToCharSet(
@@ -744,7 +744,7 @@ export function padAndJitterString(
   orderKey: string,
   numberOfChars: number,
   charSet: IndexedCharacterSet
-): Effect.Effect<string, Error, Random.Random> {
+): Effect.Effect<string, Error, typeof Random.Random> {
   return Effect.gen(function* () {
     const paddedKey = orderKey.padEnd(
       orderKey.length + numberOfChars,
@@ -920,7 +920,7 @@ export function generateJitteredKeyBetween(
   lower: string | null,
   upper: string | null,
   charSet: IndexedCharacterSet = base62CharSet()
-): Effect.Effect<string, Error, Random.Random> {
+): Effect.Effect<string, Error, typeof Random.Random> {
   return Effect.gen(function* () {
     const key = yield* generateKeyBetween(lower, upper, charSet)
     const paddingNeeded = yield* paddingNeededForJitter(key, upper, charSet)
@@ -940,7 +940,7 @@ export function generateNJitteredKeysBetween(
   upper: string | null,
   n: number,
   charSet: IndexedCharacterSet = base62CharSet()
-): Effect.Effect<string[], Error, Random.Random> {
+): Effect.Effect<string[], Error, typeof Random.Random> {
   return Effect.gen(function* () {
     if (n === 0) {
       return []
@@ -1007,12 +1007,12 @@ export class IndexGenerator {
    * Generate any number of keys at the start of the list (before the first key).
    * Optionally you can supply a groupId to generate keys at the start of a specific group.
    */
-  public nKeysStart(n: number, groupId?: string): Effect.Effect<string[], Error, Random.Random> {
+  public nKeysStart(n: number, groupId?: string): Effect.Effect<string[], Error, typeof Random.Random> {
     const self = this
     return Effect.gen(function* () {
-      yield* Effect.try(() => {
+      yield* Effect.try({ try: () => {
         self.validateGroupId(groupId)
-      })
+      }, catch: (e) => e instanceof Error ? e : new Error(String(e)) })
       const firstKey = self.firstOfGroup(groupId)
       return yield* self.generateNKeysBetween(null, firstKey, n, groupId)
     })
@@ -1022,7 +1022,7 @@ export class IndexGenerator {
    * Generate a single key at the start of the list (before the first key).
    * Optionally you can supply a groupId to generate a key at the start of a specific group.
    */
-  public keyStart(groupId?: string): Effect.Effect<string, Error, Random.Random> {
+  public keyStart(groupId?: string): Effect.Effect<string, Error, typeof Random.Random> {
     const self = this
     return Effect.gen(function* () {
       const keys = yield* self.nKeysStart(1, groupId)
@@ -1034,12 +1034,12 @@ export class IndexGenerator {
    * Generate any number of keys at the end of the list (after the last key).
    * Optionally you can supply a groupId to generate keys at the end of a specific group.
    */
-  public nKeysEnd(n: number, groupId?: string): Effect.Effect<string[], Error, Random.Random> {
+  public nKeysEnd(n: number, groupId?: string): Effect.Effect<string[], Error, typeof Random.Random> {
     const self = this
     return Effect.gen(function* () {
-      yield* Effect.try(() => {
+      yield* Effect.try({ try: () => {
         self.validateGroupId(groupId)
-      })
+      }, catch: (e) => e instanceof Error ? e : new Error(String(e)) })
       const lastKey = self.lastOfGroup(groupId)
       return yield* self.generateNKeysBetween(lastKey, null, n, groupId)
     })
@@ -1049,7 +1049,7 @@ export class IndexGenerator {
    * Generate a single key at the end of the list (after the last key).
    * Optionally you can supply a groupId to generate a key at the end of a specific group.
    */
-  public keyEnd(groupId?: string): Effect.Effect<string, Error, Random.Random> {
+  public keyEnd(groupId?: string): Effect.Effect<string, Error, typeof Random.Random> {
     const self = this
     return Effect.gen(function* () {
       const keys = yield* self.nKeysEnd(1, groupId)
@@ -1061,7 +1061,7 @@ export class IndexGenerator {
    * Generate any number of keys behind a specific key and in front of the next key.
    * GroupId will be inferred from the orderKey if working with groups
    */
-  public nKeysAfter(orderKey: string, n: number): Effect.Effect<string[], Error, Random.Random> {
+  public nKeysAfter(orderKey: string, n: number): Effect.Effect<string[], Error, typeof Random.Random> {
     const self = this
     return Effect.gen(function* () {
       const keyAfter = yield* self.getKeyAfter(orderKey)
@@ -1073,7 +1073,7 @@ export class IndexGenerator {
    * Generate a single key behind a specific key and in front of the next key.
    * GroupId will be inferred from the orderKey if working with groups
    */
-  public keyAfter(orderKey: string): Effect.Effect<string, Error, Random.Random> {
+  public keyAfter(orderKey: string): Effect.Effect<string, Error, typeof Random.Random> {
     const self = this
     return Effect.gen(function* () {
       const keys = yield* self.nKeysAfter(orderKey, 1)
@@ -1085,7 +1085,7 @@ export class IndexGenerator {
    * Generate any number of keys in front of a specific key and behind the previous key.
    * GroupId will be inferred from the orderKey if working with groups
    */
-  public nKeysBefore(orderKey: string, n: number): Effect.Effect<string[], Error, Random.Random> {
+  public nKeysBefore(orderKey: string, n: number): Effect.Effect<string[], Error, typeof Random.Random> {
     const self = this
     return Effect.gen(function* () {
       const keyBefore = yield* self.getKeyBefore(orderKey)
@@ -1097,7 +1097,7 @@ export class IndexGenerator {
    * Generate a single key in front of a specific key and behind the previous key.
    * GroupId will be inferred from the orderKey if working with groups
    */
-  public keyBefore(orderKey: string): Effect.Effect<string, Error, Random.Random> {
+  public keyBefore(orderKey: string): Effect.Effect<string, Error, typeof Random.Random> {
     const self = this
     return Effect.gen(function* () {
       const keys = yield* self.nKeysBefore(orderKey, 1)
@@ -1113,7 +1113,7 @@ export class IndexGenerator {
     upperKey: string | null,
     n: number,
     groupId: string | undefined
-  ): Effect.Effect<string[], Error, Random.Random> {
+  ): Effect.Effect<string[], Error, typeof Random.Random> {
     const self = this
     const lower = self.groupLessKey(lowerKey)
     const upper = self.groupLessKey(upperKey)
@@ -1128,7 +1128,7 @@ export class IndexGenerator {
       return Effect.gen(function* () {
         const keys = yield* generateNKeysBetween(lower, upper, n, self.charSet)
         return !groupId ? keys : keys.map((key) => groupId + key)
-      }).pipe(Effect.provideService(Random as any, Random.make(Math.random())))
+      }).pipe(Random.withSeed(Math.random()))
     }
   }
 

package/src/Operation.ts

@@ -4,7 +4,7 @@ import * as OperationDefinition from "./OperationDefinition"
 import { Schema } from "effect";
 
 
-export type Operation<TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition.OperationDefinition<TKind, TPayload, any>> = {
+export type Operation<TKind, TPayload extends Schema.Top, TDef extends OperationDefinition.OperationDefinition<TKind, TPayload, any>> = {
     readonly kind: TKind
     readonly path: OperationPath.OperationPath
     readonly payload: Schema.Schema.Type<TPayload>,
@@ -12,7 +12,7 @@ export type Operation<TKind, TPayload extends Schema.Schema.Any, TDef extends Op
 
 } & TDef
 
-export const fromDefinition = <TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition.OperationDefinition<TKind, TPayload, any>>(operationPath: OperationPath.OperationPath, definition: TDef, payload: Schema.Schema.Type<TPayload>): Operation<TKind, TPayload, TDef> => {
+export const fromDefinition = <TKind, TPayload extends Schema.Top, TDef extends OperationDefinition.OperationDefinition<TKind, TPayload, any>>(operationPath: OperationPath.OperationPath, definition: TDef, payload: Schema.Schema.Type<TPayload>): Operation<TKind, TPayload, TDef> => {
     return {
         kind: definition.kind,
         path: operationPath,
@@ -35,7 +35,7 @@ export interface EncodedOperation {
  * @param operation - The operation to encode.
  * @returns The encoded representation.
  */
-export const encode = <TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition.OperationDefinition<TKind, TPayload, any>>(
+export const encode = <TKind, TPayload extends Schema.Top, TDef extends OperationDefinition.OperationDefinition<TKind, TPayload, any>>(
     operation: Operation<TKind, TPayload, TDef>
 ): EncodedOperation => {
     return {
@@ -52,10 +52,10 @@ export const encode = <TKind, TPayload extends Schema.Schema.Any, TDef extends O
  * @param encoded - The encoded representation.
  * @returns The decoded Operation (without definition-specific methods).
  */
-export const decode = (encoded: EncodedOperation): Operation<unknown, Schema.Schema.Any, any> => {
+export const decode = (encoded: EncodedOperation): Operation<unknown, Schema.Top, any> => {
     return {
         kind: encoded.kind,
         path: OperationPath.decode(encoded.path),
         payload: encoded.payload,
-    } as Operation<unknown, Schema.Schema.Any, any>
+    } as Operation<unknown, Schema.Top, any>
 }

package/src/OperationDefinition.ts

@@ -2,14 +2,14 @@ import { Schema } from "effect";
 
 type Mutable<T> = T extends ReadonlyArray<infer U> ? Array<U> : { -readonly [K in keyof T]: T[K] };
 
-export interface OperationDefinition<TKind, TPayload extends Schema.Schema.Any, TTarget extends Schema.Schema.Any> {
+export interface OperationDefinition<TKind, TPayload extends Schema.Top, TTarget extends Schema.Top> {
     readonly kind: TKind
     readonly payload: TPayload
     readonly target: TTarget
     readonly deduplicable?: boolean
 }
 
-export const make = <TKind, TPayload extends Schema.Schema.Any, TTarget extends Schema.Schema.Any>(options: {
+export const make = <TKind, TPayload extends Schema.Top, TTarget extends Schema.Top>(options: {
     readonly kind: TKind
     readonly payload: TPayload
     readonly target: TTarget

package/src/Presence.ts

@@ -99,7 +99,7 @@ export const validate = <TData,>(
   presence: Presence<TData>,
   data: unknown
 ): TData => {
-  return Schema.decodeUnknownSync(presence.schema)(data);
+  return Schema.decodeUnknownSync(presence.schema as any)(data);
 };
 
 /**
@@ -115,7 +115,7 @@ export const validateSafe = <TData,>(
   data: unknown
 ): TData | undefined => {
   try {
-    return Schema.decodeUnknownSync(presence.schema)(data);
+    return Schema.decodeUnknownSync(presence.schema as any)(data);
   } catch {
     return undefined;
   }
@@ -133,7 +133,7 @@ export const isValid = <TData,>(
   data: unknown
 ): data is TData => {
   try {
-    Schema.decodeUnknownSync(presence.schema)(data);
+    Schema.decodeUnknownSync(presence.schema as any)(data);
     return true;
   } catch {
     return false;