@biglogic/rgs 2.7.0

package/dist/CODEOWNERS

@@ -0,0 +1 @@
+* @passariello

package/dist/CONTRIBUTING.md

@@ -0,0 +1,65 @@
+# Contributing to RGS (Argis) - React Globo State
+
+Thank you for your interest in contributing!
+
+## Development Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/dpassariello/rgs.git
+cd rgs
+
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Run linter
+npm run lint
+
+# Build
+npm run build
+```
+
+## Code Style
+
+- Use TypeScript with strict mode
+- Follow ESLint rules
+- Add JSDoc comments for public APIs
+- Write tests for new features
+
+## Testing
+
+```bash
+# Run all tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run e2e tests
+npm run test:e2e
+```
+
+## Pull Request Process
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Ensure tests pass: `npm test`
+5. Ensure linting passes: `npm run lint`
+6. Commit your changes
+7. Push to your fork
+8. Open a Pull Request
+
+## Release Process
+
+1. Update version in `package.json`
+2. Update CHANGELOG.md
+3. Create a release on GitHub
+4. NPM publish happens automatically via CI/CD
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the MIT License.

package/dist/COPYRIGHT.md

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

package/dist/LICENSE

@@ -0,0 +1,9 @@
+# MIT license
+
+Copyright 1995 - 2026 Dario Passariello
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/README.md

@@ -0,0 +1,267 @@
+# Argis (RGS) - React Globo State "The Magnetar"
+
+> **Atomic Precision. Immutable Safety. Zen Simplicity.**
+> The most powerful state management engine for React. Built for those who demand industrial-grade reliability with a zero-boilerplate experience.
+
+[![npm version](https://badge.fury.io/js/rgs.svg)](https://badge.fury.io/js/rgs)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## 🌟 Why Magnetar?
+
+We took the simplicity of **React Globo State (RGS)** and fused it with the architecture of a **High-Performance Kernel**. It's the only library that gives you:
+
+- **💎 Absolute Immutability**: Powered by **Immer**. No more manual spreads. State is frozen by default.
+- **🛡️ Industrial-Grade Safety**: Deep Proxy guards that throw `Forbidden Mutation` errors if you try to bypass the kernel.
+- **🔌 Enterprise Ecosystem**: A real plugin architecture with 10+ official modules (Sync, Storage, DevTools, etc.).
+- **⚛️ Power on Demand**: Advanced async and persistence tools isolated in the `advanced` export.
+- **🏗️ Stellar Architecture**: Zero circular dependencies. Modular, clean, and 100% type-safe.
+
+---
+
+## gState vs useState
+
+| Feature | useState | gState |
+|---------|----------|--------|
+| **State globale tra componenti** | ❌ Servono Context/props | ✅ Condivisione automatica |
+| **Provider wrapper** | ❌ Necessario | ✅ Non serve |
+| **Persistenza (localStorage)** | ❌ Manuale | ✅ Built-in |
+| **Crittografia dati** | ❌ | ✅ AES-256-GCM |
+| **Namespace/stores multipli** | ❌ | ✅ |
+| **Plugin (Immer, Undo/Redo)** | ❌ | ✅ |
+| **Audit logging** | ❌ | ✅ |
+| **RBAC/GDPR consent** | ❌ | ✅ |
+| **SSR/Hydration** | ❌ Manuale | ✅ Automatico |
+| **Computed values** | ❌ | ✅ |
+
+### Quando usare cosa?
+
+- **useState**: UI locale, un componente, state temporaneo
+- **gState**:
+  - State condiviso tra più componenti
+  - Dati persistenti (preferenze, carrello, autenticazione)
+  - Dati sensibili (crittografia)
+  - Feature advanced (undo/redo, snapshots)
+  - Enterprise (audit, RBAC, GDPR)
+
+---
+
+## 🏗️ Architecture
+
+```mermaid
+graph TB
+    subgraph API
+        A[gstate] --> D[IStore]
+        B[useStore] --> D
+        C[createStore] --> D
+    end
+
+    D --> E[Storage Adapter]
+    D --> F[Immer Proxy]
+    D --> G[Plugins]
+    D --> H[Security]
+    D --> I[Async Store]
+
+    E --> J[local]
+    E --> K[session]
+    E --> L[memory]
+
+    G --> M[UndoRedo]
+    G --> N[Sync]
+    G --> O[Schema]
+    G --> P[Analytics]
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                        React Globo State                        │
+│                         "The Magnetar"                          │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+        ┌─────────────────────┼─────────────────────┐
+        ▼                     ▼                     ▼
+┌───────────────┐    ┌───────────────┐    ┌───────────────┐
+│   gstate()    │    │  useStore()   │    │ createStore() │
+│  (One-liner)  │    │   (Hook)      │    │   (Classic)   │
+└───────┬───────┘    └───────┬───────┘    └───────┬───────┘
+        │                    │                    │
+        └────────────────────┼────────────────────┘
+                             ▼
+                    ┌────────────────┐
+                    │   IStore       │
+                    │  (Core API)    │
+                    └────────┬───────┘
+                             │
+     ┌──────────┬───────────┼───────────┬──────────┐
+     ▼          ▼           ▼           ▼          ▼
+┌─────────┐ ┌─────────┐ ┌──────────┐ ┌────────┐ ┌─────────┐
+│ Storage │ │Immer    │ │ Plugins  │ │Security│ │ Async  │
+│Adapter  │ │Proxy    │ │ System   │ │ Layer  │ │ Store  │
+└────┬────┘ └────┬────┘ └────┬─────┘ └───┬────┘ └───┬────┘
+     │           │           │            │          │
+     ▼           ▼           ▼            ▼          ▼
+  local    ┌─────────┐   ┌──────┐   ┌─────────┐  ┌──────┐
+  session  │Frozen   │   │Add   │   │AES-256  │  │Fetch │
+  memory   │State    │   │Hooks │   │Encryption│  │+Loading│
+           └─────────┘   └──────┘   └─────────┘  │Error  │
+                                                  └──────┘
+```
+
+### Core Components
+
+| Component | Description |
+|-----------|-------------|
+| **gstate()** | Creates store + hook in one line |
+| **useStore()** | React hook for subscribing to state |
+| **createStore()** | Classic store factory |
+| **IStore** | Core interface with get/set/subscribe |
+| **StorageAdapters** | local, session, memory persistence |
+| **Plugins** | Immer, Undo/Redo, Sync, Schema, etc. |
+| **Security** | Encryption, RBAC, GDPR consent |
+
+---
+
+## Requirements
+
+- **React 16.8+** (for hooks support)
+- **React DOM**
+
+## ⚡ Zero-Boilerplate Quickstart
+
+### Path A: The Zen Way (Modular)
+
+Best for modern applications. Clean imports, zero global pollution.
+
+```tsx
+import { gstate } from 'argis'
+
+// Create store and hook in one line
+const useCounter = gstate({ count: 0 })
+
+// In your component
+const [count, setCount] = useCounter('count')
+```
+
+### Path B: The Classic Way (Global)
+
+Best for shared state across the entire application.
+
+```tsx
+// 1. Initialize once
+import { initState } from 'argis'
+initState({ namespace: 'app' })
+
+// 2. Use anywhere
+const [user, setUser] = useStore('user')
+```
+
+---
+
+## 📚 Quick Examples
+
+### Persistence
+
+```tsx
+const store = gstate({ theme: 'dark' }, { persist: true })
+```
+
+### Encryption
+
+```tsx
+const secureStore = gstate({ token: 'xxx' }, { encoded: true })
+```
+
+### Undo/Redo
+
+```tsx
+const store = gstate({ count: 0 })
+store._addPlugin(undoRedoPlugin({ limit: 50 }))
+
+store.undo()
+store.redo()
+```
+
+### Cross-Tab Sync
+
+```tsx
+const store = gstate({ theme: 'light' })
+store._addPlugin(syncPlugin({ channelName: 'my-app' }))
+```
+
+### Computed Values
+
+```tsx
+const store = gstate({ firstName: 'John', lastName: 'Doe' })
+store.compute('fullName', ['firstName', 'lastName'],
+  (s) => `${s.firstName} ${s.lastName}`)
+
+const [fullName] = store('fullName') // "John Doe"
+```
+
+---
+
+## Multiple Stores
+
+You can create multiple independent stores using namespaces:
+
+```tsx
+// Option 1: gstate with namespace
+const userStore = gstate({ name: 'John' }, { namespace: 'users' })
+const appStore = gstate({ theme: 'dark' }, { namespace: 'app' })
+
+// In components - same key, different stores
+const [name] = userStore('name')     // 'John'
+const [theme] = appStore('theme')    // 'dark'
+
+// Option 2: initState + useStore (global default store)
+initState({ namespace: 'global' })
+const [value, setValue] = useStore('key')
+```
+
+**Tip**: Keys are unique per-namespace, so you can use the same key name in different stores.
+
+## 🚀 Advanced Superpowers
+
+### 🔌 Official Plugin Ecosystem
+
+Extend the core functionality dynamically with specialized modules.
+
+1. **ImmerPlugin**: Adds `setWithProduce` for functional updates.
+2. **UndoRedoPlugin**: Multi-level history management.
+3. **PersistencePlugin**: Advanced storage with custom serialization.
+4. **SyncPlugin**: Cross-tab state synchronization via BroadcastChannel.
+5. **SchemaPlugin**: Runtime validation (perfect for Zod).
+6. **DevToolsPlugin**: Redux DevTools integration.
+7. **TTLPlugin**: Time-to-live management.
+8. **AnalyticsPlugin**: Tracking bridge for metrics.
+9. **SnapshotPlugin**: Manual state checkpointing.
+10. **GuardPlugin**: Data transformation layer.
+
+```typescript
+import { createStore, PersistencePlugin, undoRedoPlugin } from 'argis'
+
+const store = createStore()
+store._addPlugin(PersistencePlugin({ storage: 'localStorage' }))
+store._addPlugin(undoRedoPlugin({ limit: 50 }))
+
+// Undo like a pro
+store.undo()
+```
+
+### 🔬 Power Tools (Import from `rgs/advanced`)
+
+Need the heavy artillery? We've got you covered.
+
+- `createAsyncStore(fetcher)`: Atomic async state management.
+- `StorageAdapters`: High-level interfaces for any storage engine.
+- `Middleware / IPlugin`: Build your own extensions.
+
+---
+
+## 📄 License
+
+MIT © [Dario Passariello](https://github.com/dpassariello)
+
+---
+
+**Designed for those who build the future.**
+Made with ❤️ and a lot of caffe' espresso!

package/dist/SECURITY.md

@@ -0,0 +1,3 @@
+# Security
+
+Please email [@passariello](https://github.com/passariello) or see <https://dario.passariello.ca/contact/> if you have a potential security vulnerability to report.

package/dist/advanced.d.ts

@@ -0,0 +1,9 @@
+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/dist/advanced.js

@@ -0,0 +1 @@
+import{createStore as o,StorageAdapters as r}from"./core/store";import*as s from"./core/security";const S=(e,t)=>o({...t,storage:e}),i=e=>o({...e,storage:r.memory()}),c=e=>{const t=r.session();return t?o({...e,storage:t}):null};export{s as Security,r as StorageAdapters,i as createMemoryStore,c as createSessionStore,o as createStore,S as createStoreWithStorage};

package/dist/core/advanced.d.ts

@@ -0,0 +1,5 @@
+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/dist/core/async.d.ts

@@ -0,0 +1,8 @@
+import type { IStore, AsyncState } from "../core/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/dist/core/hooks.d.ts

@@ -0,0 +1,8 @@
+import type { IStore, StoreConfig, PersistOptions, StateUpdater } from "./types";
+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 const 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 useGState: <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 useSimpleState: <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];

package/dist/core/security.d.ts

@@ -0,0 +1,54 @@
+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/dist/core/store.d.ts

@@ -0,0 +1,7 @@
+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/dist/core/types.d.ts

@@ -0,0 +1,134 @@
+import type { EncryptionKey, AuditEntry, Permission, AccessRule } from './security';
+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(name: string, fn: (...args: unknown[]) => unknown): void;
+    _registerMethod(pluginName: string, methodName: string, fn: (...args: unknown[]) => unknown): void;
+    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;
+    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;
+        };
+    };
+    [key: string]: Record<string, (...args: any[]) => any>;
+}
+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;
+    onError?: (error: Error, context: {
+        operation: string;
+        key?: string;
+    }) => void;
+    maxObjectSize?: number;
+    maxTotalSize?: number;
+    encryptionKey?: EncryptionKey;
+    auditEnabled?: boolean;
+    userId?: string;
+    validateInput?: boolean;
+    accessRules?: Array<{
+        pattern: string | ((key: string, userId?: string) => boolean);
+        permissions: Permission[];
+    }>;
+    immer?: boolean;
+}
+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/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { createStore as baseCreateStore } from "./core/store";
+import { useStore as baseUseStore } from "./core/hooks";
+import * as Security from "./core/security";
+import type { IStore, StoreConfig } from "./core/types";
+export declare const gstate: <S extends Record<string, unknown>>(initialState: S, configOrNamespace?: string | StoreConfig<S>) => IStore<S> & ((key: string) => unknown);
+export { baseCreateStore as createStore };
+export { useStore, useIsStoreReady, initState, destroyState, useStore as useGState, useStore as useSimpleState } from "./core/hooks";
+export { createAsyncStore } from "./core/async";
+export * from "./plugins/index";
+export { generateEncryptionKey, exportKey, importKey, isCryptoAvailable, setAuditLogger, logAudit, validateKey, sanitizeValue } from "./core/security";
+export declare const addAccessRule: (pattern: string | ((key: string, userId?: string) => boolean), perms: Security.Permission[]) => void | undefined;
+export declare const hasPermission: (key: string, action: Security.Permission, uid?: string) => boolean;
+export declare const recordConsent: (uid: string, p: string, g: boolean) => Security.ConsentRecord;
+export declare const hasConsent: (uid: string, p: string) => boolean;
+export declare const getConsents: (uid: string) => Security.ConsentRecord[];
+export declare const revokeConsent: (uid: string, p: string) => Security.ConsentRecord | null | undefined;
+export declare const exportUserData: (uid: string) => {
+    userId: string;
+    exportedAt: number;
+    consents: import("./core/security").ConsentRecord[];
+};
+export declare const deleteUserData: (uid: string) => {
+    success: boolean;
+    deletedConsents: number;
+};
+export declare const clearAccessRules: () => void;
+export declare const clearAllConsents: () => void;
+export type { EncryptionKey, AuditEntry, Permission, AccessRule, ConsentRecord } from "./core/security";
+export type { IStore, StoreConfig, PersistOptions, StateUpdater, ComputedSelector, WatcherCallback } from "./core/types";
+declare global {
+    var createStore: typeof baseCreateStore;
+    var gstate: <S extends Record<string, unknown>>(initialState: S, configOrNamespace?: string | StoreConfig<S>) => IStore<S> & ((key: string) => unknown);
+    var initState: typeof import("./core/hooks").initState;
+    var destroyState: typeof import("./core/hooks").destroyState;
+    var gState: IStore<Record<string, unknown>>;
+    var useStore: typeof baseUseStore;
+}

package/dist/index.js

@@ -0,0 +1 @@
+import{createStore as i}from"./core/store";import{useStore as c,getStore as r}from"./core/hooks";import"./core/security";import{useStore as R,useIsStoreReady as U,initState as E,destroyState as I,useStore as D,useStore as P}from"./core/hooks";import{createAsyncStore as j}from"./core/async";export*from"./plugins/index";import{generateEncryptionKey as z,exportKey as G,importKey as L,isCryptoAvailable as V,setAuditLogger as W,logAudit as _,validateKey as q,sanitizeValue as B}from"./core/security";const d=(t,e)=>{const o=i(typeof e=="string"?{namespace:e}:e);return t&&Object.entries(t).forEach(([n,a])=>{o._setSilently(n,a)}),Object.assign(n=>c(n,o),o)};const f=(t,e)=>r()?.addAccessRule(t,e),l=(t,e,s)=>r()?.hasPermission(t,e,s)??!0,y=(t,e,s)=>{const o=r();if(!o)throw new Error("[gState] recordConsent failed: No store found. call initState() first.");return o.recordConsent(t,e,s)},m=(t,e)=>r()?.hasConsent(t,e)??!1,x=t=>r()?.getConsents(t)??[],C=(t,e)=>r()?.revokeConsent(t,e),k=t=>{const e=r();if(!e)throw new Error("[gState] exportUserData failed: No store found.");return e.exportUserData(t)},b=t=>{const e=r();if(!e)throw new Error("[gState] deleteUserData failed: No store found.");return e.deleteUserData(t)},h=()=>{},w=()=>{};export{f as addAccessRule,h as clearAccessRules,w as clearAllConsents,j as createAsyncStore,i as createStore,b as deleteUserData,I as destroyState,G as exportKey,k as exportUserData,z as generateEncryptionKey,x as getConsents,d as gstate,m as hasConsent,l as hasPermission,L as importKey,E as initState,V as isCryptoAvailable,_ as logAudit,y as recordConsent,C as revokeConsent,B as sanitizeValue,W as setAuditLogger,D as useGState,U as useIsStoreReady,P as useSimpleState,R as useStore,q as validateKey};