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

package/dist/index.d.cts

@@ -1,1071 +1,9 @@
-import { Schema } from "effect";
-import * as Schema$1 from "effect/Schema";
+import { a as InferState, c as ProxyEnvironment_d_exports, d as Transaction_d_exports, f as Operation, h as __export, i as InferSnapshot, m as OperationPath_d_exports, n as AnyPrimitive, p as Operation_d_exports, r as InferProxy, s as Transform_d_exports, t as Primitive_d_exports, u as Transaction } from "./Primitive-BK7kfHJZ.cjs";
+import { i as Presence_d_exports } from "./Presence-DKKP4v5X.cjs";
 
-//#region rolldown:runtime
-declare namespace OperationPath_d_exports {
-  export { EncodedOperationPath, OperationPath, OperationPathToken, decode$2 as decode, encode$2 as encode, fromTokens, getRelativePath, isPrefix, make$4 as make, pathsEqual, pathsOverlap };
-}
-type OperationPathToken = string;
-interface OperationPath {
-  readonly _tag: "OperationPath";
-  readonly toTokens: () => ReadonlyArray<OperationPathToken>;
-  readonly concat: (other: OperationPath) => OperationPath;
-  readonly append: (token: OperationPathToken) => OperationPath;
-  readonly pop: () => OperationPath;
-  readonly shift: () => OperationPath;
-}
-/**
- * Creates a new operation path.
- * @param stringPath - The string path to create the path from.
- * @returns The new operation path.
- */
-declare function make$4(stringPath?: string): OperationPath;
-/**
- * Creates a new operation path from tokens.
- * @param tokens - The tokens to create the path from.
- * @returns The new operation path.
- */
-declare function fromTokens(tokens: ReadonlyArray<OperationPathToken>): OperationPath;
-/**
- * Checks if two operation paths overlap (one is prefix of the other or equal).
- */
-declare const pathsOverlap: (pathA: OperationPath, pathB: OperationPath) => boolean;
-/**
- * Checks if pathA is a prefix of pathB (pathA is ancestor of pathB).
- */
-declare const isPrefix: (pathA: OperationPath, pathB: OperationPath) => boolean;
-/**
- * Checks if two paths are exactly equal.
- */
-declare const pathsEqual: (pathA: OperationPath, pathB: OperationPath) => boolean;
-/**
- * Gets the relative path of pathB with respect to pathA.
- * Assumes pathA is a prefix of pathB.
- */
-declare const getRelativePath: (basePath: OperationPath, fullPath: OperationPath) => string[];
-/**
- * Encoded representation of an OperationPath for network transport.
- */
-type EncodedOperationPath = string;
-/**
- * Encodes an OperationPath to a string for network transport.
- * @param path - The operation path to encode.
- * @returns The encoded string representation.
- */
-declare const encode$2: (path: OperationPath) => EncodedOperationPath;
-/**
- * Decodes an encoded string back to an OperationPath.
- * @param encoded - The encoded string representation.
- * @returns The decoded OperationPath.
- */
-declare const decode$2: (encoded: EncodedOperationPath) => OperationPath;
-//#endregion
-//#region src/OperationDefinition.d.ts
-interface OperationDefinition<TKind, TPayload extends Schema.Schema.Any, TTarget extends Schema.Schema.Any> {
-  readonly kind: TKind;
-  readonly payload: TPayload;
-  readonly target: TTarget;
-}
-declare namespace Operation_d_exports {
-  export { EncodedOperation, Operation, decode$1 as decode, encode$1 as encode, fromDefinition };
-}
-type Operation<TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition<TKind, TPayload, any>> = {
-  readonly kind: TKind;
-  readonly path: OperationPath;
-  readonly payload: Schema.Schema.Type<TPayload>;
-} & TDef;
-declare const fromDefinition: <TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition<TKind, TPayload, any>>(operationPath: OperationPath, definition: TDef, payload: Schema.Schema.Type<TPayload>) => Operation<TKind, TPayload, TDef>;
-/**
- * Encoded representation of an Operation for network transport.
- */
-interface EncodedOperation {
-  readonly kind: unknown;
-  readonly path: EncodedOperationPath;
-  readonly payload: unknown;
-}
-/**
- * Encodes an Operation to a JSON-serializable format for network transport.
- * @param operation - The operation to encode.
- * @returns The encoded representation.
- */
-declare const encode$1: <TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition<TKind, TPayload, any>>(operation: Operation<TKind, TPayload, TDef>) => EncodedOperation;
-/**
- * Decodes an encoded operation back to an Operation.
- * Note: This returns a partial operation without the definition methods.
- * The caller must have the operation definitions to fully reconstruct if needed.
- * @param encoded - The encoded representation.
- * @returns The decoded Operation (without definition-specific methods).
- */
-declare const decode$1: (encoded: EncodedOperation) => Operation<unknown, Schema.Schema.Any, any>;
-declare namespace ProxyEnvironment_d_exports {
-  export { ProxyEnvironment, ProxyEnvironmentOptions, make$3 as make };
-}
-type ProxyEnvironment = {
-  /** Adds an operation to be collected/applied */
-  readonly addOperation: (operation: Operation<any, any, any>) => void;
-  /** Gets the current state at the given path */
-  readonly getState: (path: OperationPath) => unknown;
-  /** Generates a unique ID (UUID) for array elements */
-  readonly generateId: () => string;
-};
-interface ProxyEnvironmentOptions {
-  /** Callback when an operation is added */
-  readonly onOperation: (operation: Operation<any, any, any>) => void;
-  /** Function to retrieve current state at a path (defaults to returning undefined) */
-  readonly getState?: (path: OperationPath) => unknown;
-  /** Optional: Custom ID generator (defaults to crypto.randomUUID) */
-  readonly generateId?: () => string;
-}
-/**
- * Creates a ProxyEnvironment.
- * @param optionsOrCallback - Either an options object or a simple callback for operations
- */
-declare const make$3: (optionsOrCallback: ProxyEnvironmentOptions | ((operation: Operation<any, any, any>) => void)) => ProxyEnvironment;
-declare namespace Transform_d_exports {
-  export { TransformResult };
-}
-/**
- * Result of transforming an operation against another operation.
- */
-type TransformResult = {
-  type: "transformed";
-  operation: Operation<any, any, any>;
-} | {
-  type: "noop";
-} | {
-  type: "conflict";
-  reason: string;
-};
-//#endregion
-//#region src/primitives/shared.d.ts
-/**
- * Base interface that all primitives must implement.
- * Provides type inference helpers and internal operations.
- *
- * @typeParam TState - The state type this primitive holds
- * @typeParam TProxy - The proxy type for interacting with this primitive
- * @typeParam TDefined - Whether the value is guaranteed to be defined (via required() or default())
- * @typeParam THasDefault - Whether this primitive has a default value
- */
-interface Primitive<TState, TProxy, TDefined extends boolean = false, THasDefault extends boolean = false> {
-  readonly _tag: string;
-  readonly _State: TState;
-  readonly _Proxy: TProxy;
-  readonly _TDefined: TDefined;
-  readonly _THasDefault: THasDefault;
-  readonly _internal: PrimitiveInternal<TState, TProxy>;
-}
-/**
- * Internal operations that each primitive must provide.
- */
-interface PrimitiveInternal<TState, TProxy> {
-  /** Creates a proxy for generating operations */
-  readonly createProxy: (env: ProxyEnvironment, path: OperationPath) => TProxy;
-  /** Applies an operation to the current state, returning the new state */
-  readonly applyOperation: (state: TState | undefined, operation: Operation<any, any, any>) => TState;
-  /** Returns the initial/default state for this primitive */
-  readonly getInitialState: () => TState | undefined;
-  /**
-   * Transforms a client operation against a server operation.
-   * Used for operational transformation (OT) conflict resolution.
-   *
-   * @param clientOp - The client's operation to transform
-   * @param serverOp - The server's operation that has already been applied
-   * @returns TransformResult indicating how the client operation should be handled
-   */
-  readonly transformOperation: (clientOp: Operation<any, any, any>, serverOp: Operation<any, any, any>) => TransformResult;
-}
-/**
- * Any primitive type - used for generic constraints.
- */
-type AnyPrimitive = Primitive<any, any, any, any>;
-/**
- * Infer the state type from a primitive.
- */
-type InferState<T> = T extends Primitive<infer S, any, any, any> ? S : never;
-/**
- * Infer the proxy type from a primitive.
- */
-type InferProxy<T> = T extends Primitive<any, infer P, any, any> ? P : never;
-/**
- * Helper type to conditionally add undefined based on TDefined.
- * When TDefined is true, the value is guaranteed to be defined (via required() or default()).
- * When TDefined is false, the value may be undefined.
- */
-type MaybeUndefined<T, TDefined extends boolean> = TDefined extends true ? T : T | undefined;
-/**
- * Infer the snapshot type from a primitive.
- * The snapshot is a readonly, type-safe structure suitable for rendering.
- */
-type InferSnapshot<T> = T extends Primitive<any, infer P, any, any> ? P extends {
-  toSnapshot(): infer S;
-} ? S : never : never;
-/**
- * Extract THasDefault from a primitive.
- */
-type HasDefault<T> = T extends Primitive<any, any, any, infer H> ? H : false;
-/**
- * Extract TDefined from a primitive.
- */
-type IsDefined<T> = T extends Primitive<any, any, infer D, any> ? D : false;
-/**
- * Determines if a field is required for set() operations.
- * A field is required if: TDefined is true AND THasDefault is false
- */
-type IsRequiredForSet<T> = T extends Primitive<any, any, true, false> ? true : false;
-/**
- * Extract keys of fields that are required for set() (required without default).
- */
-type RequiredSetKeys<TFields$1 extends Record<string, AnyPrimitive>> = { [K in keyof TFields$1]: IsRequiredForSet<TFields$1[K]> extends true ? K : never }[keyof TFields$1];
-/**
- * Extract keys of fields that are optional for set() (has default OR not required).
- */
-type OptionalSetKeys<TFields$1 extends Record<string, AnyPrimitive>> = { [K in keyof TFields$1]: IsRequiredForSet<TFields$1[K]> extends true ? never : K }[keyof TFields$1];
-/**
- * Compute the input type for set() operations on a struct.
- * Required fields (required without default) must be provided.
- * Optional fields (has default or not required) can be omitted.
- */
-type StructSetInput<TFields$1 extends Record<string, AnyPrimitive>> = { readonly [K in RequiredSetKeys<TFields$1>]: InferState<TFields$1[K]> } & { readonly [K in OptionalSetKeys<TFields$1>]?: InferState<TFields$1[K]> };
-declare class ValidationError extends Error {
-  readonly _tag = "ValidationError";
-  constructor(message: string);
-}
-/**
- * A validator that checks a value and returns whether it's valid.
- */
-interface Validator<T> {
-  readonly validate: (value: T) => boolean;
-  readonly message: string;
-}
-/**
- * Runs all validators against a value, throwing ValidationError if any fail.
- */
-declare function runValidators<T>(value: T, validators: readonly {
-  validate: (value: T) => boolean;
-  message: string;
-}[]): void;
-/**
- * Checks if an operation is compatible with the given operation definitions.
- * @param operation - The operation to check.
- * @param operationDefinitions - The operation definitions to check against.
- * @returns True if the operation is compatible, false otherwise.
- */
-declare function isCompatibleOperation(operation: Operation<any, any, any>, operationDefinitions: Record<string, OperationDefinition<any, any, any>>): boolean;
-/**
- * Applies default values to a partial input, recursively handling nested structs.
- *
- * Uses a two-layer approach:
- * 1. First, get the struct's initial state (which includes struct-level defaults)
- * 2. Then, layer the provided values on top
- * 3. Finally, ensure nested structs are recursively processed
- *
- * @param primitive - The primitive definition containing field information
- * @param value - The partial value provided by the user
- * @returns The value with defaults applied for missing fields
- */
-declare function applyDefaults<T extends AnyPrimitive>(primitive: T, value: Partial<InferState<T>>): InferState<T>;
-//#endregion
-//#region src/primitives/String.d.ts
-interface StringProxy<TDefined extends boolean = false> {
-  /** Gets the current string value */
-  get(): MaybeUndefined<string, TDefined>;
-  /** Sets the string value, generating a string.set operation */
-  set(value: string): void;
-  /** Returns a readonly snapshot of the string value for rendering */
-  toSnapshot(): MaybeUndefined<string, TDefined>;
-}
-interface StringPrimitiveSchema {
-  readonly required: boolean;
-  readonly defaultValue: string | undefined;
-  readonly validators: readonly Validator<string>[];
-}
-declare class StringPrimitive<TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<string, StringProxy<TDefined>, TDefined, THasDefault> {
-  readonly _tag: "StringPrimitive";
-  readonly _State: string;
-  readonly _Proxy: StringProxy<TDefined>;
-  readonly _TDefined: TDefined;
-  readonly _THasDefault: THasDefault;
-  private readonly _schema;
-  private readonly _opDefinitions;
-  constructor(schema: StringPrimitiveSchema);
-  /** Mark this string as required */
-  required(): StringPrimitive<true, THasDefault>;
-  /** Set a default value for this string */
-  default(defaultValue: string): StringPrimitive<true, true>;
-  /** Add a custom validation rule */
-  refine(fn: (value: string) => boolean, message: string): StringPrimitive<TDefined, THasDefault>;
-  /** Minimum string length */
-  min(length: number): StringPrimitive<TDefined, THasDefault>;
-  /** Maximum string length */
-  max(length: number): StringPrimitive<TDefined, THasDefault>;
-  /** Exact string length */
-  length(exact: number): StringPrimitive<TDefined, THasDefault>;
-  /** Match a regex pattern */
-  regex(pattern: RegExp, message?: string): StringPrimitive<TDefined, THasDefault>;
-  /** Validate as email format */
-  email(): StringPrimitive<TDefined, THasDefault>;
-  /** Validate as URL format */
-  url(): StringPrimitive<TDefined, THasDefault>;
-  readonly _internal: PrimitiveInternal<string, StringProxy<TDefined>>;
-}
-/** Creates a new StringPrimitive */
-declare const String: () => StringPrimitive<false, false>;
-//#endregion
-//#region src/primitives/Struct.d.ts
-/**
- * Maps a schema definition to its state type.
- * { name: StringPrimitive, age: NumberPrimitive } -> { name: string, age: number }
- */
-type InferStructState<TFields$1 extends Record<string, AnyPrimitive>> = { readonly [K in keyof TFields$1]: InferState<TFields$1[K]> };
-/**
- * Maps a schema definition to its snapshot type.
- * Each field's snapshot type is inferred from the field primitive.
- */
-type InferStructSnapshot<TFields$1 extends Record<string, AnyPrimitive>> = { readonly [K in keyof TFields$1]: InferSnapshot<TFields$1[K]> };
-/**
- * Maps a schema definition to a partial update type.
- * For nested structs, allows recursive partial updates.
- */
-type StructUpdateValue<TFields$1 extends Record<string, AnyPrimitive>> = { readonly [K in keyof TFields$1]?: TFields$1[K] extends StructPrimitive<infer F, any> ? StructUpdateValue<F> | InferState<TFields$1[K]> : InferState<TFields$1[K]> };
-/**
- * Maps a schema definition to its proxy type.
- * Provides nested field access + get()/set()/toSnapshot() methods for the whole struct.
- */
-type StructProxy<TFields$1 extends Record<string, AnyPrimitive>, TDefined extends boolean = false> = { readonly [K in keyof TFields$1]: InferProxy<TFields$1[K]> } & {
-  /** Gets the entire struct value */
-  get(): MaybeUndefined<InferStructState<TFields$1>, TDefined>;
-  /** Sets the entire struct value (only fields that are required without defaults must be provided) */
-  set(value: StructSetInput<TFields$1>): void;
-  /** Updates only the specified fields (partial update, handles nested structs recursively) */
-  update(value: StructUpdateValue<TFields$1>): void;
-  /** Returns a readonly snapshot of the struct for rendering */
-  toSnapshot(): MaybeUndefined<InferStructSnapshot<TFields$1>, TDefined>;
-};
-interface StructPrimitiveSchema<TFields$1 extends Record<string, AnyPrimitive>> {
-  readonly required: boolean;
-  readonly defaultValue: InferStructState<TFields$1> | undefined;
-  readonly fields: TFields$1;
-  readonly validators: readonly Validator<InferStructState<TFields$1>>[];
-}
-declare class StructPrimitive<TFields$1 extends Record<string, AnyPrimitive>, TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<InferStructState<TFields$1>, StructProxy<TFields$1, TDefined>, TDefined, THasDefault> {
-  readonly _tag: "StructPrimitive";
-  readonly _State: InferStructState<TFields$1>;
-  readonly _Proxy: StructProxy<TFields$1, TDefined>;
-  readonly _TDefined: TDefined;
-  readonly _THasDefault: THasDefault;
-  private readonly _schema;
-  private readonly _opDefinitions;
-  constructor(schema: StructPrimitiveSchema<TFields$1>);
-  /** Mark this struct as required */
-  required(): StructPrimitive<TFields$1, true, THasDefault>;
-  /** Set a default value for this struct */
-  default(defaultValue: StructSetInput<TFields$1>): StructPrimitive<TFields$1, true, true>;
-  /** Get the fields schema */
-  get fields(): TFields$1;
-  /** Add a custom validation rule (useful for cross-field validation) */
-  refine(fn: (value: InferStructState<TFields$1>) => boolean, message: string): StructPrimitive<TFields$1, TDefined, THasDefault>;
-  readonly _internal: PrimitiveInternal<InferStructState<TFields$1>, StructProxy<TFields$1, TDefined>>;
-}
-/** Creates a new StructPrimitive with the given fields */
-declare const Struct: <TFields$1 extends Record<string, AnyPrimitive>>(fields: TFields$1) => StructPrimitive<TFields$1, false, false>;
-//#endregion
-//#region src/primitives/Boolean.d.ts
-interface BooleanProxy<TDefined extends boolean = false> {
-  /** Gets the current boolean value */
-  get(): MaybeUndefined<boolean, TDefined>;
-  /** Sets the boolean value, generating a boolean.set operation */
-  set(value: boolean): void;
-  /** Returns a readonly snapshot of the boolean value for rendering */
-  toSnapshot(): MaybeUndefined<boolean, TDefined>;
-}
-interface BooleanPrimitiveSchema {
-  readonly required: boolean;
-  readonly defaultValue: boolean | undefined;
-  readonly validators: readonly Validator<boolean>[];
-}
-declare class BooleanPrimitive<TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<boolean, BooleanProxy<TDefined>, TDefined, THasDefault> {
-  readonly _tag: "BooleanPrimitive";
-  readonly _State: boolean;
-  readonly _Proxy: BooleanProxy<TDefined>;
-  readonly _TDefined: TDefined;
-  readonly _THasDefault: THasDefault;
-  private readonly _schema;
-  private readonly _opDefinitions;
-  constructor(schema: BooleanPrimitiveSchema);
-  /** Mark this boolean as required */
-  required(): BooleanPrimitive<true, THasDefault>;
-  /** Set a default value for this boolean */
-  default(defaultValue: boolean): BooleanPrimitive<true, true>;
-  /** Add a custom validation rule */
-  refine(fn: (value: boolean) => boolean, message: string): BooleanPrimitive<TDefined, THasDefault>;
-  readonly _internal: PrimitiveInternal<boolean, BooleanProxy<TDefined>>;
-}
-/** Creates a new BooleanPrimitive */
-declare const Boolean: () => BooleanPrimitive<false, false>;
-//#endregion
-//#region src/primitives/Number.d.ts
-interface NumberProxy<TDefined extends boolean = false> {
-  /** Gets the current number value */
-  get(): MaybeUndefined<number, TDefined>;
-  /** Sets the number value, generating a number.set operation */
-  set(value: number): void;
-  /** Returns a readonly snapshot of the number value for rendering */
-  toSnapshot(): MaybeUndefined<number, TDefined>;
-}
-interface NumberPrimitiveSchema {
-  readonly required: boolean;
-  readonly defaultValue: number | undefined;
-  readonly validators: readonly Validator<number>[];
-}
-declare class NumberPrimitive<TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<number, NumberProxy<TDefined>, TDefined, THasDefault> {
-  readonly _tag: "NumberPrimitive";
-  readonly _State: number;
-  readonly _Proxy: NumberProxy<TDefined>;
-  readonly _TDefined: TDefined;
-  readonly _THasDefault: THasDefault;
-  private readonly _schema;
-  private readonly _opDefinitions;
-  constructor(schema: NumberPrimitiveSchema);
-  /** Mark this number as required */
-  required(): NumberPrimitive<true, THasDefault>;
-  /** Set a default value for this number */
-  default(defaultValue: number): NumberPrimitive<true, true>;
-  /** Add a custom validation rule */
-  refine(fn: (value: number) => boolean, message: string): NumberPrimitive<TDefined, THasDefault>;
-  /** Minimum value (inclusive) */
-  min(value: number): NumberPrimitive<TDefined, THasDefault>;
-  /** Maximum value (inclusive) */
-  max(value: number): NumberPrimitive<TDefined, THasDefault>;
-  /** Must be positive (> 0) */
-  positive(): NumberPrimitive<TDefined, THasDefault>;
-  /** Must be negative (< 0) */
-  negative(): NumberPrimitive<TDefined, THasDefault>;
-  /** Must be an integer */
-  int(): NumberPrimitive<TDefined, THasDefault>;
-  readonly _internal: PrimitiveInternal<number, NumberProxy<TDefined>>;
-}
-/** Creates a new NumberPrimitive */
-declare const Number: () => NumberPrimitive<false, false>;
-//#endregion
-//#region src/primitives/Literal.d.ts
-/** Valid literal types */
-type LiteralValue = string | number | boolean | null;
-interface LiteralProxy<T extends LiteralValue, TDefined extends boolean = false> {
-  /** Gets the current literal value */
-  get(): MaybeUndefined<T, TDefined>;
-  /** Sets the literal value (must match the exact literal type) */
-  set(value: T): void;
-  /** Returns a readonly snapshot of the literal value for rendering */
-  toSnapshot(): MaybeUndefined<T, TDefined>;
-}
-interface LiteralPrimitiveSchema<T extends LiteralValue> {
-  readonly required: boolean;
-  readonly defaultValue: T | undefined;
-  readonly literal: T;
-}
-declare class LiteralPrimitive<T extends LiteralValue, TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<T, LiteralProxy<T, TDefined>, TDefined, THasDefault> {
-  readonly _tag: "LiteralPrimitive";
-  readonly _State: T;
-  readonly _Proxy: LiteralProxy<T, TDefined>;
-  readonly _TDefined: TDefined;
-  readonly _THasDefault: 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, true, true>;
-  /** Get the literal value this primitive represents */
-  get literal(): T;
-  readonly _internal: PrimitiveInternal<T, LiteralProxy<T, TDefined>>;
-}
-/** Creates a new LiteralPrimitive with the given literal value */
-declare const Literal: <T extends LiteralValue>(literal: T) => LiteralPrimitive<T, false, false>;
-//#endregion
-//#region src/primitives/Array.d.ts
-/**
- * Entry in an ordered array with ID and fractional position
- */
-interface ArrayEntry<T> {
-  readonly id: string;
-  readonly pos: string;
-  readonly value: T;
-}
-/**
- * Entry in an array snapshot with ID and value snapshot
- */
-interface ArrayEntrySnapshot<TElement extends AnyPrimitive> {
-  readonly id: string;
-  readonly value: InferSnapshot<TElement>;
-}
-/**
- * Snapshot type for arrays - always an array (never undefined)
- */
-type ArraySnapshot<TElement extends AnyPrimitive> = readonly ArrayEntrySnapshot<TElement>[];
-/**
- * Compute the input type for array element values.
- * If the element is a struct, uses StructSetInput (partial with defaults).
- * Otherwise uses the full state type.
- */
-type ArrayElementSetInput<TElement extends AnyPrimitive> = TElement extends StructPrimitive<infer TFields, any, any> ? StructSetInput<TFields> : InferState<TElement>;
-interface ArrayProxy<TElement extends AnyPrimitive> {
-  /** Gets the current array entries (sorted by position) */
-  get(): ArrayState<TElement>;
-  /** Replaces the entire array with new values (generates new IDs and positions, applies defaults) */
-  set(values: readonly ArrayElementSetInput<TElement>[]): void;
-  /** Appends a value to the end of the array (applies defaults for struct elements) */
-  push(value: ArrayElementSetInput<TElement>): void;
-  /** Inserts a value at the specified visual index (applies defaults for struct elements) */
-  insertAt(index: number, value: ArrayElementSetInput<TElement>): void;
-  /** Removes the element with the specified ID */
-  remove(id: string): void;
-  /** Moves an element to a new visual index */
-  move(id: string, toIndex: number): void;
-  /** Returns a proxy for the element with the specified ID */
-  at(id: string): InferProxy<TElement>;
-  /** Finds an element by predicate and returns its proxy */
-  find(predicate: (value: InferState<TElement>, id: string) => boolean): InferProxy<TElement> | undefined;
-  /** Returns a readonly snapshot of the array for rendering (always returns an array, never undefined) */
-  toSnapshot(): ArraySnapshot<TElement>;
-}
-/** The state type for arrays - an array of entries */
-type ArrayState<TElement extends AnyPrimitive> = readonly ArrayEntry<InferState<TElement>>[];
-interface ArrayPrimitiveSchema<TElement extends AnyPrimitive> {
-  readonly required: boolean;
-  readonly defaultValue: ArrayState<TElement> | undefined;
-  readonly element: TElement;
-  readonly validators: readonly Validator<ArrayState<TElement>>[];
-}
-declare class ArrayPrimitive<TElement extends AnyPrimitive, TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<ArrayState<TElement>, ArrayProxy<TElement>, TDefined, THasDefault> {
-  readonly _tag: "ArrayPrimitive";
-  readonly _State: ArrayState<TElement>;
-  readonly _Proxy: ArrayProxy<TElement>;
-  readonly _TDefined: TDefined;
-  readonly _THasDefault: THasDefault;
-  private readonly _schema;
-  private readonly _opDefinitions;
-  constructor(schema: ArrayPrimitiveSchema<TElement>);
-  /** Mark this array as required */
-  required(): ArrayPrimitive<TElement, true, THasDefault>;
-  /** Set a default value for this array */
-  default(defaultValue: ArrayState<TElement>): ArrayPrimitive<TElement, true, true>;
-  /** Get the element primitive */
-  get element(): TElement;
-  /** Add a custom validation rule */
-  refine(fn: (value: ArrayState<TElement>) => boolean, message: string): ArrayPrimitive<TElement, TDefined, THasDefault>;
-  /** Minimum array length */
-  minLength(length: number): ArrayPrimitive<TElement, TDefined, THasDefault>;
-  /** Maximum array length */
-  maxLength(length: number): ArrayPrimitive<TElement, TDefined, THasDefault>;
-  readonly _internal: PrimitiveInternal<ArrayState<TElement>, ArrayProxy<TElement>>;
-}
-/** Creates a new ArrayPrimitive with the given element type */
-declare const Array$1: <TElement extends AnyPrimitive>(element: TElement) => ArrayPrimitive<TElement, false, false>;
-//#endregion
-//#region src/primitives/Lazy.d.ts
-/**
- * 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>> {
-  readonly _tag: "LazyPrimitive";
-  readonly _State: InferLazyState<TThunk>;
-  readonly _Proxy: InferLazyProxy<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
-//#region src/primitives/Union.d.ts
-/**
- * Type constraint for union variants - must be struct primitives
- */
-type UnionVariants = Record<string, StructPrimitive<any, any, any>>;
-/**
- * Infer the union state type from variants
- */
-type InferUnionState<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferState<TVariants[K]> }[keyof TVariants];
-/**
- * Infer the union snapshot type from variants
- */
-type InferUnionSnapshot<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferSnapshot<TVariants[K]> }[keyof TVariants];
-/**
- * Compute the input type for union.set() operations.
- * For each variant, uses StructSetInput to make fields with defaults optional.
- */
-type UnionSetInput<TVariants extends UnionVariants> = { [K in keyof TVariants]: TVariants[K] extends StructPrimitive<infer TFields, any, any> ? StructSetInput<TFields> : InferState<TVariants[K]> }[keyof TVariants];
-/**
- * Proxy for accessing union variants
- */
-interface UnionProxy<TVariants extends UnionVariants, _TDiscriminator extends string, TDefined extends boolean = false> {
-  /** Gets the current union value */
-  get(): MaybeUndefined<InferUnionState<TVariants>, TDefined>;
-  /** Sets the entire union value (applies defaults for variant fields) */
-  set(value: UnionSetInput<TVariants>): void;
-  /** Access a specific variant's proxy (assumes the variant is active) */
-  as<K$1 extends keyof TVariants>(variant: K$1): InferProxy<TVariants[K$1]>;
-  /** Pattern match on the variant type */
-  match<R>(handlers: { [K in keyof TVariants]: (proxy: InferProxy<TVariants[K$1]>) => R }): R | undefined;
-  /** Returns a readonly snapshot of the union for rendering */
-  toSnapshot(): MaybeUndefined<InferUnionSnapshot<TVariants>, TDefined>;
-}
-interface UnionPrimitiveSchema<TVariants extends UnionVariants, TDiscriminator extends string> {
-  readonly required: boolean;
-  readonly defaultValue: InferUnionState<TVariants> | undefined;
-  readonly discriminator: TDiscriminator;
-  readonly variants: TVariants;
-}
-declare class UnionPrimitive<TVariants extends UnionVariants, TDiscriminator extends string = "type", TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TDefined>, TDefined, THasDefault> {
-  readonly _tag: "UnionPrimitive";
-  readonly _State: InferUnionState<TVariants>;
-  readonly _Proxy: UnionProxy<TVariants, TDiscriminator, TDefined>;
-  readonly _TDefined: TDefined;
-  readonly _THasDefault: THasDefault;
-  private readonly _schema;
-  private readonly _opDefinitions;
-  constructor(schema: UnionPrimitiveSchema<TVariants, TDiscriminator>);
-  /** Mark this union as required */
-  required(): UnionPrimitive<TVariants, TDiscriminator, true, THasDefault>;
-  /** Set a default value for this union */
-  default(defaultValue: UnionSetInput<TVariants>): UnionPrimitive<TVariants, TDiscriminator, true, true>;
-  /** Get the discriminator field name */
-  get discriminator(): TDiscriminator;
-  /** Get the variants */
-  get variants(): TVariants;
-  /** Find the variant key from a state value */
-  private _findVariantKey;
-  /** Apply defaults to a variant value based on the discriminator */
-  private _applyVariantDefaults;
-  readonly _internal: PrimitiveInternal<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TDefined>>;
-}
-/** Options for creating a Union primitive */
-interface UnionOptions<TVariants extends UnionVariants, TDiscriminator extends string> {
-  /** The field name used to discriminate between variants (defaults to "type") */
-  readonly discriminator?: TDiscriminator;
-  /** The variant struct primitives */
-  readonly variants: TVariants;
-}
-/** Creates a new UnionPrimitive with the given variants */
-declare function Union<TVariants extends UnionVariants>(options: UnionOptions<TVariants, "type">): UnionPrimitive<TVariants, "type", false, false>;
-declare function Union<TVariants extends UnionVariants, TDiscriminator extends string>(options: UnionOptions<TVariants, TDiscriminator>): UnionPrimitive<TVariants, TDiscriminator, false, false>;
-//#endregion
-//#region src/primitives/Either.d.ts
-/**
- * Scalar primitives that can be used as variants in Either
- */
-type ScalarPrimitive = StringPrimitive<any, any> | NumberPrimitive<any, any> | BooleanPrimitive<any, any> | LiteralPrimitive<any, any, any>;
-/**
- * Infer the union state type from a tuple of scalar primitives
- */
-type InferEitherState<TVariants extends readonly ScalarPrimitive[]> = InferState<TVariants[number]>;
-/**
- * Infer the union snapshot type from a tuple of scalar primitives
- */
-type InferEitherSnapshot<TVariants extends readonly ScalarPrimitive[]> = InferState<TVariants[number]>;
-/**
- * Match handlers for Either - optional handlers for each scalar type
- */
-interface EitherMatchHandlers<R> {
-  string?: (value: string) => R;
-  number?: (value: number) => R;
-  boolean?: (value: boolean) => R;
-  literal?: (value: LiteralValue) => R;
-}
-/**
- * Proxy for accessing Either values
- */
-interface EitherProxy<TVariants extends readonly ScalarPrimitive[], TDefined extends boolean = false> {
-  /** Gets the current value */
-  get(): MaybeUndefined<InferEitherState<TVariants>, TDefined>;
-  /** Sets the value to any of the allowed variant types */
-  set(value: InferEitherState<TVariants>): void;
-  /** Pattern match on the value type */
-  match<R>(handlers: EitherMatchHandlers<R>): R | undefined;
-  /** Returns a readonly snapshot of the value for rendering */
-  toSnapshot(): MaybeUndefined<InferEitherSnapshot<TVariants>, TDefined>;
-}
-interface EitherPrimitiveSchema<TVariants extends readonly ScalarPrimitive[]> {
-  readonly required: boolean;
-  readonly defaultValue: InferEitherState<TVariants> | undefined;
-  readonly variants: TVariants;
-}
-declare class EitherPrimitive<TVariants extends readonly ScalarPrimitive[], TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<InferEitherState<TVariants>, EitherProxy<TVariants, TDefined>, TDefined, THasDefault> {
-  readonly _tag: "EitherPrimitive";
-  readonly _State: InferEitherState<TVariants>;
-  readonly _Proxy: EitherProxy<TVariants, TDefined>;
-  readonly _TDefined: TDefined;
-  readonly _THasDefault: THasDefault;
-  private readonly _schema;
-  private readonly _opDefinitions;
-  constructor(schema: EitherPrimitiveSchema<TVariants>);
-  /** Mark this either as required */
-  required(): EitherPrimitive<TVariants, true, THasDefault>;
-  /** Set a default value for this either */
-  default(defaultValue: InferEitherState<TVariants>): EitherPrimitive<TVariants, true, true>;
-  /** Get the variants */
-  get variants(): TVariants;
-  /**
-   * Determine the type category of a value based on the variants
-   */
-  private _getValueType;
-  /**
-   * Find the matching variant for a value.
-   * For literals, matches exact value. For other types, matches by typeof.
-   */
-  private _findMatchingVariant;
-  /**
-   * Get the operation kind for a variant
-   */
-  private _getVariantOperationKind;
-  /**
-   * Validate a value against the matching variant, including running its validators.
-   * Throws ValidationError if the value doesn't match any variant or fails validation.
-   */
-  private _validateAndApplyToVariant;
-  readonly _internal: PrimitiveInternal<InferEitherState<TVariants>, EitherProxy<TVariants, TDefined>>;
-}
-/**
- * Creates a new EitherPrimitive with the given scalar variant types.
- * Validators defined on the variants are applied when validating values.
- *
- * @example
- * ```typescript
- * // String or number
- * const value = Either(String(), Number());
- *
- * // String, number, or boolean
- * const status = Either(String(), Number(), Boolean()).default("pending");
- *
- * // With literal types
- * const mode = Either(Literal("auto"), Literal("manual"), Number());
- *
- * // With validators - validates string length and number range
- * const constrained = Either(
- *   String().min(2).max(50),
- *   Number().max(255)
- * );
- * ```
- */
-declare function Either<TVariants extends readonly ScalarPrimitive[]>(...variants: TVariants): EitherPrimitive<TVariants, false, false>;
-//#endregion
-//#region src/primitives/TreeNode.d.ts
-/**
- * Branded type for TreeNodeSelf - distinguishable at compile time
- */
-declare const SelfBrand: unique symbol;
-interface TreeNodeSelfType {
-  readonly _tag: "TreeNodeSelf";
-  readonly _brand: typeof SelfBrand;
-}
-/**
- * Special placeholder for self-referential tree nodes.
- * Use this in the children array when a node type can contain itself.
- *
- * @example
- * ```typescript
- * const FolderNode = TreeNode("folder", {
- *   data: Struct({ name: String() }),
- *   children: [TreeNodeSelf], // Folder can contain other folders
- * });
- * ```
- */
-declare const TreeNodeSelf: TreeNodeSelfType;
-/**
- * Type utility to resolve Self placeholders to the actual node type
- */
-type ResolveSelf<T, TSelf extends AnyTreeNodePrimitive> = T extends TreeNodeSelfType ? TSelf : T;
-/**
- * Type utility to resolve all children in a tuple, replacing Self with the node type
- */
-type ResolveChildrenUnion<TChildren, TSelf extends AnyTreeNodePrimitive> = TChildren extends readonly (infer U)[] ? ResolveSelf<U, TSelf> : never;
-/**
- * The type for children - either a direct array or a lazy function (for self-referential nodes).
- */
-type TreeNodeChildrenInput = readonly (AnyTreeNodePrimitive | TreeNodeSelfType)[] | (() => readonly (AnyTreeNodePrimitive | TreeNodeSelfType)[]);
-/**
- * Any TreeNodePrimitive type - used for generic constraints.
- */
-type AnyTreeNodePrimitive = TreeNodePrimitive<string, StructPrimitive<any>, any>;
-/**
- * Infer the data state type from a TreeNodePrimitive
- */
-type InferTreeNodeDataState<T extends AnyTreeNodePrimitive> = T extends TreeNodePrimitive<any, infer TData, any> ? InferState<TData> : never;
-/**
- * Infer the type literal from a TreeNodePrimitive
- */
-type InferTreeNodeType<T extends AnyTreeNodePrimitive> = T extends TreeNodePrimitive<infer TType, any, any> ? TType : never;
-/**
- * Infer the allowed children from a TreeNodePrimitive
- */
-type InferTreeNodeChildren<T> = T extends TreeNodePrimitive<any, any, infer TChildren> ? TChildren : never;
-/**
- * Configuration for a TreeNode primitive
- */
-interface TreeNodeConfig<TData$1 extends StructPrimitive<any>, TChildren extends readonly (AnyTreeNodePrimitive | TreeNodeSelfType)[]> {
-  readonly data: TData$1;
-  readonly children: TChildren | (() => TChildren);
-}
-/**
- * TreeNodePrimitive - defines a node type with its data schema and allowed children
- */
-declare class TreeNodePrimitive<TType extends string, TData$1 extends StructPrimitive<any>, TChildren extends AnyTreeNodePrimitive = AnyTreeNodePrimitive> {
-  readonly _tag: "TreeNodePrimitive";
-  readonly _Type: TType;
-  readonly _Data: TData$1;
-  readonly _Children: TChildren;
-  private readonly _type;
-  private readonly _data;
-  private readonly _children;
-  private _resolvedChildren;
-  constructor(type: TType, config: TreeNodeConfig<TData$1, readonly (AnyTreeNodePrimitive | TreeNodeSelfType)[]>);
-  /** Get the node type identifier */
-  get type(): TType;
-  /** Get the data primitive */
-  get data(): TData$1;
-  /** Get resolved children (resolves lazy thunk if needed, replaces Self with this node) */
-  get children(): readonly AnyTreeNodePrimitive[];
-  /** Check if a child type is allowed */
-  isChildAllowed(childType: string): boolean;
-}
-/** Creates a new TreeNodePrimitive with the given type and config */
-declare const TreeNode: <TType extends string, TData$1 extends StructPrimitive<any>, const TChildren extends readonly (AnyTreeNodePrimitive | TreeNodeSelfType)[]>(type: TType, config: TreeNodeConfig<TData$1, TChildren>) => TreeNodePrimitive<TType, TData$1, ResolveChildrenUnion<TChildren, TreeNodePrimitive<TType, TData$1, any>>>;
-//#endregion
-//#region src/primitives/Tree.d.ts
-/**
- * A node in the tree state (flat storage format)
- */
-interface TreeNodeState {
-  readonly id: string;
-  readonly type: string;
-  readonly parentId: string | null;
-  readonly pos: string;
-  readonly data: unknown;
-}
-/**
- * Typed node state for a specific node type
- */
-interface TypedTreeNodeState<TNode extends AnyTreeNodePrimitive> {
-  readonly id: string;
-  readonly type: InferTreeNodeType<TNode>;
-  readonly parentId: string | null;
-  readonly pos: string;
-  readonly data: InferTreeNodeDataState<TNode>;
-}
-/**
- * The state type for trees - a flat array of nodes
- */
-type TreeState<_TRoot extends AnyTreeNodePrimitive> = readonly TreeNodeState[];
-/**
- * Snapshot of a single node for UI rendering (data properties spread at node level)
- */
-type TreeNodeSnapshot<TNode extends AnyTreeNodePrimitive> = {
-  readonly id: string;
-  readonly type: InferTreeNodeType<TNode>;
-  readonly children: TreeNodeSnapshot<InferTreeNodeChildren<TNode>>[];
-} & InferTreeNodeDataState<TNode>;
-/**
- * Infer the snapshot type for a tree (recursive tree structure for UI)
- */
-type InferTreeSnapshot<T extends TreePrimitive<any>> = T extends TreePrimitive<infer TRoot> ? TreeNodeSnapshot<TRoot> : never;
-/**
- * Helper type to infer the update value type from a TreeNode's data
- */
-type TreeNodeUpdateValue<TNode extends AnyTreeNodePrimitive> = TNode["data"] extends StructPrimitive<infer TFields, any, any> ? StructUpdateValue<TFields> : never;
-/**
- * Helper type to infer the input type for node data (with defaults applied).
- * Uses StructSetInput for struct data, making fields with defaults optional.
- */
-type TreeNodeDataSetInput<TNode extends AnyTreeNodePrimitive> = TNode["data"] extends StructPrimitive<infer TFields, any, any> ? StructSetInput<TFields> : InferTreeNodeDataState<TNode>;
-/**
- * Typed proxy for a specific node type - provides type-safe data access
- */
-interface TypedNodeProxy<TNode extends AnyTreeNodePrimitive> {
-  /** The node ID */
-  readonly id: string;
-  /** The node type */
-  readonly type: InferTreeNodeType<TNode>;
-  /** Access the node's data proxy */
-  readonly data: InferProxy<TNode["data"]>;
-  /** Get the raw node state */
-  get(): TypedTreeNodeState<TNode>;
-  /** Updates only the specified data fields (partial update, handles nested structs recursively) */
-  update(value: TreeNodeUpdateValue<TNode>): void;
-}
-/**
- * Node proxy with type narrowing capabilities
- */
-interface TreeNodeProxyBase<_TRoot extends AnyTreeNodePrimitive> {
-  /** The node ID */
-  readonly id: string;
-  /** The node type (string) */
-  readonly type: string;
-  /** Type guard - narrows the proxy to a specific node type */
-  is<TNode extends AnyTreeNodePrimitive>(nodeType: TNode): this is TypedNodeProxy<TNode>;
-  /** Type assertion - returns typed proxy (throws if wrong type) */
-  as<TNode extends AnyTreeNodePrimitive>(nodeType: TNode): TypedNodeProxy<TNode>;
-  /** Get the raw node state */
-  get(): TreeNodeState;
-}
-/**
- * Proxy for accessing and modifying tree nodes
- */
-interface TreeProxy<TRoot$1 extends AnyTreeNodePrimitive> {
-  /** Gets the entire tree state (flat array of nodes) */
-  get(): TreeState<TRoot$1>;
-  /** Replaces the entire tree */
-  set(nodes: TreeState<TRoot$1>): void;
-  /** Gets the root node state */
-  root(): TypedTreeNodeState<TRoot$1> | undefined;
-  /** Gets ordered children states of a parent (null for root's children) */
-  children(parentId: string | null): TreeNodeState[];
-  /** Gets a node proxy by ID with type narrowing capabilities */
-  node(id: string): TreeNodeProxyBase<TRoot$1> | undefined;
-  /** Insert a new node as the first child (applies defaults for node data) */
-  insertFirst<TNode extends AnyTreeNodePrimitive>(parentId: string | null, nodeType: TNode, data: TreeNodeDataSetInput<TNode>): string;
-  /** Insert a new node as the last child (applies defaults for node data) */
-  insertLast<TNode extends AnyTreeNodePrimitive>(parentId: string | null, nodeType: TNode, data: TreeNodeDataSetInput<TNode>): string;
-  /** Insert a new node at a specific index among siblings (applies defaults for node data) */
-  insertAt<TNode extends AnyTreeNodePrimitive>(parentId: string | null, index: number, nodeType: TNode, data: TreeNodeDataSetInput<TNode>): string;
-  /** Insert a new node after a sibling (applies defaults for node data) */
-  insertAfter<TNode extends AnyTreeNodePrimitive>(siblingId: string, nodeType: TNode, data: TreeNodeDataSetInput<TNode>): string;
-  /** Insert a new node before a sibling (applies defaults for node data) */
-  insertBefore<TNode extends AnyTreeNodePrimitive>(siblingId: string, nodeType: TNode, data: TreeNodeDataSetInput<TNode>): string;
-  /** Remove a node and all its descendants */
-  remove(id: string): void;
-  /** Move a node to a new parent at a specific index */
-  move(nodeId: string, newParentId: string | null, toIndex: number): void;
-  /** Move a node after a sibling */
-  moveAfter(nodeId: string, siblingId: string): void;
-  /** Move a node before a sibling */
-  moveBefore(nodeId: string, siblingId: string): void;
-  /** Move a node to be the first child of a parent */
-  moveToFirst(nodeId: string, newParentId: string | null): void;
-  /** Move a node to be the last child of a parent */
-  moveToLast(nodeId: string, newParentId: string | null): void;
-  /** Returns a typed proxy for a specific node's data */
-  at<TNode extends AnyTreeNodePrimitive>(id: string, nodeType: TNode): InferProxy<TNode["data"]>;
-  /** Updates only the specified data fields of a node (partial update) */
-  updateAt<TNode extends AnyTreeNodePrimitive>(id: string, nodeType: TNode, value: TreeNodeUpdateValue<TNode>): void;
-  /** Convert tree to a nested snapshot for UI rendering */
-  toSnapshot(): TreeNodeSnapshot<TRoot$1> | undefined;
-}
-interface TreePrimitiveSchema<TRoot$1 extends AnyTreeNodePrimitive> {
-  readonly required: boolean;
-  readonly defaultValue: TreeState<TRoot$1> | undefined;
-  readonly root: TRoot$1;
-  readonly validators: readonly Validator<TreeState<TRoot$1>>[];
-}
-declare class TreePrimitive<TRoot$1 extends AnyTreeNodePrimitive, TDefined extends boolean = false, THasDefault extends boolean = false> implements Primitive<TreeState<TRoot$1>, TreeProxy<TRoot$1>, TDefined, THasDefault> {
-  readonly _tag: "TreePrimitive";
-  readonly _State: TreeState<TRoot$1>;
-  readonly _Proxy: TreeProxy<TRoot$1>;
-  readonly _TDefined: TDefined;
-  readonly _THasDefault: THasDefault;
-  private readonly _schema;
-  private _nodeTypeRegistry;
-  private readonly _opDefinitions;
-  constructor(schema: TreePrimitiveSchema<TRoot$1>);
-  /** Mark this tree as required */
-  required(): TreePrimitive<TRoot$1, true, THasDefault>;
-  /** Set a default value for this tree */
-  default(defaultValue: TreeState<TRoot$1>): TreePrimitive<TRoot$1, true, true>;
-  /** Get the root node type */
-  get root(): TRoot$1;
-  /** Add a custom validation rule */
-  refine(fn: (value: TreeState<TRoot$1>) => boolean, message: string): TreePrimitive<TRoot$1, TDefined, THasDefault>;
-  /**
-   * Build a registry of all node types reachable from root
-   */
-  private _buildNodeTypeRegistry;
-  /**
-   * Get a node type primitive by its type string
-   */
-  private _getNodeTypePrimitive;
-  /**
-   * Validate that a node type can be a child of a parent node type
-   */
-  private _validateChildType;
-  readonly _internal: PrimitiveInternal<TreeState<TRoot$1>, TreeProxy<TRoot$1>>;
-}
-/** Options for creating a Tree primitive */
-interface TreeOptions<TRoot$1 extends AnyTreeNodePrimitive> {
-  /** The root node type */
-  readonly root: TRoot$1;
-}
-/** Creates a new TreePrimitive with the given root node type */
-declare const Tree: <TRoot$1 extends AnyTreeNodePrimitive>(options: TreeOptions<TRoot$1>) => TreePrimitive<TRoot$1, false, false>;
-declare namespace Primitive_d_exports {
-  export { AnyPrimitive, AnyTreeNodePrimitive, Array$1 as Array, ArrayElementSetInput, ArrayEntry, ArrayEntrySnapshot, ArrayPrimitive, ArrayProxy, ArraySnapshot, ArrayState, Boolean, BooleanPrimitive, BooleanProxy, Either, EitherMatchHandlers, EitherPrimitive, EitherProxy, HasDefault, InferEitherSnapshot, InferEitherState, InferLazyProxy, InferLazySnapshot, InferLazyState, InferProxy, InferSnapshot, InferState, InferStructSnapshot, InferStructState, InferTreeNodeChildren, InferTreeNodeDataState, InferTreeNodeType, InferTreeSnapshot, InferUnionSnapshot, InferUnionState, IsDefined, IsRequiredForSet, Lazy, LazyPrimitive, Literal, LiteralPrimitive, LiteralProxy, LiteralValue, MaybeUndefined, Number, NumberPrimitive, NumberProxy, OptionalSetKeys, Primitive, PrimitiveInternal, RequiredSetKeys, ScalarPrimitive, String, StringPrimitive, StringProxy, Struct, StructPrimitive, StructProxy, StructSetInput, StructUpdateValue, Tree, TreeNode, TreeNodeChildrenInput, TreeNodeConfig, TreeNodeDataSetInput, TreeNodePrimitive, TreeNodeProxyBase, TreeNodeSelf, TreeNodeSelfType, TreeNodeSnapshot, TreeNodeState, TreeNodeUpdateValue, TreeOptions, TreePrimitive, TreeProxy, TreeState, TypedNodeProxy, TypedTreeNodeState, Union, UnionOptions, UnionPrimitive, UnionProxy, UnionSetInput, UnionVariants, ValidationError, Validator, applyDefaults, isCompatibleOperation, runValidators };
-}
-declare namespace Transaction_d_exports {
-  export { EncodedTransaction, Transaction, decode, empty, encode, isEmpty, make$2 as make, merge };
-}
-/**
- * A Transaction represents a group of operations that were applied atomically.
- */
-interface Transaction {
-  /** Unique identifier for this transaction */
-  readonly id: string;
-  /** Operations contained in this transaction */
-  readonly ops: ReadonlyArray<Operation<any, any, any>>;
-  /** Timestamp when the transaction was created */
-  readonly timestamp: number;
-}
-/**
- * Creates a new Transaction with the given operations.
- */
-declare const make$2: (ops: ReadonlyArray<Operation<any, any, any>>) => Transaction;
-/**
- * Creates an empty Transaction.
- */
-declare const empty: () => Transaction;
-/**
- * Checks if a transaction is empty (has no operations).
- */
-declare const isEmpty: (tx: Transaction) => boolean;
-/**
- * Merges multiple transactions into one.
- */
-declare const merge: (txs: ReadonlyArray<Transaction>) => Transaction;
-/**
- * Encoded representation of a Transaction for network transport.
- */
-interface EncodedTransaction {
-  readonly id: string;
-  readonly ops: ReadonlyArray<EncodedOperation>;
-  readonly timestamp: number;
-}
-/**
- * Encodes a Transaction to a JSON-serializable format for network transport.
- * @param transaction - The transaction to encode.
- * @returns The encoded representation.
- */
-declare const encode: (transaction: Transaction) => EncodedTransaction;
-/**
- * Decodes an encoded transaction back to a Transaction.
- * @param encoded - The encoded representation.
- * @returns The decoded Transaction.
- */
-declare const decode: (encoded: EncodedTransaction) => Transaction;
+//#region src/Document.d.ts
 declare namespace Document_d_exports {
-  export { Document, DocumentOptions, NestedTransactionError, OperationError, make$1 as make };
+  export { Document, DocumentOptions, NestedTransactionError, OperationError, make };
 }
 /**
  * Error thrown when attempting to start a nested transaction.
@@ -1122,92 +60,7 @@ interface DocumentOptions<TSchema extends AnyPrimitive> {
 /**
  * Creates a new Document for the given schema.
  */
-declare const make$1: <TSchema extends AnyPrimitive>(schema: TSchema, options?: DocumentOptions<TSchema>) => Document<TSchema>;
-declare namespace Presence_d_exports {
-  export { AnyPresence, Infer, Presence, PresenceEntry, PresenceOptions, isValid, make, validate, validateSafe };
-}
-/**
- * A Presence schema wrapper that holds an Effect Schema for validation.
- * This is used by both client and server to validate presence data.
- */
-interface Presence<TData$1> {
-  readonly _tag: "Presence";
-  /** The Effect Schema used for validation */
-  readonly schema: Schema$1.Schema<TData$1>;
-  /** Branded type marker for inference */
-  readonly _Data: TData$1;
-}
-/**
- * Options for creating a Presence instance.
- */
-interface PresenceOptions<TData$1> {
-  /** The Effect Schema defining the presence data structure */
-  readonly schema: Schema$1.Schema<TData$1>;
-}
-/**
- * Infer the data type from a Presence instance.
- */
-type Infer<P extends Presence<any>> = P["_Data"];
-/**
- * Any Presence type (for generic constraints).
- */
-type AnyPresence = Presence<any>;
-/**
- * A presence entry as stored/transmitted.
- */
-interface PresenceEntry<TData$1 = unknown> {
-  /** The presence data */
-  readonly data: TData$1;
-  /** Optional user ID from authentication */
-  readonly userId?: string;
-}
-/**
- * Creates a new Presence schema wrapper.
- *
- * @example
- * ```typescript
- * import { Presence } from "@voidhash/mimic";
- * import { Schema } from "effect";
- *
- * const CursorPresence = Presence.make({
- *   schema: Schema.Struct({
- *     name: Schema.String,
- *     cursor: Schema.Struct({
- *       x: Schema.Number,
- *       y: Schema.Number,
- *     }),
- *   }),
- * });
- * ```
- */
-declare const make: <TData$1>(options: PresenceOptions<TData$1>) => Presence<TData$1>;
-/**
- * Validates unknown data against a Presence schema.
- * Throws a ParseError if validation fails.
- *
- * @param presence - The Presence instance with the schema
- * @param data - Unknown data to validate
- * @returns The validated and typed data
- * @throws ParseError if validation fails
- */
-declare const validate: <TData$1>(presence: Presence<TData$1>, data: unknown) => TData$1;
-/**
- * Safely validates unknown data against a Presence schema.
- * Returns undefined if validation fails instead of throwing.
- *
- * @param presence - The Presence instance with the schema
- * @param data - Unknown data to validate
- * @returns The validated data or undefined if invalid
- */
-declare const validateSafe: <TData$1>(presence: Presence<TData$1>, data: unknown) => TData$1 | undefined;
-/**
- * Checks if unknown data is valid according to a Presence schema.
- *
- * @param presence - The Presence instance with the schema
- * @param data - Unknown data to check
- * @returns true if valid, false otherwise
- */
-declare const isValid: <TData$1>(presence: Presence<TData$1>, data: unknown) => data is TData$1;
+declare const make: <TSchema extends AnyPrimitive>(schema: TSchema, options?: DocumentOptions<TSchema>) => Document<TSchema>;
 //#endregion
 export { Document_d_exports as Document, Operation_d_exports as Operation, OperationPath_d_exports as OperationPath, Presence_d_exports as Presence, Primitive_d_exports as Primitive, ProxyEnvironment_d_exports as ProxyEnvironment, Transaction_d_exports as Transaction, Transform_d_exports as Transform };
 //# sourceMappingURL=index.d.cts.map