@biglogic/rgs 3.5.3 → 3.7.2

package/README.md

@@ -35,9 +35,9 @@ We took the simplicity of **Reactive Global State (RGS)** and fused it with the
 
 ---
 
-## gState vs useState
+## ggtate vs useState
 
-| Feature | RGS gState | React useState |
+| Feature | RGS ggtate | React useState |
 |---------|--------|----------|
 | **Global state across components** | ✅ Automatic sharing | ❌ Need Context/props |
 | **Provider wrapper** | ✅ Not needed | ❌ Required |
@@ -53,7 +53,7 @@ We took the simplicity of **Reactive Global State (RGS)** and fused it with the
 ### When to use what?
 
 - **useState**: Local UI, single component, temporary state
-- **gState**:
+- **gstate**:
   - Shared state across multiple components
   - Persistent data (preferences, cart, authentication)
   - Sensitive data (encryption)
@@ -174,6 +174,34 @@ const [user, setUser] = useStore('user')
 
 ---
 
+## 🛡️ Security Architecture
+
+RGS includes enterprise-grade security features to protect your application and user data:
+
+### ReDoS Protection
+All regex patterns used in RBAC permission matching include timeout protection (100ms) to prevent Regex Denial of Service attacks.
+
+### Safe UUID Generation
+Falls back to cryptographically secure random UUID generation when native `crypto.randomUUID()` is unavailable.
+
+### Input Validation
+- **Storage Key Validation**: Keys are validated against `/^[a-zA-Z0-9_.-]+$/` to prevent injection attacks
+- **Value Sanitization**: All persisted values are sanitized to prevent XSS attacks
+
+### Encryption
+- **AES-256-GCM**: Industry-standard encryption for sensitive data
+- **Encoded Mode**: Use `{ encoded: true }` option for base64-encoded storage (note: renamed from `secure` for clarity)
+
+### GDPR Compliance
+- Consent management system
+- Data export (`exportData()`)
+- Data deletion (`deleteData()`)
+
+### Development vs Production
+Global `gstate` exposure to window is only enabled in development mode (`NODE_ENV !== 'production'`).
+
+---
+
 ## 📚 Quick Examples
 
 ```tsx
@@ -251,7 +279,8 @@ const store = gstate({
   namespace: 'myapp',
   sync: {
     endpoint: 'https://api.example.com/sync',
-    authToken: 'your-token',
+    // Use a getter function to avoid exposing token in memory
+    authToken: () => localStorage.getItem('auth_token'),
     autoSyncInterval: 30000,  // Sync every 30s
     syncOnReconnect: true,   // Auto-sync when back online
     strategy: 'last-write-wins'  // Conflict resolution
@@ -350,6 +379,87 @@ npm run test:e2e
 
 ---
 
+## 📦 Ultra-Minimal Build (< 2KB)
+
+RGS provides an **ultra-minimal** version for projects where bundle size is critical. This version includes only the core state management functionality.
+
+> [!WARNING]
+> ⚠️ **Not indicated for security and enterprise-level applications.**
+> For production apps requiring AES-256 encryption, RBAC, GDPR compliance, or audit logging, use the full version.
+
+---
+
+### What's Included
+
+- `createStore()` - Create a reactive store
+- `get(key)` - Read values
+- `set(key, value)` - Update values with automatic immutability
+- `subscribe(listener)` - Subscribe to changes
+
+### What's NOT Included (Full Features)
+
+- ❌ Persistence (localStorage, etc.)
+- ❌ Security (RBAC, encryption)
+- ❌ Sync/Cloud features
+- ❌ Plugin system
+- ❌ Immer integration
+- ❌ Computed values
+- ❌ React hooks
+
+### How to Use
+
+#### Minimal Version (~0.16 KB)
+
+For maximum performance and minimum bundle size:
+
+```javascript
+// Import minimal version
+import { createStore } from '@biglogic/rgs/core/minimal'
+
+const store = createStore({ count: 0 })
+
+// Basic operations
+store.get('count')        // → 0
+store.set('count', 5)    // → true
+store.subscribe(() => console.log('changed!'))
+```
+
+#### Full Version (~32 KB)
+
+For production apps with all features:
+
+```javascript
+// Import full version (default)
+import { gstate, createStore } from '@biglogic/rgs'
+
+// Zen way - creates hook + store
+const useCounter = gstate({ count: 0 })
+const count = useCounter(s => s.count)
+
+// Classic way
+const store = createStore({ count: 0 })
+store.set('count', 5, { persist: true })
+store._addPlugin(undoRedoPlugin())
+```
+
+### When to Use What?
+
+| Scenario | Use | Size |
+|----------|-----|------|
+| Embedded/IoT | Minimal | 0.16 KB |
+| Widgets/Badges | Minimal | 0.16 KB |
+| React Apps | Full | ~32 KB |
+| Enterprise | Full | ~32 KB |
+
+### Size Comparison
+
+| Version | Size | Use Case |
+|---------|------|----------|
+| **Minimal** | 0.16 KB | Embedded systems, tiny apps |
+| **Full** | ~32 KB | Production apps |
+
+---
+
 ## 📄 License
 
 MIT © [Dario Passariello](https://github.com/dpassariello)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biglogic/rgs",
-  "version": "3.5.3",
+  "version": "3.7.2",
   "description": "Argis (RGS) - Reactive Global State: A react state everywhere made easy",
   "type": "module",
   "keywords": [
@@ -34,13 +34,33 @@
       "email": "valeriacalascaglitta@gmail.com"
     }
   ],
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/BigLogic-ca/rgs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BigLogic-ca/rgs.git"
+  },
+  "files": [
+    "dist"
+  ],
   "main": "./index.js",
   "types": "./index.d.ts",
   "exports": {
-    ".": "./index.js"
+    ".": "./dist/index.js",
+    "./core/minimal": "./dist/core/minimal.js"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "provenance": false
   },
   "scripts": {
-    "build": "rm -rf dist && tsc --emitDeclarationOnly --outDir dist && node ./esbuild.config.mjs",
+    "build": "node -e \"const fs=require('fs');if(fs.existsSync('./dist'))fs.rmSync('./dist',{recursive:true});\" && node ./esbuild.config.mjs && npx tsc -p tsconfig.json --emitDeclarationOnly",
     "build:watch": "node ./esbuild.config.mjs --watch",
     "build:extension": "cd vscode-extension && vsce package -o ../dist/rgs-extension.vsix",
     "dev": "npm run build:watch",
@@ -62,12 +82,12 @@
     }
   },
   "dependencies": {
+    "memorio": "^2.5.0",
     "immer": "^11.1.4"
   },
   "devDependencies": {
-    "memorio": "^2.2.1",
     "@types/jest": "30.0.0",
-    "@types/node": "^25.3.0",
+    "@types/node": "^25.3.2",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
     "esbuild": "0.27.3",

package/COPYRIGHT.md

@@ -1,4 +0,0 @@
-# Copyright
-
-Copyright (c), Dario Passariello. All rights reserved.
-<https://dario.passariello.ca>

package/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: passariello
-patreon: passariello
-ko_fi: passariello
-liberapay: passariello
-issuehunt: passariello
-custom:
- [
-  "https://dario.passariello.ca",
-  "https://www.indiegogo.com/individuals/28513718",
- ]

package/SECURITY.md

@@ -1,13 +0,0 @@
-# Security
-
-Reactive Global State (RGS) implements enterprise-grade security including AES-256-GCM encryption, RBAC, and internal XSS sanitization as a secondary defense layer.
-
-## Reporting a Vulnerability
-
-Please email [@passariello](https://github.com/passariello) or see <https://dario.passariello.ca/contact/> if you have a potential security vulnerability to report.
-
-## Recent Hardening
-
-- Improved XSS sanitization patterns to block `data:`, `vbscript:`, and complex HTML tag combinations.
-- Implemented removal of HTML entity obfuscation.
-- Enhanced deep cloning to support `Map`/`Set` and circular references.

package/advanced.d.ts

@@ -1,9 +0,0 @@
-import { createStore, StorageAdapters } from "./core/store";
-import type { IStore, StoreConfig, PersistOptions, CustomStorage } from "./core/types";
-import * as Security from "./core/security";
-export declare const createStoreWithStorage: <S extends Record<string, unknown>>(storage: CustomStorage, config?: StoreConfig<S>) => IStore<S>;
-export declare const createMemoryStore: <S extends Record<string, unknown>>(config?: StoreConfig<S>) => IStore<S>;
-export declare const createSessionStore: <S extends Record<string, unknown>>(config?: StoreConfig<S>) => IStore<S> | null;
-export { createStore, StorageAdapters, Security };
-export type { IStore, StoreConfig, PersistOptions, CustomStorage };
-export type { EncryptionKey, AuditEntry, Permission, AccessRule, ConsentRecord } from "./core/security";

package/core/advanced.d.ts

@@ -1,5 +0,0 @@
-export { createAsyncStore } from "./async";
-export { StorageAdapters } from "./store";
-export { syncPlugin as SyncPlugin } from "../plugins/official/sync.plugin";
-export { analyticsPlugin as AnalyticsPlugin } from "../plugins/official/analytics.plugin";
-export type { AsyncState, Middleware, IPlugin, PluginContext } from "./types";

package/core/async.d.ts

@@ -1,8 +0,0 @@
-import type { IStore, AsyncState } from "./types";
-export declare const createAsyncStore: <T>(resolver: () => Promise<T>, options?: {
-    key?: string;
-    persist?: boolean;
-    store?: IStore<Record<string, AsyncState<T>>>;
-}) => IStore<Record<string, AsyncState<T>>> & {
-    execute: () => Promise<void>;
-};

package/core/hooks.d.ts

@@ -1,17 +0,0 @@
-import type { IStore, StoreConfig, PersistOptions, StateUpdater } from "./types";
-import { SyncEngine, SyncConfig, SyncState } from "./sync";
-export declare const initState: <S extends Record<string, unknown>>(config?: StoreConfig<S>) => IStore<S>;
-export declare const destroyState: () => void;
-export declare const useIsStoreReady: (store?: IStore<Record<string, unknown>>) => boolean;
-export declare const getStore: () => IStore<Record<string, unknown>> | null;
-export declare function useStore<T, S extends Record<string, unknown> = Record<string, unknown>>(selector: (state: S) => T, store?: IStore<S>): T;
-export declare function useStore<T = unknown, S extends Record<string, unknown> = Record<string, unknown>>(key: string, store?: IStore<S>): readonly [T | undefined, (val: T | StateUpdater<T>, options?: PersistOptions) => boolean];
-export declare const initSync: (store: IStore<Record<string, unknown>>, config: SyncConfig) => SyncEngine<Record<string, unknown>>;
-export declare const destroySync: (namespace: string) => void;
-export declare function useSyncedState<T = unknown>(key: string, store?: IStore<Record<string, unknown>>): readonly [
-    T | undefined,
-    (val: T | StateUpdater<T>, options?: PersistOptions) => boolean,
-    SyncState
-];
-export declare const useSyncStatus: () => SyncState;
-export declare const triggerSync: (namespace?: string) => Promise<void>;

package/core/persistence.d.ts

@@ -1,23 +0,0 @@
-import { StorageAdapters } from "./store";
-import * as Security from "./security";
-import type { StoreConfig, PersistOptions } from "./types";
-export interface PersistenceContext {
-    store: Map<string, unknown>;
-    versions: Map<string, number>;
-    sizes: Map<string, number>;
-    totalSize: number;
-    storage: ReturnType<typeof StorageAdapters.local>;
-    config: StoreConfig<Record<string, unknown>>;
-    diskQueue: Map<string, {
-        value: unknown;
-        options: PersistOptions;
-    }>;
-    encryptionKey: Security.EncryptionKey | null;
-    audit: (action: 'set' | 'get' | 'delete' | 'hydrate', key: string, success: boolean, error?: string) => void;
-    onError?: (error: Error, metadata?: Record<string, unknown>) => void;
-    silent: boolean;
-    debounceTime: number;
-    currentVersion: number;
-}
-export declare const flushDisk: (ctx: PersistenceContext) => Promise<void>;
-export declare const hydrateStore: (ctx: PersistenceContext, calculateSize: (val: unknown) => number, emit: () => void) => Promise<void>;

package/core/plugins.d.ts

@@ -1,8 +0,0 @@
-import { IStore, PluginHookName, PluginContext, IPlugin } from "./types";
-export interface PluginManagerContext<S extends Record<string, unknown>> {
-    plugins: Map<string, IPlugin<S>>;
-    onError?: (error: Error, metadata?: Record<string, unknown>) => void;
-    silent: boolean;
-}
-export declare const runHook: <S extends Record<string, unknown>>(ctx: PluginManagerContext<S>, name: PluginHookName, hookContext: PluginContext<S>) => void;
-export declare const installPlugin: <S extends Record<string, unknown>>(ctx: PluginManagerContext<S>, plugin: IPlugin<S>, storeInstance: IStore<S>) => void;

package/core/reactivity.d.ts

@@ -1,19 +0,0 @@
-import { ComputedSelector, WatcherCallback, StoreSubscriber } from "./types";
-export interface ReactivityContext {
-    computed: Map<string, {
-        selector: ComputedSelector<unknown>;
-        lastValue: unknown;
-        deps: Set<string>;
-    }>;
-    computedDeps: Map<string, Set<string>>;
-    watchers: Map<string, Set<WatcherCallback<unknown>>>;
-    listeners: Set<StoreSubscriber>;
-    keyListeners: Map<string, Set<StoreSubscriber>>;
-    versions: Map<string, number>;
-    storeInstance: unknown;
-    immer: boolean;
-    onError?: (error: Error, metadata?: Record<string, unknown>) => void;
-    silent: boolean;
-}
-export declare const updateComputed: (ctx: ReactivityContext, key: string, emit: (k?: string) => void) => void;
-export declare const emitChange: (ctx: ReactivityContext, changedKey?: string, isTransaction?: boolean, setPendingEmit?: (v: boolean) => void, emit?: (k?: string) => void) => void;

package/core/security.d.ts

@@ -1,54 +0,0 @@
-export declare const isCryptoAvailable: boolean;
-export interface EncryptionKey {
-    key: CryptoKey;
-    iv: Uint8Array;
-}
-export declare const generateEncryptionKey: () => Promise<EncryptionKey>;
-export declare const exportKey: (encryptionKey: EncryptionKey) => Promise<{
-    key: string;
-    iv: string;
-}>;
-export declare const importKey: (keyData: string, ivData: string) => Promise<EncryptionKey>;
-export declare const encrypt: (data: unknown, encryptionKey: EncryptionKey) => Promise<string>;
-export declare const decrypt: <T>(encryptedData: string, encryptionKey: EncryptionKey) => Promise<T>;
-export interface AuditEntry {
-    timestamp: number;
-    action: 'set' | 'get' | 'delete' | 'hydrate';
-    key: string;
-    userId?: string;
-    success: boolean;
-    error?: string;
-}
-export declare const setAuditLogger: (logger: (entry: AuditEntry) => void) => void;
-export declare const isAuditActive: () => boolean;
-export declare const logAudit: (entry: AuditEntry) => void;
-export type Permission = 'read' | 'write' | 'delete' | 'admin';
-export interface AccessRule {
-    pattern: string | ((key: string, userId?: string) => boolean);
-    permissions: Permission[];
-}
-export type AccessRulesMap = Map<string | ((key: string, userId?: string) => boolean), Permission[]>;
-export declare const addAccessRule: (rules: AccessRulesMap, pattern: string | ((key: string, userId?: string) => boolean), perms: Permission[]) => void;
-export declare const hasPermission: (rules: AccessRulesMap, key: string, action: Permission, _userId?: string) => boolean;
-export declare const sanitizeValue: (value: unknown) => unknown;
-export declare const validateKey: (key: string) => boolean;
-export interface ConsentRecord {
-    id: string;
-    purpose: string;
-    granted: boolean;
-    timestamp: number;
-}
-export type ConsentsMap = Map<string, ConsentRecord[]>;
-export declare const recordConsent: (consents: ConsentsMap, userId: string, purpose: string, granted: boolean) => ConsentRecord;
-export declare const hasConsent: (consents: ConsentsMap, userId: string, purpose: string) => boolean;
-export declare const revokeConsent: (consents: ConsentsMap, userId: string, purpose: string) => ConsentRecord | null;
-export declare const getConsents: (consents: ConsentsMap, userId: string) => ConsentRecord[];
-export declare const exportUserData: (consents: ConsentsMap, userId: string) => {
-    userId: string;
-    exportedAt: number;
-    consents: ConsentRecord[];
-};
-export declare const deleteUserData: (consents: ConsentsMap, userId: string) => {
-    success: boolean;
-    deletedConsents: number;
-};

package/core/store.d.ts

@@ -1,7 +0,0 @@
-import type { IStore, StoreConfig, CustomStorage } from './types';
-export declare const StorageAdapters: {
-    local: () => CustomStorage | null;
-    session: () => CustomStorage | null;
-    memory: () => CustomStorage;
-};
-export declare const createStore: <S extends Record<string, unknown> = Record<string, unknown>>(config?: StoreConfig<S>) => IStore<S>;

package/core/sync.d.ts

@@ -1,75 +0,0 @@
-import { IStore } from "./types";
-export type SyncStrategy = 'last-write-wins' | 'merge' | 'crdt' | 'server-wins' | 'client-wins';
-export interface SyncConfig {
-    endpoint: string;
-    authToken?: string;
-    strategy?: SyncStrategy;
-    autoSyncInterval?: number;
-    syncOnReconnect?: boolean;
-    debounceTime?: number;
-    fetch?: typeof fetch;
-    onSync?: (result: SyncResult) => void;
-    onConflict?: (conflict: ConflictInfo) => ConflictResolution;
-    maxRetries?: number;
-}
-export interface SyncResult {
-    success: boolean;
-    syncedKeys: string[];
-    conflicts: ConflictInfo[];
-    errors: string[];
-    timestamp: number;
-    duration: number;
-}
-export interface ConflictInfo {
-    key: string;
-    localValue: unknown;
-    remoteValue: unknown;
-    localVersion: number;
-    remoteVersion: number;
-    timestamp: number;
-}
-export type ConflictResolution = {
-    action: 'accept-local';
-} | {
-    action: 'accept-remote';
-} | {
-    action: 'merge';
-    value: unknown;
-} | {
-    action: 'discard';
-};
-export interface SyncState {
-    isOnline: boolean;
-    isSyncing: boolean;
-    lastSyncTimestamp: number | null;
-    pendingChanges: number;
-    conflicts: number;
-}
-export declare class SyncEngine<S extends Record<string, unknown> = Record<string, unknown>> {
-    private store;
-    private config;
-    private pendingQueue;
-    private remoteVersions;
-    private syncTimer;
-    private onlineStatusListeners;
-    private syncStateListeners;
-    private _isOnline;
-    private _isSyncing;
-    constructor(store: IStore<S>, config: SyncConfig);
-    private _setupOnlineListener;
-    private _setupStoreListener;
-    private _startAutoSync;
-    private _notifyOnlineChange;
-    private _notifyStateChange;
-    queueChange(key: string, value: unknown): void;
-    sync(): Promise<SyncResult>;
-    private _fetchRemoteVersions;
-    private _pushChange;
-    private _resolveConflict;
-    getState(): SyncState;
-    onOnlineChange(callback: (online: boolean) => void): () => void;
-    onStateChange(callback: (state: SyncState) => void): () => void;
-    flush(): Promise<SyncResult>;
-    destroy(): void;
-}
-export declare const createSyncEngine: <S extends Record<string, unknown>>(store: IStore<S>, config: SyncConfig) => SyncEngine<S>;

package/core/types.d.ts

@@ -1,164 +0,0 @@
-import type { EncryptionKey, AuditEntry, Permission, AccessRule } from './security';
-import type { SyncConfig } from './sync';
-export interface PersistOptions {
-    persist?: boolean;
-    secure?: boolean;
-    encoded?: boolean;
-    encrypted?: boolean;
-    ttl?: number;
-}
-export interface StoreMetadata {
-    version: number;
-    lastUpdated: number;
-}
-export type StoreSubscriber = () => void;
-export type Middleware<T = unknown> = (key: string, value: T, meta: StoreMetadata) => void;
-export type StateUpdater<T> = (draft: T) => void | T;
-export type ComputedSelector<T> = (get: <V>(key: string) => V | null) => T;
-export type WatcherCallback<T> = (value: T | null) => void;
-export interface PluginMethod<T = unknown> {
-    (...args: unknown[]): T;
-}
-export type PluginMethods<T extends Record<string, PluginMethod>> = T;
-export type PluginHookName = 'onInit' | 'onInstall' | 'onSet' | 'onGet' | 'onRemove' | 'onDestroy' | 'onTransaction' | 'onBeforeSet' | 'onAfterSet';
-export interface PluginContext<S extends Record<string, unknown> = Record<string, unknown>> {
-    store: IStore<S>;
-    key?: string;
-    value?: unknown;
-    version?: number;
-}
-export interface IPlugin<S extends Record<string, unknown> = Record<string, unknown>> {
-    name: string;
-    hooks: {
-        [K in PluginHookName]?: (context: PluginContext<S>) => void | Promise<void>;
-    };
-}
-export declare const createTypedPlugin: <T extends Record<string, PluginMethod>>(name: string, methods: T) => IPlugin & {
-    methods: T;
-};
-export interface IStore<S extends Record<string, unknown> = Record<string, unknown>> {
-    set<K extends keyof S>(key: K, valOrUp: S[K] | StateUpdater<S[K]>, options?: PersistOptions): boolean;
-    get<K extends keyof S>(key: K): S[K] | null;
-    set<T = unknown>(key: string, valOrUp: T | StateUpdater<T>, options?: PersistOptions): boolean;
-    get<T = unknown>(key: string): T | null;
-    compute<T = unknown>(key: string, selector: ComputedSelector<T>): T;
-    watch<K extends keyof S>(key: K, callback: WatcherCallback<S[K]>): () => void;
-    watch<T = unknown>(key: string, callback: WatcherCallback<T>): () => void;
-    remove(key: keyof S | string): boolean;
-    delete(key: keyof S | string): boolean;
-    deleteAll(): boolean;
-    list(): Record<string, unknown>;
-    use(m: Middleware): void;
-    transaction(fn: () => void): void;
-    destroy(): void;
-    _addPlugin(plugin: IPlugin<S>): void;
-    _removePlugin(name: string): void;
-    _subscribe(cb: StoreSubscriber, key?: string): () => void;
-    _getVersion(key: string): number;
-    _setSilently(key: string, value: unknown): void;
-    _registerMethod(pluginName: string, methodName: string, fn: (...args: unknown[]) => unknown): void;
-    getSnapshot(): S;
-    addAccessRule(pattern: string | ((key: string, userId?: string) => boolean), permissions: Permission[]): void;
-    hasPermission(key: string, action: Permission, userId?: string): boolean;
-    recordConsent(userId: string, purpose: string, granted: boolean): import('./security').ConsentRecord;
-    hasConsent(userId: string, purpose: string): boolean;
-    getConsents(userId: string): import('./security').ConsentRecord[];
-    revokeConsent(userId: string, purpose: string): import('./security').ConsentRecord | null;
-    exportUserData(userId: string): {
-        userId: string;
-        exportedAt: number;
-        consents: import('./security').ConsentRecord[];
-    };
-    deleteUserData(userId: string): {
-        success: boolean;
-        deletedConsents: number;
-    };
-    readonly isReady: boolean;
-    readonly namespace: string;
-    readonly userId?: string;
-    whenReady(): Promise<void>;
-    readonly plugins: GStatePlugins;
-}
-export interface GStatePlugins {
-    security: {
-        addAccessRule: (pattern: string | ((key: string, userId?: string) => boolean), permissions: Permission[]) => void;
-        recordConsent: (userId: string, purpose: string, granted: boolean) => import('./security').ConsentRecord;
-        hasConsent: (userId: string, purpose: string) => boolean;
-        getConsents: (userId: string) => import('./security').ConsentRecord[];
-        revokeConsent: (userId: string, purpose: string) => import('./security').ConsentRecord | null;
-        exportUserData: (userId: string) => {
-            userId: string;
-            exportedAt: number;
-            consents: import('./security').ConsentRecord[];
-        };
-        deleteUserData: (userId: string) => {
-            success: boolean;
-            deletedConsents: number;
-        };
-    };
-    undoRedo: {
-        undo: () => boolean;
-        redo: () => boolean;
-        canUndo: () => boolean;
-        canRedo: () => boolean;
-    };
-    immer: {
-        setWithProduce: <T>(key: string, updater: (draft: T) => void) => boolean;
-    };
-    cloudSync: {
-        sync: () => Promise<{
-            status: string;
-            stats: import('../plugins/official/cloud-sync.plugin').SyncStats;
-        }>;
-        getStats: () => import('../plugins/official/cloud-sync.plugin').SyncStats;
-    };
-    sync: {
-        flush: () => Promise<import('../core/sync').SyncResult>;
-        getState: () => import('../core/sync').SyncState;
-        onStateChange: (callback: (state: import('../core/sync').SyncState) => void) => () => void;
-    };
-    logger: Record<string, never>;
-    [key: string]: unknown;
-}
-export interface StoreConfig<S extends Record<string, unknown> = Record<string, unknown>> {
-    namespace?: string;
-    version?: number;
-    silent?: boolean;
-    debounceTime?: number;
-    storage?: CustomStorage | Storage;
-    migrate?: (oldState: Record<string, unknown>, oldVersion: number) => S;
-    persistByDefault?: boolean;
-    persistence?: boolean;
-    persist?: boolean;
-    onError?: (error: Error, context: {
-        operation: string;
-        key?: string;
-    }) => void;
-    maxObjectSize?: number;
-    maxTotalSize?: number;
-    encryptionKey?: EncryptionKey;
-    auditEnabled?: boolean;
-    userId?: string;
-    validateInput?: boolean;
-    encoded?: boolean;
-    accessRules?: Array<{
-        pattern: string | ((key: string, userId?: string) => boolean);
-        permissions: Permission[];
-    }>;
-    immer?: boolean;
-    sync?: SyncConfig;
-}
-export interface CustomStorage {
-    getItem(key: string): string | null;
-    setItem(key: string, value: string): void;
-    removeItem(key: string): void;
-    key(index: number): string | null;
-    length: number;
-}
-export interface AsyncState<T> {
-    data: T | null;
-    loading: boolean;
-    error: Error | null;
-    updatedAt: number | null;
-}
-export type { EncryptionKey, AuditEntry, Permission, AccessRule };

package/core/utils.d.ts

@@ -1,2 +0,0 @@
-export declare const deepClone: <T>(obj: T) => T;
-export declare const isEqual: (a: unknown, b: unknown) => boolean;