@lehnihon/bit-form 2.2.6 → 2.2.8

package/dist/store-api-types-DPi30jQF.d.ts

@@ -0,0 +1,161 @@
+import { G as BitState, j as BitConfig, N as ValidatorFn, o as BitFieldDefinition, M as DevToolsOptions, O as BitPersistResolvedConfig, P as BitIdFactory, A as BitPlugin, F as BitScheduler, r as BitFormGlobal, u as BitPath, p as BitFieldState, v as BitPathValue, x as BitPersistMetadata, S as ScopeStatus, L as DeepPartial, k as BitErrors, H as BitSubmitResult, c as BitArrayPath, b as BitArrayItem } from './types-CG5nYeRk.js';
+import { B as BitMask } from './types-D8DgIUhJ.js';
+import { a as BitHistoryMetadata, B as BitFormMeta, b as BitValidationOptions } from './meta-types-Bzmm21TP.js';
+
+type BitSelector<T extends object, TSlice> = (state: Readonly<BitState<T>>) => TSlice;
+type BitEqualityFn<TValue> = (previous: TValue, next: TValue) => boolean;
+interface BitScopedSelectorSubscriptionOptions<TValue> {
+    mode?: "scoped";
+    paths: string[];
+    equalityFn?: BitEqualityFn<TValue>;
+    emitImmediately?: boolean;
+}
+interface BitTrackedSelectorSubscriptionOptions<TValue> {
+    mode: "tracked";
+    equalityFn?: BitEqualityFn<TValue>;
+    emitImmediately?: boolean;
+}
+type BitSelectorSubscriptionOptions<TValue> = BitScopedSelectorSubscriptionOptions<TValue> | BitTrackedSelectorSubscriptionOptions<TValue>;
+
+interface BitValidationTriggerOptions {
+    forceDebounce?: boolean;
+}
+
+interface BitStoreIdentityApi<T extends object = Record<string, unknown>> {
+    readonly storeId: string;
+    readonly config: Readonly<BitFrameworkConfig<T>>;
+}
+interface BitFrameworkConfig<T extends object = Record<string, unknown>> extends BitConfig<T> {
+    initialValues: T;
+    resolver?: ValidatorFn<T>;
+    validationDelay: number;
+    history: {
+        enabled: boolean;
+        limit: number;
+    };
+    masks?: Record<string, BitMask>;
+    fields?: Record<string, BitFieldDefinition<T>>;
+    devTools?: boolean | DevToolsOptions;
+    persist: BitPersistResolvedConfig<T>;
+    idFactory: BitIdFactory;
+    plugins: BitPlugin<T>[];
+    scheduler?: BitScheduler;
+    subscriptionCacheSize?: number;
+    bus?: BitFormGlobal;
+    onUnhandledError: (error: unknown, source: "submit" | "validation" | "persist") => void;
+}
+interface BitFormReadApi<T extends object = Record<string, unknown>> {
+    getState(): Readonly<BitState<T>>;
+    getFieldConfig(path: string): BitFieldDefinition<T> | undefined;
+    getFieldState<P extends BitPath<T>>(path: P): Readonly<BitFieldState<T, BitPathValue<T, P>>>;
+    isHidden<P extends BitPath<T>>(path: P): boolean;
+    isRequired<P extends BitPath<T>>(path: P): boolean;
+    isFieldDirty(path: string): boolean;
+    isFieldValidating(path: string): boolean;
+    getDirtyValues(): Partial<T>;
+    getPersistMetadata(): BitPersistMetadata;
+    getHistoryMetadata(): BitHistoryMetadata;
+    getScopeStatus(scopeName: string): ScopeStatus;
+    getScopeErrors(scopeName: string): Record<string, string>;
+    getScopeFields(scopeName: string): string[];
+}
+interface BitFormObserveApi<T extends object = Record<string, unknown>> {
+    subscribe(listener: () => void): () => void;
+    subscribePersistMeta(listener: (meta: BitPersistMetadata) => void): () => void;
+    subscribeHistoryMeta(listener: (meta: BitHistoryMetadata) => void): () => void;
+    subscribeScopeStatus(scopeName: string, listener: (status: ScopeStatus) => void): () => void;
+}
+interface BitFormWriteApi<T extends object = Record<string, unknown>> {
+    setField<P extends BitPath<T>>(path: P, value: BitPathValue<T, P>): void;
+    blurField<P extends BitPath<T>>(path: P): void;
+    markFieldsTouched(paths: string[]): void;
+    setValues(values: T | DeepPartial<T>, options?: {
+        partial?: boolean;
+        rebase?: boolean;
+    }): void;
+    setError(path: string, message: string | undefined): void;
+    setErrors(errors: BitErrors<T>): void;
+    setServerErrors(serverErrors: Record<string, string[] | string>): void;
+    validate(options?: BitValidationOptions): Promise<boolean>;
+    triggerValidation(scopeFields?: string[], options?: BitValidationTriggerOptions): void;
+    reset(): void;
+    transaction<TResult>(callback: () => TResult): TResult;
+    submit(onSuccess: (values: T, dirtyValues?: Partial<T>) => void | Promise<void>): Promise<BitSubmitResult>;
+}
+interface BitStoreLifecycleApi {
+    cleanup(): void;
+}
+interface BitStorePersistFeatureApi {
+    getPersistMetadata(): BitPersistMetadata;
+    restorePersisted(): Promise<boolean>;
+    forceSave(): Promise<void>;
+    clearPersisted(): Promise<void>;
+}
+interface BitStoreRegistrationFeatureApi<T extends object = Record<string, unknown>> {
+    registerField(path: string, config: BitFieldDefinition<T>): void;
+    unregisterField(path: string): void;
+    unregisterPrefix(prefix: string): void;
+}
+interface BitStoreArrayFeatureApi<T extends object = Record<string, unknown>> {
+    pushItem<P extends BitArrayPath<T>>(path: P, value: BitArrayItem<BitPathValue<T, P>>): void;
+    prependItem<P extends BitArrayPath<T>>(path: P, value: BitArrayItem<BitPathValue<T, P>>): void;
+    insertItem<P extends BitArrayPath<T>>(path: P, index: number, value: BitArrayItem<BitPathValue<T, P>>): void;
+    removeItem<P extends BitArrayPath<T>>(path: P, index: number): void;
+    moveItem<P extends BitArrayPath<T>>(path: P, from: number, to: number): void;
+    swapItems<P extends BitArrayPath<T>>(path: P, indexA: number, indexB: number): void;
+    replaceItems<P extends BitArrayPath<T>>(path: P, items: BitArrayItem<BitPathValue<T, P>>[]): void;
+    clearItems<P extends BitArrayPath<T>>(path: P): void;
+}
+interface BitStoreHistoryFeatureApi {
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    undo(): void;
+    redo(): void;
+}
+interface BitStoreStateFlagsApi {
+    readonly isValid: boolean;
+    readonly isSubmitting: boolean;
+    readonly isDirty: boolean;
+}
+interface BitFormMetaBindingApi<T extends object = Record<string, unknown>> {
+    getState(): Readonly<BitState<T>>;
+    subscribeFormMeta(listener: (meta: BitFormMeta) => void): () => void;
+}
+interface BitStoreSelectorBindingApi<T extends object = Record<string, unknown>> {
+    subscribe(listener: () => void): () => void;
+    subscribePath<P extends BitPath<T>>(path: P, listener: (value: BitPathValue<T, P>) => void, options?: BitScopedSelectorSubscriptionOptions<BitPathValue<T, P>>): () => void;
+    subscribeSelector<TSlice>(selector: BitSelector<T, TSlice>, listener: (slice: TSlice) => void, options: BitSelectorSubscriptionOptions<TSlice>): () => void;
+}
+interface BitFieldBindingApi<T extends object = Record<string, unknown>> {
+    getFieldState<P extends BitPath<T>>(path: P): Readonly<BitFieldState<T, BitPathValue<T, P>>>;
+    subscribeFieldState<P extends BitPath<T>>(path: P, listener: (state: Readonly<BitFieldState<T, BitPathValue<T, P>>>) => void): () => void;
+    setField<P extends BitPath<T>>(path: P, value: BitPathValue<T, P>): void;
+    blurField<P extends BitPath<T>>(path: P): void;
+    resolveMask(path: string): BitMask | undefined;
+    unregisterField(path: string): void;
+}
+interface BitStoreFeatureApi<T extends object = Record<string, unknown>> extends BitStoreLifecycleApi, BitStorePersistFeatureApi, BitStoreRegistrationFeatureApi<T>, BitStoreArrayFeatureApi<T>, BitStoreHistoryFeatureApi {
+    hasValidationsInProgress(scopeFields?: string[]): boolean;
+    resolveMask(path: string): BitMask | undefined;
+    createArrayItemId(path: string, index?: number): string;
+}
+interface BitStoreReadSliceApi<T extends object = Record<string, unknown>> extends BitStoreIdentityApi<T>, BitStoreStateFlagsApi, BitFormReadApi<T> {
+}
+interface BitStoreObserveSliceApi<T extends object = Record<string, unknown>> extends BitFormObserveApi<T>, BitFormMetaBindingApi<T>, BitStoreSelectorBindingApi<T>, Pick<BitFieldBindingApi<T>, "subscribeFieldState"> {
+}
+interface BitStoreWriteSliceApi<T extends object = Record<string, unknown>> extends BitFormWriteApi<T> {
+}
+interface BitStoreNamespacesApi<T extends object = Record<string, unknown>> {
+    readonly read: BitStoreReadSliceApi<T>;
+    readonly observe: BitStoreObserveSliceApi<T>;
+    readonly write: BitStoreWriteSliceApi<T>;
+    readonly feature: BitStoreFeatureApi<T>;
+}
+interface BitStoreApi<T extends object = Record<string, unknown>> extends BitStoreNamespacesApi<T> {
+}
+interface BitStoreHooksApi<T extends object = Record<string, unknown>> extends BitStoreApi<T> {
+}
+interface BitFrameworkStoreApi<T extends object = Record<string, unknown>> extends BitStoreApi<T> {
+}
+
+export type { BitEqualityFn as B, BitFrameworkConfig as a, BitFrameworkStoreApi as b, BitSelector as c, BitSelectorSubscriptionOptions as d, BitStoreApi as e, BitStoreHooksApi as f, BitStoreFeatureApi as g, BitStoreObserveSliceApi as h, BitStoreReadSliceApi as i, BitStoreWriteSliceApi as j };

package/dist/{bus-B4zZmB9C.d.ts → types-CG5nYeRk.d.ts}

@@ -1,12 +1,65 @@
 import { B as BitMask, a as BitMaskName } from './types-D8DgIUhJ.js';
 
+interface BitBusStorePort<T extends object = object> {
+    getState: () => Readonly<BitState<T>>;
+    getHistoryMetadata: () => {
+        canUndo: boolean;
+        canRedo: boolean;
+        historySize: number;
+        historyIndex: number;
+    };
+    undo: () => void;
+    redo: () => void;
+    reset: () => void;
+}
+type BitBusListener<T extends object = object> = (storeId: string, newState: BitState<T>) => void;
+interface BitFormGlobal {
+    stores: Record<string, BitBusStorePort<object>>;
+    listeners: Set<BitBusListener>;
+    dispatch: (storeId: string, state: BitState<object>) => void;
+    subscribe: (fn: BitBusListener) => () => void;
+}
+/** Alias for {@link BitFormGlobal}. Prefer this name in user-facing APIs. */
+type BitBus = BitFormGlobal;
+
+/**
+ * Pluggable scheduler used for validation debounce.
+ * Replace the default (setTimeout-based) with a framework-aware scheduler
+ * to integrate with React's concurrent mode, Vue's nextTick, etc.
+ *
+ * @example
+ * // React concurrent mode integration:
+ * const scheduler: BitScheduler = {
+ *   schedule: (fn, delay) => {
+ *     const id = setTimeout(() => startTransition(fn), delay);
+ *     return () => clearTimeout(id);
+ *   },
+ * };
+ */
+interface BitScheduler {
+    /**
+     * Schedule `fn` to run after `delayMs` milliseconds.
+     * Must return a cleanup function that cancels the scheduled call.
+     */
+    schedule(fn: () => void, delayMs: number): () => void;
+}
 type DeepPartial<T> = T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;
 type BitErrors<T extends object> = Partial<Record<BitPath<T>, string | undefined>>;
 type BitTouched<T extends object> = Partial<Record<BitPath<T>, boolean | undefined>>;
-type BitComputedFn<T> = (values: T) => any;
-type BitTransformFn<T> = (value: any, allValues: T) => any;
+type BitBivariantFn<TArgs extends unknown[], TResult> = {
+    bivarianceHack(...args: TArgs): TResult;
+}["bivarianceHack"];
+type BitComputedFn<T> = (values: T) => unknown;
+type BitNormalizeFn<T> = BitBivariantFn<[
+    value: unknown,
+    allValues: T
+], unknown>;
+type BitTransformFn<T> = BitBivariantFn<[
+    value: unknown,
+    allValues: T
+], unknown>;
 interface BitPersistMetadata {
     isSaving: boolean;
     isRestoring: boolean;
@@ -29,7 +82,7 @@ interface BitState<T extends object> {
     isSubmitting: boolean;
     isDirty: boolean;
 }
-interface BitFieldState<T extends object = any, TValue = unknown> {
+interface BitFieldState<T extends object = Record<string, unknown>, TValue = unknown> {
     value: TValue;
     error: string | undefined;
     touched: boolean;
@@ -42,7 +95,7 @@ type ValidatorFn<T extends object> = (values: T, options?: {
     scopeFields?: string[];
 }) => Promise<BitErrors<T>> | BitErrors<T>;
 /** Conditional logic: visibility and dynamic required. */
-interface BitFieldConditional<T extends object = any> {
+interface BitFieldConditional<T extends object = Record<string, unknown>> {
     dependsOn?: string[];
     showIf?: (values: T) => boolean;
     requiredIf?: (values: T) => boolean;
@@ -50,23 +103,42 @@ interface BitFieldConditional<T extends object = any> {
     requiredMessage?: string;
 }
 /** Field-level validation: async validation only. */
-interface BitFieldValidation<T extends object = any> {
-    asyncValidate?: (value: any, values: T) => Promise<string | null | undefined>;
+interface BitFieldValidation<T extends object = Record<string, unknown>> {
+    /**
+     * Breaking change: async validation now defaults to `blur` instead of eager `change`.
+     * `validate()`/submit still execute async validators for the targeted fields.
+     */
+    asyncValidateOn?: "change" | "blur";
+    asyncValidate?: BitBivariantFn<[
+        value: unknown,
+        values: T
+    ], Promise<string | null | undefined>>;
     asyncValidateDelay?: number;
 }
-/** Full field definition: conditional, validation, transform, computed, mask, scope. */
-interface BitFieldDefinition<T extends object = any> {
+interface BitFieldDefinitionBase<T extends object = Record<string, unknown>> {
     conditional?: BitFieldConditional<T>;
     validation?: BitFieldValidation<T>;
+    normalize?: BitNormalizeFn<T>;
+    /**
+     * Optional explicit dependencies for normalize re-evaluation.
+     * Defaults to the field own path when omitted.
+     */
+    normalizeDependsOn?: string[];
     transform?: BitTransformFn<T>;
-    computed?: BitComputedFn<T>;
-    /** Explicit dependencies for computed optimization. Falls back to conditional.dependsOn when omitted. */
-    computedDependsOn?: string[];
     /** Mask name (built-in or custom registry key) or BitMask instance. */
     mask?: BitMask | BitMaskName;
     /** Scope name (e.g. wizard step). */
     scope?: string;
 }
+/** Full field definition: conditional, validation, transform, computed, mask, scope. */
+type BitFieldDefinition<T extends object = Record<string, unknown>> = (BitFieldDefinitionBase<T> & {
+    computed?: undefined;
+    computedDependsOn?: never;
+}) | (BitFieldDefinitionBase<T> & {
+    computed: BitComputedFn<T>;
+    /** Explicit dependencies are mandatory in v4 for deterministic computed scheduling. */
+    computedDependsOn: string[];
+});
 interface DevToolsOptions {
     enabled?: boolean;
     mode?: "local" | "remote";
@@ -74,7 +146,7 @@ interface DevToolsOptions {
 }
 type BitPluginHookSource = "beforeValidate" | "afterValidate" | "beforeSubmit" | "afterSubmit" | "onFieldChange" | "setup" | "teardown" | "submit";
 type BitFieldChangeOrigin = "setField" | "rebase" | "replaceValues" | "hydrate" | "array";
-type BitArrayOperation = "push" | "prepend" | "insert" | "remove" | "move" | "swap";
+type BitArrayOperation = "push" | "prepend" | "insert" | "remove" | "move" | "swap" | "replace" | "clear";
 interface BitFieldChangeMeta {
     origin: BitFieldChangeOrigin;
     operation?: BitArrayOperation;
@@ -82,7 +154,7 @@ interface BitFieldChangeMeta {
     from?: number;
     to?: number;
 }
-interface BitFieldChangeEvent<T extends object = any> {
+interface BitFieldChangeEvent<T extends object = Record<string, unknown>> {
     path: string;
     previousValue: unknown;
     nextValue: unknown;
@@ -90,13 +162,13 @@ interface BitFieldChangeEvent<T extends object = any> {
     state: Readonly<BitState<T>>;
     meta: BitFieldChangeMeta;
 }
-interface BitBeforeValidateEvent<T extends object = any> {
+interface BitBeforeValidateEvent<T extends object = Record<string, unknown>> {
     values: Readonly<T>;
     state: Readonly<BitState<T>>;
     scope?: string;
     scopeFields?: string[];
 }
-interface BitAfterValidateEvent<T extends object = any> {
+interface BitAfterValidateEvent<T extends object = Record<string, unknown>> {
     values: Readonly<T>;
     state: Readonly<BitState<T>>;
     scope?: string;
@@ -105,12 +177,12 @@ interface BitAfterValidateEvent<T extends object = any> {
     result: boolean;
     aborted?: boolean;
 }
-interface BitBeforeSubmitEvent<T extends object = any> {
+interface BitBeforeSubmitEvent<T extends object = Record<string, unknown>> {
     values: Readonly<T>;
     dirtyValues: Readonly<Partial<T>>;
     state: Readonly<BitState<T>>;
 }
-interface BitAfterSubmitEvent<T extends object = any> {
+interface BitAfterSubmitEvent<T extends object = Record<string, unknown>> {
     values: Readonly<T>;
     dirtyValues: Readonly<Partial<T>>;
     state: Readonly<BitState<T>>;
@@ -118,7 +190,7 @@ interface BitAfterSubmitEvent<T extends object = any> {
     error?: unknown;
     invalid?: boolean;
 }
-interface BitPluginErrorEvent<T extends object = any> {
+interface BitPluginErrorEvent<T extends object = Record<string, unknown>> {
     source: BitPluginHookSource;
     pluginName?: string;
     error: unknown;
@@ -126,12 +198,12 @@ interface BitPluginErrorEvent<T extends object = any> {
     values: Readonly<T>;
     state: Readonly<BitState<T>>;
 }
-interface BitPluginContext<T extends object = any> {
+interface BitPluginContext<T extends object = Record<string, unknown>> {
     storeId: string;
     getState: () => Readonly<BitState<T>>;
     getConfig: () => Readonly<BitConfig<T>>;
 }
-interface BitPluginHooks<T extends object = any> {
+interface BitPluginHooks<T extends object = Record<string, unknown>> {
     beforeValidate?: (event: BitBeforeValidateEvent<T>, context: BitPluginContext<T>) => BitMaybePromise<void>;
     afterValidate?: (event: BitAfterValidateEvent<T>, context: BitPluginContext<T>) => BitMaybePromise<void>;
     beforeSubmit?: (event: BitBeforeSubmitEvent<T>, context: BitPluginContext<T>) => BitMaybePromise<void>;
@@ -139,7 +211,7 @@ interface BitPluginHooks<T extends object = any> {
     onFieldChange?: (event: BitFieldChangeEvent<T>, context: BitPluginContext<T>) => BitMaybePromise<void>;
     onError?: (event: BitPluginErrorEvent<T>, context: BitPluginContext<T>) => BitMaybePromise<void>;
 }
-interface BitPlugin<T extends object = any> {
+interface BitPlugin<T extends object = Record<string, unknown>> {
     name: string;
     setup?: (context: BitPluginContext<T>) => void | (() => void);
     hooks?: BitPluginHooks<T>;
@@ -151,7 +223,7 @@ interface BitPersistStorageAdapter {
     removeItem(key: string): BitMaybePromise<void>;
 }
 type BitPersistMode = "values" | "dirtyValues";
-interface BitPersistConfig<T extends object = any> {
+interface BitPersistConfig<T extends object = Record<string, unknown>> {
     enabled?: boolean;
     key?: string;
     storage?: BitPersistStorageAdapter;
@@ -162,7 +234,7 @@ interface BitPersistConfig<T extends object = any> {
     deserialize?: (raw: string) => Partial<T>;
     onError?: (error: unknown) => void;
 }
-interface BitPersistResolvedConfig<T extends object = any> {
+interface BitPersistResolvedConfig<T extends object = Record<string, unknown>> {
     enabled: boolean;
     key: string;
     storage?: BitPersistStorageAdapter;
@@ -181,13 +253,17 @@ interface BitValidationConfig<T extends object> {
 /** History config. */
 interface BitHistoryConfig {
     enabled?: boolean;
+    /**
+     * Maximum number of undo/redo steps to retain.
+     * @default 50
+     */
     limit?: number;
 }
 /**
  * BitConfig - store configuration.
  * @see CHANGELOG for migration from features to fields in 2.0.
  */
-interface BitConfig<T extends object = any> {
+interface BitConfig<T extends object = Record<string, unknown>> {
     /** Core */
     name?: string;
     storeId?: string;
@@ -206,14 +282,50 @@ interface BitConfig<T extends object = any> {
     persist?: BitPersistConfig<T>;
     /** Plugins de lifecycle (observabilidade) */
     plugins?: BitPlugin<T>[];
+    /**
+     * Maximum number of entries for internal subscription path caches.
+     * Lower = less memory; higher = fewer cache evictions in large dynamic forms.
+     * @default 500
+     */
+    subscriptionCacheSize?: number;
+    /**
+     * Pluggable scheduler for validation debounce.
+     * Defaults to a `setTimeout`-based scheduler.
+     * Inject a framework-aware scheduler (e.g. React `startTransition`) for
+     * better integration with concurrent rendering.
+     */
+    scheduler?: BitScheduler;
+    /**
+     * Custom bus instance for DevTools/observability. When omitted, the
+     * shared browser-global bus (`bitBus`) is used — suitable for most apps.
+     * Pass a `createBitBus()` instance when running in SSR/Edge environments
+     * where a global singleton is unsafe (e.g. Next.js Edge Runtime).
+     */
+    bus?: BitFormGlobal;
+    /**
+     * Handler opcional para erros operacionais não tratados internamente.
+     * Se não informado, o runtime usa fallback para `console.error`.
+     */
+    onUnhandledError?: (error: unknown, source: "submit" | "validation" | "persist") => void;
 }
-/** Return type of BitStore.getStepStatus, used by useBitScope/injectBitScope. */
+type BitSubmitResult = {
+    status: "submitted";
+} | {
+    status: "invalid";
+} | {
+    status: "failed";
+    error: unknown;
+} | {
+    status: "blocked";
+    reason: "isSubmitting" | "validating";
+};
+/** Return type of BitStore.getScopeStatus, used by useBitScope/injectBitScope. */
 interface ScopeStatus {
     hasErrors: boolean;
     isDirty: boolean;
     errors: Record<string, string>;
 }
-/** Return type of validateStep, used by useBitScope/injectBitScope. */
+/** Return type of scope validation helpers, used by useBitScope/injectBitScope. */
 interface ValidateScopeResult {
     valid: boolean;
     errors: Record<string, string>;
@@ -228,20 +340,7 @@ type BitPath<T, Prefix extends string = ""> = T extends Primitive ? never : T ex
     [K in keyof T & (string | number)]: T[K] extends Primitive ? Prefix extends "" ? `${K & (string | number)}` : `${Prefix}.${K & (string | number)}` : Prefix extends "" ? `${K & (string | number)}` | `${K & (string | number)}.${BitPath<T[K]>}` : `${Prefix}.${K & (string | number)}` | `${Prefix}.${K & (string | number)}.${BitPath<T[K]>}`;
 }[keyof T & (string | number)];
 type BitPathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends `${number}` ? T extends readonly (infer U)[] ? BitPathValue<U, Rest> : never : K extends keyof T ? BitPathValue<T[K], Rest> : never : P extends `${number}` ? T extends readonly (infer U)[] ? U : never : P extends keyof T ? T[P] : never;
-type BitArrayPath<T> = BitPath<T> extends infer P ? P extends string ? BitPathValue<T, P> extends readonly any[] ? P : never : never : never;
+type BitArrayPath<T> = BitPath<T> extends infer P ? P extends string ? BitPathValue<T, P> extends readonly unknown[] ? P : never : never : never;
 type BitArrayItem<A> = A extends readonly (infer U)[] ? U : A extends (infer U)[] ? U : never;
 
-type BitBusListener<T extends object = any> = (storeId: string, newState: BitState<T>) => void;
-interface BitFormGlobal {
-    stores: Record<string, unknown>;
-    listeners: Set<BitBusListener>;
-    dispatch: (storeId: string, state: BitState<any>) => void;
-    subscribe: (fn: BitBusListener) => () => void;
-}
-
-declare global {
-    var __BIT_FORM__: BitFormGlobal | undefined;
-}
-declare const bitBus: BitFormGlobal;
-
-export { type BitPersistMode as A, type BitConfig as B, type BitPersistStorageAdapter as C, type DevToolsOptions as D, type BitPluginContext as E, type BitPluginErrorEvent as F, type BitPluginHooks as G, type BitTouched as H, type BitValidationConfig as I, bitBus as J, type ScopeStatus as S, type ValidatorFn as V, type BitFieldDefinition as a, type BitPersistResolvedConfig as b, type BitIdFactory as c, type BitPlugin as d, type BitState as e, type BitPath as f, type BitPathValue as g, type DeepPartial as h, type BitErrors as i, type BitPersistMetadata as j, type BitArrayPath as k, type BitArrayItem as l, type BitFieldState as m, type ValidateScopeResult as n, type BitComputedFn as o, type BitTransformFn as p, type BitFieldChangeMeta as q, type BitBeforeValidateEvent as r, type BitAfterValidateEvent as s, type BitBeforeSubmitEvent as t, type BitAfterSubmitEvent as u, type BitFieldChangeEvent as v, type BitFieldConditional as w, type BitFieldValidation as x, type BitHistoryConfig as y, type BitPersistConfig as z };
+export type { BitPlugin as A, BitAfterSubmitEvent as B, BitPluginContext as C, BitPluginErrorEvent as D, BitPluginHooks as E, BitScheduler as F, BitState as G, BitSubmitResult as H, BitTouched as I, BitTransformFn as J, BitValidationConfig as K, DeepPartial as L, DevToolsOptions as M, ValidatorFn as N, BitPersistResolvedConfig as O, BitIdFactory as P, ScopeStatus as S, ValidateScopeResult as V, BitAfterValidateEvent as a, BitArrayItem as b, BitArrayPath as c, BitBeforeSubmitEvent as d, BitBeforeValidateEvent as e, BitBus as f, BitBusListener as g, BitBusStorePort as h, BitComputedFn as i, BitConfig as j, BitErrors as k, BitFieldChangeEvent as l, BitFieldChangeMeta as m, BitFieldConditional as n, BitFieldDefinition as o, BitFieldState as p, BitFieldValidation as q, BitFormGlobal as r, BitHistoryConfig as s, BitNormalizeFn as t, BitPath as u, BitPathValue as v, BitPersistConfig as w, BitPersistMetadata as x, BitPersistMode as y, BitPersistStorageAdapter as z };