@voidhash/mimic 0.0.2 → 0.0.3

package/dist/Primitive-DqQFc3Gu.d.mts

@@ -1,1180 +0,0 @@
-import { Schema } from "effect";
-
-//#region src/OperationPath.d.ts
-declare namespace OperationPath_d_exports {
-  export { EncodedOperationPath, OperationPath, OperationPathToken, decode$2 as decode, encode$2 as encode, fromTokens, getRelativePath, isPrefix, make$2 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$2(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 Transaction_d_exports {
-  export { EncodedTransaction, Transaction, decode, empty, encode, isEmpty, make$1 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$1: (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;
-declare namespace ProxyEnvironment_d_exports {
-  export { ProxyEnvironment, ProxyEnvironmentOptions, 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: (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, TRequired extends boolean = false, THasDefault extends boolean = false, TSetInput = unknown, TUpdateInput = unknown> {
-  readonly _tag: string;
-  readonly _State: TState;
-  readonly _Proxy: TProxy;
-  readonly _TRequired: TRequired;
-  readonly _THasDefault: THasDefault;
-  readonly _internal: PrimitiveInternal<TState, TProxy>;
-  readonly TSetInput: TSetInput;
-  readonly TUpdateInput: TUpdateInput;
-}
-/**
- * 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;
-/**
- * Infer the SetInput type from a primitive.
- * Works with both Primitive interface types and types with a TSetInput property (like TreeNodePrimitive).
- */
-type InferSetInput$5<T> = T extends Primitive<any, any, any, any, infer S, any> ? S : T extends {
-  TSetInput: infer S;
-} ? S : never;
-/**
- * Infer the UpdateInput type from a primitive.
- * Works with both Primitive interface types and types with a TUpdateInput property (like TreeNodePrimitive).
- */
-type InferUpdateInput$5<T> = T extends Primitive<any, any, any, any, any, infer U> ? U : T extends {
-  TUpdateInput: infer U;
-} ? U : never;
-/**
- * Helper type to conditionally add undefined based on TRequired and THasDefault.
- * When TRequired is false and THasDefault is false, the value may be undefined.
- * Otherwise, the value is guaranteed to be defined.
- */
-type MaybeUndefined<T, TRequired extends boolean, THasDefault extends boolean> = TRequired extends false ? THasDefault extends false ? Optional<T> : T : T;
-type Optional<T> = T | undefined;
-/**
- * Helper type to conditionally add undefined based on TRequired and THasDefault.
- * When TRequired is true and THasDefault is false, the value must be provided.
- * Otherwise, the value may be undefined.
- */
-type NeedsValue<T, TRequired extends boolean, THasDefault extends boolean> = TRequired extends true ? THasDefault extends false ? T : Optional<T> : Optional<T>;
-/**
- * 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;
-/**
- * Infer whether a primitive is required.
- * Alias for IsDefined for clarity.
- */
-type IsRequired<T> = IsDefined<T>;
-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
-type InferSetInput$4<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<string, TRequired, THasDefault>;
-type InferUpdateInput$4<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<string, TRequired, THasDefault>;
-interface StringProxy<TRequired extends boolean = false, THasDefault extends boolean = false> {
-  /** Gets the current string value */
-  get(): MaybeUndefined<string, TRequired, THasDefault>;
-  /** Sets the string value, generating a string.set operation */
-  set(value: InferSetInput$4<TRequired, THasDefault>): void;
-  /** This is the same as set. Updates the string value, generating a string.set operation */
-  update(value: InferUpdateInput$4<TRequired, THasDefault>): void;
-  /** Returns a readonly snapshot of the string value for rendering */
-  toSnapshot(): MaybeUndefined<string, TRequired, THasDefault>;
-}
-interface StringPrimitiveSchema {
-  readonly required: boolean;
-  readonly defaultValue: string | undefined;
-  readonly validators: readonly Validator<string>[];
-}
-declare class StringPrimitive<TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<string, StringProxy<TRequired, THasDefault>, TRequired, THasDefault, InferSetInput$4<TRequired, THasDefault>, InferUpdateInput$4<TRequired, THasDefault>> {
-  readonly _tag: "StringPrimitive";
-  readonly _State: string;
-  readonly _Proxy: StringProxy<TRequired, THasDefault>;
-  readonly _TRequired: TRequired;
-  readonly _THasDefault: THasDefault;
-  readonly TUpdateInput: InferUpdateInput$4<TRequired, THasDefault>;
-  readonly TSetInput: InferSetInput$4<TRequired, 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<TRequired, true>;
-  /** Add a custom validation rule */
-  refine(fn: (value: string) => boolean, message: string): StringPrimitive<TRequired, THasDefault>;
-  /** Minimum string length */
-  min(length: number): StringPrimitive<TRequired, THasDefault>;
-  /** Maximum string length */
-  max(length: number): StringPrimitive<TRequired, THasDefault>;
-  /** Exact string length */
-  length(exact: number): StringPrimitive<TRequired, THasDefault>;
-  /** Match a regex pattern */
-  regex(pattern: RegExp, message?: string): StringPrimitive<TRequired, THasDefault>;
-  /** Validate as email format */
-  email(): StringPrimitive<TRequired, THasDefault>;
-  /** Validate as URL format */
-  url(): StringPrimitive<TRequired, THasDefault>;
-  readonly _internal: PrimitiveInternal<string, StringProxy<TRequired, THasDefault>>;
-}
-/** Creates a new StringPrimitive */
-declare const String: () => StringPrimitive<false, false>;
-//#endregion
-//#region src/primitives/Struct.d.ts
-/**
- * Determines if a field is required for set() operations.
- * A field is required if: TRequired 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.
- * Uses each field's TSetInput type to handle nested structs correctly.
- */
-type StructSetInput<TFields$1 extends Record<string, AnyPrimitive>> = { readonly [K in RequiredSetKeys<TFields$1>]: InferSetInput$5<TFields$1[K]> } & { readonly [K in OptionalSetKeys<TFields$1>]?: InferSetInput$5<TFields$1[K]> };
-/**
- * Input type for set() - respects required/default status of the struct.
- * If the struct is required without a default, the value must be provided.
- * The value itself uses StructSetInput which handles field-level required/default logic.
- */
-type InferStructSetInput<TFields$1 extends Record<string, AnyPrimitive>, TRequired extends boolean, THasDefault extends boolean> = NeedsValue<StructSetInput<TFields$1>, TRequired, THasDefault>;
-/**
- * Input type for update() - always partial since update only modifies specified fields.
- * For nested structs, allows recursive partial updates.
- */
-type InferStructUpdateInput<TFields$1 extends Record<string, AnyPrimitive>> = StructUpdateValue<TFields$1>;
-/**
- * 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.
- * Uses each field's TUpdateInput type, which handles nested updates recursively.
- */
-type StructUpdateValue<TFields$1 extends Record<string, AnyPrimitive>> = { readonly [K in keyof TFields$1]?: InferUpdateInput$5<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>, TRequired extends boolean = false, THasDefault extends boolean = false> = { readonly [K in keyof TFields$1]: InferProxy<TFields$1[K]> } & {
-  /** Gets the entire struct value */
-  get(): MaybeUndefined<InferStructState<TFields$1>, TRequired, THasDefault>;
-  /** Sets the entire struct value (only fields that are required without defaults must be provided) */
-  set(value: InferStructSetInput<TFields$1, TRequired, THasDefault>): void;
-  /** Updates only the specified fields (partial update, handles nested structs recursively) */
-  update(value: InferStructUpdateInput<TFields$1>): void;
-  /** Returns a readonly snapshot of the struct for rendering */
-  toSnapshot(): MaybeUndefined<InferStructSnapshot<TFields$1>, TRequired, THasDefault>;
-};
-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>, TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<InferStructState<TFields$1>, StructProxy<TFields$1, TRequired, THasDefault>, TRequired, THasDefault, InferStructSetInput<TFields$1, TRequired, THasDefault>, InferStructUpdateInput<TFields$1>> {
-  readonly _tag: "StructPrimitive";
-  readonly _State: InferStructState<TFields$1>;
-  readonly _Proxy: StructProxy<TFields$1, TRequired, THasDefault>;
-  readonly _TRequired: TRequired;
-  readonly _THasDefault: THasDefault;
-  readonly TSetInput: InferStructSetInput<TFields$1, TRequired, THasDefault>;
-  readonly TUpdateInput: InferStructUpdateInput<TFields$1>;
-  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, TRequired, 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, TRequired, THasDefault>;
-  readonly _internal: PrimitiveInternal<InferStructState<TFields$1>, StructProxy<TFields$1, TRequired, THasDefault>>;
-}
-/** 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
-type InferSetInput$3<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<boolean, TRequired, THasDefault>;
-type InferUpdateInput$3<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<boolean, TRequired, THasDefault>;
-interface BooleanProxy<TRequired extends boolean = false, THasDefault extends boolean = false> {
-  /** Gets the current boolean value */
-  get(): MaybeUndefined<boolean, TRequired, THasDefault>;
-  /** Sets the boolean value, generating a boolean.set operation */
-  set(value: InferSetInput$3<TRequired, THasDefault>): void;
-  /** This is the same as set. Updates the boolean value, generating a boolean.set operation */
-  update(value: InferUpdateInput$3<TRequired, THasDefault>): void;
-  /** Returns a readonly snapshot of the boolean value for rendering */
-  toSnapshot(): MaybeUndefined<boolean, TRequired, THasDefault>;
-}
-interface BooleanPrimitiveSchema {
-  readonly required: boolean;
-  readonly defaultValue: boolean | undefined;
-  readonly validators: readonly Validator<boolean>[];
-}
-declare class BooleanPrimitive<TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<boolean, BooleanProxy<TRequired, THasDefault>, TRequired, THasDefault, InferSetInput$3<TRequired, THasDefault>, InferUpdateInput$3<TRequired, THasDefault>> {
-  readonly _tag: "BooleanPrimitive";
-  readonly _State: boolean;
-  readonly _Proxy: BooleanProxy<TRequired, THasDefault>;
-  readonly _TRequired: TRequired;
-  readonly _THasDefault: THasDefault;
-  readonly TUpdateInput: InferUpdateInput$3<TRequired, THasDefault>;
-  readonly TSetInput: InferSetInput$3<TRequired, 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<TRequired, true>;
-  /** Add a custom validation rule */
-  refine(fn: (value: boolean) => boolean, message: string): BooleanPrimitive<TRequired, THasDefault>;
-  readonly _internal: PrimitiveInternal<boolean, BooleanProxy<TRequired, THasDefault>>;
-}
-/** Creates a new BooleanPrimitive */
-declare const Boolean: () => BooleanPrimitive<false, false>;
-//#endregion
-//#region src/primitives/Number.d.ts
-type InferSetInput$2<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<number, TRequired, THasDefault>;
-type InferUpdateInput$2<TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<number, TRequired, THasDefault>;
-interface NumberProxy<TRequired extends boolean = false, THasDefault extends boolean = false> {
-  /** Gets the current number value */
-  get(): MaybeUndefined<number, TRequired, THasDefault>;
-  /** Sets the number value, generating a number.set operation */
-  set(value: InferSetInput$2<TRequired, THasDefault>): void;
-  /** This is the same as set. Updates the number value, generating a number.set operation */
-  update(value: InferUpdateInput$2<TRequired, THasDefault>): void;
-  /** Returns a readonly snapshot of the number value for rendering */
-  toSnapshot(): MaybeUndefined<number, TRequired, THasDefault>;
-}
-interface NumberPrimitiveSchema {
-  readonly required: boolean;
-  readonly defaultValue: number | undefined;
-  readonly validators: readonly Validator<number>[];
-}
-declare class NumberPrimitive<TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<number, NumberProxy<TRequired, THasDefault>, TRequired, THasDefault, InferSetInput$2<TRequired, THasDefault>, InferUpdateInput$2<TRequired, THasDefault>> {
-  readonly _tag: "NumberPrimitive";
-  readonly _State: number;
-  readonly _Proxy: NumberProxy<TRequired, THasDefault>;
-  readonly _TRequired: TRequired;
-  readonly _THasDefault: THasDefault;
-  readonly TUpdateInput: InferUpdateInput$2<TRequired, THasDefault>;
-  readonly TSetInput: InferSetInput$2<TRequired, 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<TRequired, true>;
-  /** Add a custom validation rule */
-  refine(fn: (value: number) => boolean, message: string): NumberPrimitive<TRequired, THasDefault>;
-  /** Minimum value (inclusive) */
-  min(value: number): NumberPrimitive<TRequired, THasDefault>;
-  /** Maximum value (inclusive) */
-  max(value: number): NumberPrimitive<TRequired, THasDefault>;
-  /** Must be positive (> 0) */
-  positive(): NumberPrimitive<TRequired, THasDefault>;
-  /** Must be negative (< 0) */
-  negative(): NumberPrimitive<TRequired, THasDefault>;
-  /** Must be an integer */
-  int(): NumberPrimitive<TRequired, THasDefault>;
-  readonly _internal: PrimitiveInternal<number, NumberProxy<TRequired, THasDefault>>;
-}
-/** 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;
-type InferSetInput$1<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<T, TRequired, THasDefault>;
-type InferUpdateInput$1<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<T, TRequired, THasDefault>;
-interface LiteralProxy<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> {
-  /** Gets the current literal value */
-  get(): MaybeUndefined<T, TRequired, THasDefault>;
-  /** Sets the literal value (must match the exact literal type) */
-  set(value: InferSetInput$1<T, TRequired, THasDefault>): void;
-  /** This is the same as set. Updates the literal value, generating a literal.set operation */
-  update(value: InferUpdateInput$1<T, TRequired, THasDefault>): void;
-  /** Returns a readonly snapshot of the literal value for rendering */
-  toSnapshot(): MaybeUndefined<T, TRequired, THasDefault>;
-}
-interface LiteralPrimitiveSchema<T extends LiteralValue> {
-  readonly required: boolean;
-  readonly defaultValue: T | undefined;
-  readonly literal: T;
-}
-declare class LiteralPrimitive<T extends LiteralValue, TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<T, LiteralProxy<T, TRequired, THasDefault>, TRequired, THasDefault, InferSetInput$1<T, TRequired, THasDefault>, InferUpdateInput$1<T, TRequired, THasDefault>> {
-  readonly _tag: "LiteralPrimitive";
-  readonly _State: T;
-  readonly _Proxy: LiteralProxy<T, TRequired, THasDefault>;
-  readonly _TRequired: TRequired;
-  readonly _THasDefault: THasDefault;
-  readonly TUpdateInput: InferUpdateInput$1<T, TRequired, THasDefault>;
-  readonly TSetInput: InferSetInput$1<T, TRequired, THasDefault>;
-  private readonly _schema;
-  private readonly _opDefinitions;
-  constructor(schema: LiteralPrimitiveSchema<T>);
-  /** Mark this literal as required */
-  required(): LiteralPrimitive<T, true, THasDefault>;
-  /** Set a default value for this literal */
-  default(defaultValue: T): LiteralPrimitive<T, TRequired, true>;
-  /** Get the literal value this primitive represents */
-  get literal(): T;
-  readonly _internal: PrimitiveInternal<T, LiteralProxy<T, TRequired, THasDefault>>;
-}
-/** Creates a new LiteralPrimitive with the given literal value */
-declare const Literal: <T extends LiteralValue>(literal: T) => LiteralPrimitive<T, false, false>;
-//#endregion
-//#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.
- * Uses StructSetInput directly for struct elements so that:
- * - Fields that are required AND have no default must be provided
- * - Fields that are optional OR have defaults can be omitted
- *
- * For non-struct elements, falls back to InferSetInput.
- */
-type ArrayElementSetInput<TElement extends AnyPrimitive> = TElement extends StructPrimitive<infer TFields, any, any> ? StructSetInput<TFields> : InferSetInput$5<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>>[];
-}
-/** Input type for array set() - an array of element set inputs */
-type ArraySetInput<TElement extends AnyPrimitive> = readonly ArrayElementSetInput<TElement>[];
-/** Input type for array update() - same as set() for arrays */
-type ArrayUpdateInput<TElement extends AnyPrimitive> = readonly ArrayElementSetInput<TElement>[];
-declare class ArrayPrimitive<TElement extends AnyPrimitive, TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<ArrayState<TElement>, ArrayProxy<TElement>, TRequired, THasDefault, ArraySetInput<TElement>, ArrayUpdateInput<TElement>> {
-  readonly _tag: "ArrayPrimitive";
-  readonly _State: ArrayState<TElement>;
-  readonly _Proxy: ArrayProxy<TElement>;
-  readonly _TRequired: TRequired;
-  readonly _THasDefault: THasDefault;
-  readonly TSetInput: ArraySetInput<TElement>;
-  readonly TUpdateInput: ArrayUpdateInput<TElement>;
-  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, TRequired, true>;
-  /** Get the element primitive */
-  get element(): TElement;
-  /** Add a custom validation rule */
-  refine(fn: (value: ArrayState<TElement>) => boolean, message: string): ArrayPrimitive<TElement, TRequired, THasDefault>;
-  /** Minimum array length */
-  minLength(length: number): ArrayPrimitive<TElement, TRequired, THasDefault>;
-  /** Maximum array length */
-  maxLength(length: number): ArrayPrimitive<TElement, TRequired, 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 SetInput from a lazy thunk
- */
-type InferLazySetInput<T extends () => AnyPrimitive> = InferSetInput$5<ReturnType<T>>;
-/**
- * Type to infer UpdateInput from a lazy thunk
- */
-type InferLazyUpdateInput<T extends () => AnyPrimitive> = InferUpdateInput$5<ReturnType<T>>;
-/**
- * Type to infer state from a lazy thunk
- */
-type InferLazyState<T extends () => AnyPrimitive> = InferState<ReturnType<T>>;
-/**
- * Type to infer proxy from a lazy thunk
- */
-type InferLazyProxy<T extends () => AnyPrimitive> = InferProxy<ReturnType<T>>;
-/**
- * Type to infer snapshot from a lazy thunk
- */
-type InferLazySnapshot<T extends () => AnyPrimitive> = InferSnapshot<ReturnType<T>>;
-declare class LazyPrimitive<TThunk extends () => AnyPrimitive> implements Primitive<InferLazyState<TThunk>, InferLazyProxy<TThunk>, false, false, InferLazySetInput<TThunk>, InferLazyUpdateInput<TThunk>> {
-  readonly _tag: "LazyPrimitive";
-  readonly _State: InferLazyState<TThunk>;
-  readonly _Proxy: InferLazyProxy<TThunk>;
-  readonly _TRequired: false;
-  readonly _THasDefault: false;
-  readonly TSetInput: InferLazySetInput<TThunk>;
-  readonly TUpdateInput: InferLazyUpdateInput<TThunk>;
-  private readonly _thunk;
-  private _resolved;
-  constructor(thunk: TThunk);
-  /** Resolve and cache the lazy primitive */
-  private _resolve;
-  /** Mark this lazy primitive as required (delegates to resolved) */
-  required(): LazyPrimitive<TThunk>;
-  readonly _internal: PrimitiveInternal<InferLazyState<TThunk>, InferLazyProxy<TThunk>>;
-}
-/** Creates a new LazyPrimitive with the given thunk */
-declare const Lazy: <TThunk extends () => AnyPrimitive>(thunk: TThunk) => LazyPrimitive<TThunk>;
-//#endregion
-//#region src/primitives/Union.d.ts
-/**
- * Type constraint for union variants - must be struct primitives
- */
-type UnionVariants = Record<string, StructPrimitive<any, any, any>>;
-/**
- * Infer the union state type from variants
- */
-type InferUnionState<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferState<TVariants[K]> }[keyof TVariants];
-/**
- * Infer the union snapshot type from variants
- */
-type InferUnionSnapshot<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferSnapshot<TVariants[K]> }[keyof TVariants];
-/**
- * Compute the input type for union.set() operations.
- * Uses each variant's TSetInput type.
- */
-type UnionSetInput<TVariants extends UnionVariants> = { [K in keyof TVariants]: InferSetInput$5<TVariants[K]> }[keyof TVariants];
-/**
- * Proxy for accessing union variants
- */
-interface UnionProxy<TVariants extends UnionVariants, _TDiscriminator extends string, TRequired extends boolean = false, THasDefault extends boolean = false> {
-  /** Gets the current union value */
-  get(): MaybeUndefined<InferUnionState<TVariants>, TRequired, THasDefault>;
-  /** Sets the entire union value (applies defaults for variant fields) */
-  set(value: UnionSetInput<TVariants>): void;
-  /** Access a specific variant's proxy (assumes the variant is active) */
-  as<K$1 extends keyof TVariants>(variant: K$1): InferProxy<TVariants[K$1]>;
-  /** Pattern match on the variant type */
-  match<R>(handlers: { [K in keyof TVariants]: (proxy: InferProxy<TVariants[K$1]>) => R }): R | undefined;
-  /** Returns a readonly snapshot of the union for rendering */
-  toSnapshot(): MaybeUndefined<InferUnionSnapshot<TVariants>, TRequired, THasDefault>;
-}
-interface UnionPrimitiveSchema<TVariants extends UnionVariants, TDiscriminator extends string> {
-  readonly required: boolean;
-  readonly defaultValue: InferUnionState<TVariants> | undefined;
-  readonly discriminator: TDiscriminator;
-  readonly variants: TVariants;
-}
-declare class UnionPrimitive<TVariants extends UnionVariants, TDiscriminator extends string = "type", TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>, TRequired, THasDefault, UnionSetInput<TVariants>, UnionSetInput<TVariants>> {
-  readonly _tag: "UnionPrimitive";
-  readonly _State: InferUnionState<TVariants>;
-  readonly _Proxy: UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>;
-  readonly _TRequired: TRequired;
-  readonly _THasDefault: THasDefault;
-  readonly TSetInput: UnionSetInput<TVariants>;
-  readonly TUpdateInput: UnionSetInput<TVariants>;
-  private readonly _schema;
-  private readonly _opDefinitions;
-  constructor(schema: UnionPrimitiveSchema<TVariants, TDiscriminator>);
-  /** Mark this union as required */
-  required(): UnionPrimitive<TVariants, TDiscriminator, true, THasDefault>;
-  /** Set a default value for this union */
-  default(defaultValue: UnionSetInput<TVariants>): UnionPrimitive<TVariants, TDiscriminator, true, true>;
-  /** Get the discriminator field name */
-  get discriminator(): TDiscriminator;
-  /** Get the variants */
-  get variants(): TVariants;
-  /** Find the variant key from a state value */
-  private _findVariantKey;
-  /** Apply defaults to a variant value based on the discriminator */
-  private _applyVariantDefaults;
-  readonly _internal: PrimitiveInternal<InferUnionState<TVariants>, UnionProxy<TVariants, TDiscriminator, TRequired, THasDefault>>;
-}
-/** Options for creating a Union primitive */
-interface UnionOptions<TVariants extends UnionVariants, TDiscriminator extends string> {
-  /** The field name used to discriminate between variants (defaults to "type") */
-  readonly discriminator?: TDiscriminator;
-  /** The variant struct primitives */
-  readonly variants: TVariants;
-}
-/** Creates a new UnionPrimitive with the given variants */
-declare function Union<TVariants extends UnionVariants>(options: UnionOptions<TVariants, "type">): UnionPrimitive<TVariants, "type", false, false>;
-declare function Union<TVariants extends UnionVariants, TDiscriminator extends string>(options: UnionOptions<TVariants, TDiscriminator>): UnionPrimitive<TVariants, TDiscriminator, false, false>;
-//#endregion
-//#region src/primitives/Either.d.ts
-type InferSetInput<TVariants extends readonly ScalarPrimitive[], TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<InferEitherState<TVariants>, TRequired, THasDefault>;
-type InferUpdateInput<TVariants extends readonly ScalarPrimitive[], TRequired extends boolean = false, THasDefault extends boolean = false> = NeedsValue<InferEitherState<TVariants>, TRequired, THasDefault>;
-/**
- * Scalar primitives that can be used as variants in Either
- */
-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[], TRequired extends boolean = false, THasDefault extends boolean = false> {
-  /** Gets the current value */
-  get(): MaybeUndefined<InferEitherState<TVariants>, TRequired, THasDefault>;
-  /** Sets the value to any of the allowed variant types */
-  set(value: InferSetInput<TVariants, TRequired, THasDefault>): void;
-  /** This is the same as set. Updates the value, generating an either.set operation */
-  update(value: InferUpdateInput<TVariants, TRequired, THasDefault>): void;
-  /** Pattern match on the value type */
-  match<R>(handlers: EitherMatchHandlers<R>): R | undefined;
-  /** Returns a readonly snapshot of the value for rendering */
-  toSnapshot(): MaybeUndefined<InferEitherSnapshot<TVariants>, TRequired, THasDefault>;
-}
-interface EitherPrimitiveSchema<TVariants extends readonly ScalarPrimitive[]> {
-  readonly required: boolean;
-  readonly defaultValue: InferEitherState<TVariants> | undefined;
-  readonly variants: TVariants;
-}
-declare class EitherPrimitive<TVariants extends readonly ScalarPrimitive[], TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<InferEitherState<TVariants>, EitherProxy<TVariants, TRequired, THasDefault>, TRequired, THasDefault, InferSetInput<TVariants, TRequired, THasDefault>, InferUpdateInput<TVariants, TRequired, THasDefault>> {
-  readonly _tag: "EitherPrimitive";
-  readonly _State: InferEitherState<TVariants>;
-  readonly _Proxy: EitherProxy<TVariants, TRequired, THasDefault>;
-  readonly _TRequired: TRequired;
-  readonly _THasDefault: THasDefault;
-  readonly TUpdateInput: InferUpdateInput<TVariants, TRequired, THasDefault>;
-  readonly TSetInput: InferSetInput<TVariants, TRequired, THasDefault>;
-  private readonly _schema;
-  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, TRequired, 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, TRequired, THasDefault>>;
-}
-/**
- * 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;
-  /** For InferSetInput compatibility - delegates to the data struct's set input type */
-  readonly TSetInput: InferSetInput$5<TData$1>;
-  /** For InferUpdateInput compatibility - delegates to the data struct's update input type */
-  readonly TUpdateInput: InferUpdateInput$5<TData$1>;
-  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.
- * Uses StructUpdateValue directly to get field-level partial update semantics.
- * All fields are optional in update operations.
- */
-type TreeNodeUpdateValue<TNode extends AnyTreeNodePrimitive> = TNode["data"] extends StructPrimitive<infer TFields, any, any> ? StructUpdateValue<TFields> : InferUpdateInput$5<TNode["data"]>;
-/**
- * Helper type to infer the input type for node data (respects field defaults).
- * Uses StructSetInput directly so that:
- * - Fields that are required AND have no default must be provided
- * - Fields that are optional OR have defaults can be omitted
- *
- * This bypasses the struct-level NeedsValue wrapper since tree inserts
- * always require a data object (even if empty for all-optional fields).
- */
-type TreeNodeDataSetInput<TNode extends AnyTreeNodePrimitive> = TNode["data"] extends StructPrimitive<infer TFields, any, any> ? StructSetInput<TFields> : InferSetInput$5<TNode["data"]>;
-/**
- * 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>>[];
-}
-/** Input type for tree set() - tree state */
-type TreeSetInput<TRoot$1 extends AnyTreeNodePrimitive> = TreeState<TRoot$1>;
-/** Input type for tree update() - same as set() for trees */
-type TreeUpdateInput<TRoot$1 extends AnyTreeNodePrimitive> = TreeState<TRoot$1>;
-declare class TreePrimitive<TRoot$1 extends AnyTreeNodePrimitive, TRequired extends boolean = false, THasDefault extends boolean = false> implements Primitive<TreeState<TRoot$1>, TreeProxy<TRoot$1>, TRequired, THasDefault, TreeSetInput<TRoot$1>, TreeUpdateInput<TRoot$1>> {
-  readonly _tag: "TreePrimitive";
-  readonly _State: TreeState<TRoot$1>;
-  readonly _Proxy: TreeProxy<TRoot$1>;
-  readonly _TRequired: TRequired;
-  readonly _THasDefault: THasDefault;
-  readonly TSetInput: TreeSetInput<TRoot$1>;
-  readonly TUpdateInput: TreeUpdateInput<TRoot$1>;
-  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, TRequired, 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, TRequired, 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, ArraySetInput, ArraySnapshot, ArrayState, ArrayUpdateInput, Boolean, BooleanPrimitive, BooleanProxy, Either, EitherMatchHandlers, EitherPrimitive, EitherProxy, HasDefault, InferEitherSnapshot, InferEitherState, InferLazyProxy, InferLazySetInput, InferLazySnapshot, InferLazyState, InferLazyUpdateInput, InferProxy, InferSetInput$5 as InferSetInput, InferSnapshot, InferState, InferStructSnapshot, InferStructState, InferTreeNodeChildren, InferTreeNodeDataState, InferTreeNodeType, InferTreeSnapshot, InferUnionSnapshot, InferUnionState, InferUpdateInput$5 as InferUpdateInput, IsDefined, IsRequired, Lazy, LazyPrimitive, Literal, LiteralPrimitive, LiteralProxy, LiteralValue, MaybeUndefined, NeedsValue, Number, NumberPrimitive, NumberProxy, Optional, Primitive, PrimitiveInternal, ScalarPrimitive, String, StringPrimitive, StringProxy, Struct, StructPrimitive, StructProxy, StructSetInput, StructUpdateValue, Tree, TreeNode, TreeNodeChildrenInput, TreeNodeConfig, TreeNodeDataSetInput, TreeNodePrimitive, TreeNodeProxyBase, TreeNodeSelf, TreeNodeSelfType, TreeNodeSnapshot, TreeNodeState, TreeNodeUpdateValue, TreeOptions, TreePrimitive, TreeProxy, TreeSetInput, TreeState, TreeUpdateInput, TypedNodeProxy, TypedTreeNodeState, Union, UnionOptions, UnionPrimitive, UnionProxy, UnionSetInput, UnionVariants, ValidationError, Validator, applyDefaults, isCompatibleOperation, runValidators };
-}
-//#endregion
-export { InferState as $, InferLazyProxy as A, ArraySnapshot as B, TreeNodeSelfType as C, InferUnionSnapshot as D, ScalarPrimitive as E, ArrayElementSetInput as F, StructProxy as G, ArrayUpdateInput as H, ArrayEntry as I, AnyPrimitive as J, StructSetInput as K, ArrayEntrySnapshot as L, InferLazySnapshot as M, InferLazyState as N, InferUnionState as O, InferLazyUpdateInput as P, InferSnapshot as Q, ArrayProxy as R, TreeNodeSelf as S, InferEitherState as T, InferStructSnapshot as U, ArrayState as V, InferStructState as W, InferProxy as X, HasDefault as Y, InferSetInput$5 as Z, InferTreeNodeDataState as _, OperationPath_d_exports as _t, TreeNodeSnapshot as a, Optional as at, TreeNodeConfig as b, TreePrimitive as c, Validator as ct, TreeState as d, ProxyEnvironment_d_exports as dt, InferUpdateInput$5 as et, TreeUpdateInput as f, EncodedTransaction as ft, InferTreeNodeChildren as g, Operation_d_exports as gt, AnyTreeNodePrimitive as h, Operation as ht, TreeNodeProxyBase as i, NeedsValue as it, InferLazySetInput as j, UnionVariants as k, TreeProxy as l, TransformResult as lt, TypedTreeNodeState as m, Transaction_d_exports as mt, InferTreeSnapshot as n, IsRequired as nt, TreeNodeState as o, Primitive as ot, TypedNodeProxy as p, Transaction as pt, StructUpdateValue as q, TreeNodeDataSetInput as r, MaybeUndefined as rt, TreeNodeUpdateValue as s, PrimitiveInternal as st, Primitive_d_exports as t, IsDefined as tt, TreeSetInput as u, Transform_d_exports as ut, InferTreeNodeType as v, InferEitherSnapshot as w, TreeNodePrimitive as x, TreeNodeChildrenInput as y, ArraySetInput as z };
-//# sourceMappingURL=Primitive-DqQFc3Gu.d.mts.map