localspace 0.2.2 → 0.3.0

package/README.md

@@ -57,20 +57,18 @@ localspace is built on a foundation designed for growth. Here's what's planned:
 - [x] **Improved error handling** - Structured error types with detailed context
 
 ### TODO
-- [ ] **Plugin system** - Middleware architecture for cross-cutting concerns
-- [ ] **Cache API driver** - Native browser caching with automatic HTTP semantics
+- [x] **Plugin system** - Middleware architecture for cross-cutting concerns
 - [ ] **OPFS driver** - Origin Private File System for high-performance file storage
-- [ ] **Memory driver** - In-memory storage for testing and SSR
 - [ ] **Custom driver templates** - Documentation and examples for third-party drivers
 - [ ] **Node.js** - File system and SQLite adapters
 - [ ] **React Native** - AsyncStorage and SQLite drivers
 - [ ] **Electron** - Main and renderer process coordination
 - [ ] **Deno** - Native KV store integration
-- [ ] **TTL plugin** - Time-to-live expiration with automatic cleanup
-- [ ] **Encryption plugin** - Transparent encryption/decryption with Web Crypto API
-- [ ] **Compression plugin** - LZ-string or Brotli compression for large values
-- [ ] **Sync plugin** - Multi-tab synchronization with BroadcastChannel
-- [ ] **Quota plugin** - Automatic quota management and cleanup strategies
+- [x] **TTL plugin** - Time-to-live expiration with automatic cleanup
+- [x] **Encryption plugin** - Transparent encryption/decryption with Web Crypto API
+- [x] **Compression plugin** - LZ-string or Brotli compression for large values
+- [x] **Sync plugin** - Multi-tab synchronization with BroadcastChannel
+- [x] **Quota plugin** - Automatic quota management and cleanup strategies
 
 ### 📊 Community Priorities
 
@@ -283,6 +281,82 @@ await localspace.setItem('file', file);
 const restored = await localspace.getItem<Blob>('file');
 ```
 
+## Plugin System
+
+localspace now ships with a first-class plugin engine. Attach middleware when creating an instance or call `use()` later; plugins can mutate payloads, observe driver context, and run async interceptors around every storage call.
+
+```ts
+const store = localspace.createInstance({
+  name: 'secure-store',
+  storeName: 'primary',
+  plugins: [
+    ttlPlugin({ defaultTTL: 60_000 }),
+    encryptionPlugin({ key: '0123456789abcdef0123456789abcdef' }),
+    compressionPlugin({ threshold: 1024 }),
+    syncPlugin({ channelName: 'localspace-sync' }),
+    quotaPlugin({ maxSize: 5 * 1024 * 1024, evictionPolicy: 'lru' }),
+  ],
+});
+```
+
+### Lifecycle and hooks
+
+- **Registration** – supply `plugins` when calling `createInstance()` or chain `instance.use(plugin)` later. Each plugin can also expose `enabled` (boolean or function) and `priority` to control execution order.
+- **Lifecycle events** – `onInit(context)` is invoked after `ready()`, and `onDestroy` lets you tear down timers or channels. Call `await instance.destroy()` when disposing of an instance to run every `onDestroy` hook (executed in reverse priority order). Context exposes the active driver, db info, config, and a shared `metadata` bag for cross-plugin coordination.
+- **Interceptors** – hook into `beforeSet/afterSet`, `beforeGet/afterGet`, `beforeRemove/afterRemove`, plus batch-specific methods such as `beforeSetItems` or `beforeGetItems`. Hooks run sequentially: `before*` hooks execute from highest to lowest priority, while `after*` hooks unwind in reverse order so layered transformations (compression → encryption → TTL) remain invertible. Returning a value passes it to the next plugin, while throwing a `LocalSpaceError` aborts the operation.
+- **Per-call state** – plugins can stash data on `context.operationState` (e.g., capture the original value in `beforeSet` and reuse it in `afterSet`). For batch operations, `context.operationState.isBatch` is `true` and `context.operationState.batchSize` provides the total count.
+- **Error handling & init policy** – unexpected exceptions are reported through `plugin.onError`. Throw a `LocalSpaceError` if you need to stop the pipeline (quota violations, failed decryptions, etc.). If a plugin `onInit` throws, the default policy is fail-fast (propagate and abort init). Set `pluginInitPolicy: 'disable-and-continue'` in config to log and skip the failing plugin instead (use with care for critical plugins like encryption).
+
+### Plugin execution order
+
+Plugins are sorted by `priority` (higher runs first in `before*`, last in `after*`). Default priorities:
+
+| Plugin | Priority | Notes |
+|--------|----------|-------|
+| sync | -100 | Runs last in `afterSet` to broadcast original (untransformed) values |
+| quota | -10 | Runs late so it measures final payload sizes |
+| ttl, encryption, compression | 0 | Default; chain in registration order |
+
+**Recommended order**: `[ttlPlugin, encryptionPlugin, compressionPlugin, syncPlugin, quotaPlugin]`
+
+### Built-in plugins
+
+#### TTL plugin
+Wraps values as `{ data, expiresAt }`, invalidates stale reads, and optionally runs background cleanup. Options:
+
+- `defaultTTL` (ms) and `keyTTL` overrides
+- `cleanupInterval` to periodically scan `iterate()` output
+- `onExpire(key, value)` callback before removal
+
+#### Encryption plugin
+Encrypts serialized payloads using the Web Crypto API (AES-GCM by default) and decrypts transparently on reads.
+
+- Provide a `key` (CryptoKey/ArrayBuffer/string) or `keyDerivation` block (PBKDF2)
+- Customize `algorithm`, `ivLength`, `ivGenerator`, or `randomSource`
+- Works in browsers and modern Node runtimes (pass your own `subtle` when needed)
+
+#### Compression plugin
+Runs LZ-string compression (or a custom codec) when payloads exceed a `threshold` and restores them on read.
+
+- `threshold` (bytes) controls when compression kicks in
+- Supply a custom `{ compress, decompress }` codec if you prefer pako/Brotli
+
+#### Sync plugin
+Keeps multiple tabs/processes in sync via `BroadcastChannel` (with `storage`-event fallback).
+
+- `channelName` separates logical buses
+- `syncKeys` lets you scope which keys broadcast
+- `conflictStrategy` defaults to `last-write-wins`; provide `onConflict` (return `false` to drop remote writes) for merge logic
+
+#### Quota plugin
+Tracks approximate storage usage after every mutation and enforces limits.
+
+- `maxSize` (bytes) and optional `useNavigatorEstimate` to read the browser’s quota
+- `evictionPolicy: 'error' | 'lru'` (LRU removes least-recently-used keys automatically)
+- `onQuotaExceeded(info)` fires before throwing so you can log/alert users
+
+> Tip: place quota plugins last so they see the final payload size after other transformations (TTL, encryption, compression, etc.).
+
 ## Migration Guide
 
 ### Note differences from localForage before upgrading
@@ -325,6 +399,7 @@ localspace.setItem('key', 'value', (err, value) => {
 
 ## Performance notes
 - **Automatic write coalescing (enabled by default):** localspace automatically merges rapid single writes (`setItem`/`removeItem`) within an 8ms window into one transaction, giving you 3-10x performance improvement with zero code changes. This is enabled by default for IndexedDB. Set `coalesceWrites: false` if you need strict per-operation durability.
+- **Read-your-writes consistency with coalescing:** Pending coalesced writes are flushed before reads (`getItem`, `getItems`, `iterate`, `keys`, `length`, `key`) and destructive ops (`clear`, `dropInstance`), so immediate reads always observe the latest value. If you need eventual reads for speed, you can switch `coalesceReadConsistency` to `'eventual'`.
 - **Batch APIs outperform loops:** Playwright benchmark (`test/playwright/benchmark.spec.ts`) on 500 items x 256B showed `setItems()` ~6x faster and `getItems()` ~7.7x faster than per-item loops, with `removeItems()` ~2.8x faster (Chromium, relaxed durability).
 - **Transaction helpers:** `runTransaction()` lets you co-locate reads/writes in a single transaction for atomic migrations and to shorten lock time.
 - **Batch sizing:** Use `maxBatchSize` to split very large batch operations (`setItems`/`removeItems`/`getItems`) and keep transaction size in check. This works independently from `coalesceWrites`, which optimizes single-item operations.
@@ -342,6 +417,8 @@ When `compatibilityMode` is off, driver setup methods also use Node-style callba
 - **Read structured errors:** Rejections surface as `LocalSpaceError` with a `code`, contextual `details` (driver, operation, key, attemptedDrivers), and the original `cause`. Branch on `error.code` instead of parsing strings.
 - **Handle quota errors:** Check for `error.code === 'QUOTA_EXCEEDED'` (or inspect `error.cause`) from `setItem` to inform users about storage limits.
 - **Run unit tests:** The project ships with Vitest and Playwright suites covering API behavior; run `yarn test` to verify changes.
+- **Collect Playwright coverage:** Run `yarn test:e2e:coverage` to re-build the bundle, execute the Playwright suite with Chromium V8 coverage enabled, and emit both text + HTML reports via `nyc` (open `coverage/index.html` after the run; raw JSON sits in `.nyc_output`).
+- **Collect combined Vitest + Playwright coverage:** Run `yarn coverage:full` to clean previous artifacts, run `vitest --coverage`, stash its Istanbul JSON into `.nyc_output`, then execute the coverage-enabled Playwright suite and emit merged `nyc` reports.
 
 ## License
 [MIT](./LICENSE)

package/dist/core/plugin-manager.d.ts

@@ -0,0 +1,48 @@
+import type { BatchItems, BatchResponse, DbInfo, LocalSpaceConfig, LocalSpaceInstance, LocalSpacePlugin, PluginContext, PluginOperation } from '../types';
+export declare class PluginAbortError extends Error {
+    constructor(message?: string);
+}
+type PluginHost = LocalSpaceInstance & {
+    _config: LocalSpaceConfig;
+    _dbInfo: DbInfo | null;
+};
+export declare class PluginManager {
+    private readonly host;
+    private readonly sharedMetadata;
+    private readonly pluginRegistry;
+    private readonly initialized;
+    private readonly initPromises;
+    private readonly destroyed;
+    private readonly disabled;
+    private orderCounter;
+    constructor(host: PluginHost, initialPlugins?: LocalSpacePlugin[]);
+    hasPlugins(): boolean;
+    registerPlugins(plugins: LocalSpacePlugin[]): void;
+    private sortPlugins;
+    private getActivePlugins;
+    ensureInitialized(): Promise<void>;
+    createContext(operation: PluginOperation | null): PluginContext;
+    beforeSet<T>(key: string, value: T, context: PluginContext): Promise<T>;
+    afterSet<T>(key: string, value: T, context: PluginContext): Promise<void>;
+    beforeGet(key: string, context: PluginContext): Promise<string>;
+    afterGet<T>(key: string, value: T | null, context: PluginContext): Promise<T | null>;
+    beforeRemove(key: string, context: PluginContext): Promise<string>;
+    afterRemove(key: string, context: PluginContext): Promise<void>;
+    beforeSetItems<T>(entries: BatchItems<T>, context: PluginContext): Promise<BatchItems<T>>;
+    afterSetItems<T>(entries: BatchResponse<T>, context: PluginContext): Promise<BatchResponse<T>>;
+    beforeGetItems(keys: string[], context: PluginContext): Promise<string[]>;
+    afterGetItems<T>(entries: BatchResponse<T>, context: PluginContext): Promise<BatchResponse<T>>;
+    beforeRemoveItems(keys: string[], context: PluginContext): Promise<string[]>;
+    afterRemoveItems(keys: string[], context: PluginContext): Promise<void>;
+    destroy(): Promise<void>;
+    normalizeBatch<T>(items: BatchItems<T>): Array<{
+        key: string;
+        value: T;
+    }>;
+    private shouldPropagate;
+    private dispatchPluginError;
+    private invokeValueHook;
+    private invokeVoidHook;
+}
+export {};
+//# sourceMappingURL=plugin-manager.d.ts.map

package/dist/core/plugin-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-manager.d.ts","sourceRoot":"","sources":["../../src/core/plugin-manager.ts"],"names":[],"mappings":"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"}

package/dist/core/plugin-manager.js

@@ -0,0 +1,334 @@
+import { LocalSpaceError } from '../errors';
+import { normalizeBatchEntries } from '../utils/helpers';
+export class PluginAbortError extends Error {
+    constructor(message = 'Plugin aborted the operation') {
+        super(message);
+        this.name = 'PluginAbortError';
+    }
+}
+const sharedMetadataFor = () => Object.create(null);
+export class PluginManager {
+    constructor(host, initialPlugins = []) {
+        Object.defineProperty(this, "host", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sharedMetadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: sharedMetadataFor()
+        });
+        Object.defineProperty(this, "pluginRegistry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new WeakSet()
+        });
+        Object.defineProperty(this, "initPromises", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new WeakMap()
+        });
+        Object.defineProperty(this, "destroyed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new WeakSet()
+        });
+        Object.defineProperty(this, "disabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new WeakSet()
+        });
+        Object.defineProperty(this, "orderCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.host = host;
+        if (initialPlugins.length) {
+            this.registerPlugins(initialPlugins);
+        }
+    }
+    hasPlugins() {
+        return this.pluginRegistry.length > 0;
+    }
+    registerPlugins(plugins) {
+        for (const plugin of plugins) {
+            if (!plugin)
+                continue;
+            this.pluginRegistry.push({ plugin, order: this.orderCounter++ });
+        }
+        this.sortPlugins();
+    }
+    sortPlugins() {
+        this.pluginRegistry.sort((a, b) => {
+            const priorityA = a.plugin.priority ?? 0;
+            const priorityB = b.plugin.priority ?? 0;
+            if (priorityA === priorityB) {
+                return a.order - b.order;
+            }
+            return priorityB - priorityA;
+        });
+    }
+    getActivePlugins(options) {
+        const reverse = options?.reverse ?? false;
+        const plugins = this.pluginRegistry
+            .map((entry) => entry.plugin)
+            .filter((plugin) => {
+            if (this.disabled.has(plugin)) {
+                return false;
+            }
+            const enabled = plugin.enabled;
+            if (typeof enabled === 'function') {
+                try {
+                    return !!enabled();
+                }
+                catch (error) {
+                    console.warn(`Plugin "${plugin.name}" enabled() check failed`, error);
+                    return false;
+                }
+            }
+            return enabled !== false;
+        });
+        return reverse ? plugins.slice().reverse() : plugins;
+    }
+    async ensureInitialized() {
+        for (const plugin of this.getActivePlugins()) {
+            if (this.initialized.has(plugin)) {
+                continue;
+            }
+            if (typeof plugin.onInit !== 'function') {
+                this.initialized.add(plugin);
+                continue;
+            }
+            const pendingInit = this.initPromises.get(plugin);
+            if (pendingInit) {
+                await pendingInit;
+                continue;
+            }
+            const context = this.createContext(null);
+            const initPromise = (async () => {
+                try {
+                    await plugin.onInit(context);
+                    this.initialized.add(plugin);
+                }
+                catch (error) {
+                    await this.dispatchPluginError(plugin, error, 'init', 'lifecycle', undefined, context);
+                    const policy = this.host._config.pluginInitPolicy ?? 'fail';
+                    if (policy === 'disable-and-continue') {
+                        this.disabled.add(plugin);
+                        return;
+                    }
+                    throw error;
+                }
+                finally {
+                    this.initPromises.delete(plugin);
+                }
+            })();
+            this.initPromises.set(plugin, initPromise);
+            await initPromise;
+        }
+    }
+    createContext(operation) {
+        return {
+            instance: this.host,
+            driver: this.host.driver ? this.host.driver() : null,
+            dbInfo: this.host._dbInfo ?? null,
+            config: this.host._config,
+            metadata: this.sharedMetadata,
+            operation,
+            operationState: Object.create(null),
+        };
+    }
+    async beforeSet(key, value, context) {
+        let current = value;
+        for (const plugin of this.getActivePlugins()) {
+            if (!plugin.beforeSet)
+                continue;
+            current = await this.invokeValueHook(plugin, () => plugin.beforeSet(key, current, context), 'before', 'setItem', key, context, current);
+        }
+        return current;
+    }
+    async afterSet(key, value, context) {
+        for (const plugin of this.getActivePlugins({ reverse: true })) {
+            if (!plugin.afterSet)
+                continue;
+            await this.invokeVoidHook(plugin, () => plugin.afterSet(key, value, context), 'after', 'setItem', key, context);
+        }
+    }
+    async beforeGet(key, context) {
+        let currentKey = key;
+        for (const plugin of this.getActivePlugins()) {
+            if (!plugin.beforeGet)
+                continue;
+            currentKey = await this.invokeValueHook(plugin, () => plugin.beforeGet(currentKey, context), 'before', 'getItem', currentKey, context, currentKey);
+        }
+        return currentKey;
+    }
+    async afterGet(key, value, context) {
+        let currentValue = value;
+        for (const plugin of this.getActivePlugins({ reverse: true })) {
+            if (!plugin.afterGet)
+                continue;
+            currentValue = await this.invokeValueHook(plugin, () => plugin.afterGet(key, currentValue, context), 'after', 'getItem', key, context, currentValue);
+        }
+        return currentValue;
+    }
+    async beforeRemove(key, context) {
+        let currentKey = key;
+        for (const plugin of this.getActivePlugins()) {
+            if (!plugin.beforeRemove)
+                continue;
+            currentKey = await this.invokeValueHook(plugin, () => plugin.beforeRemove(currentKey, context), 'before', 'removeItem', currentKey, context, currentKey);
+        }
+        return currentKey;
+    }
+    async afterRemove(key, context) {
+        for (const plugin of this.getActivePlugins({ reverse: true })) {
+            if (!plugin.afterRemove)
+                continue;
+            await this.invokeVoidHook(plugin, () => plugin.afterRemove(key, context), 'after', 'removeItem', key, context);
+        }
+    }
+    async beforeSetItems(entries, context) {
+        let current = entries;
+        for (const plugin of this.getActivePlugins()) {
+            if (!plugin.beforeSetItems)
+                continue;
+            current = await this.invokeValueHook(plugin, () => plugin.beforeSetItems(current, context), 'before', 'setItems', undefined, context, current);
+        }
+        return current;
+    }
+    async afterSetItems(entries, context) {
+        let current = entries;
+        for (const plugin of this.getActivePlugins({ reverse: true })) {
+            if (!plugin.afterSetItems)
+                continue;
+            current = await this.invokeValueHook(plugin, () => plugin.afterSetItems(current, context), 'after', 'setItems', undefined, context, current);
+        }
+        return current;
+    }
+    async beforeGetItems(keys, context) {
+        let currentKeys = keys;
+        for (const plugin of this.getActivePlugins()) {
+            if (!plugin.beforeGetItems)
+                continue;
+            currentKeys = await this.invokeValueHook(plugin, () => plugin.beforeGetItems(currentKeys, context), 'before', 'getItems', undefined, context, currentKeys);
+        }
+        return currentKeys;
+    }
+    async afterGetItems(entries, context) {
+        let current = entries;
+        for (const plugin of this.getActivePlugins({ reverse: true })) {
+            if (!plugin.afterGetItems)
+                continue;
+            current = await this.invokeValueHook(plugin, () => plugin.afterGetItems(current, context), 'after', 'getItems', undefined, context, current);
+        }
+        return current;
+    }
+    async beforeRemoveItems(keys, context) {
+        let currentKeys = keys;
+        for (const plugin of this.getActivePlugins()) {
+            if (!plugin.beforeRemoveItems)
+                continue;
+            currentKeys = await this.invokeValueHook(plugin, () => plugin.beforeRemoveItems(currentKeys, context), 'before', 'removeItems', undefined, context, currentKeys);
+        }
+        return currentKeys;
+    }
+    async afterRemoveItems(keys, context) {
+        for (const plugin of this.getActivePlugins({ reverse: true })) {
+            if (!plugin.afterRemoveItems)
+                continue;
+            await this.invokeVoidHook(plugin, () => plugin.afterRemoveItems(keys, context), 'after', 'removeItems', undefined, context);
+        }
+    }
+    async destroy() {
+        const plugins = this.pluginRegistry
+            .map((entry) => entry.plugin)
+            .slice()
+            .reverse();
+        for (const plugin of plugins) {
+            if (this.destroyed.has(plugin) || this.disabled.has(plugin)) {
+                continue;
+            }
+            if (typeof plugin.onDestroy !== 'function') {
+                this.destroyed.add(plugin);
+                continue;
+            }
+            const context = this.createContext(null);
+            try {
+                await plugin.onDestroy(context);
+            }
+            catch (error) {
+                await this.dispatchPluginError(plugin, error, 'destroy', 'lifecycle', undefined, context);
+            }
+            finally {
+                this.destroyed.add(plugin);
+            }
+        }
+    }
+    normalizeBatch(items) {
+        return normalizeBatchEntries(items);
+    }
+    shouldPropagate(error) {
+        return (error instanceof LocalSpaceError || error instanceof PluginAbortError);
+    }
+    async dispatchPluginError(plugin, error, stage, operation, key, context) {
+        const info = {
+            plugin: plugin.name,
+            operation,
+            stage,
+            key,
+            context,
+            error,
+        };
+        if (typeof plugin.onError === 'function') {
+            try {
+                await plugin.onError(error, info);
+                return;
+            }
+            catch (hookError) {
+                console.error(`Plugin onError handler failed for "${plugin.name}"`, hookError);
+            }
+        }
+        console.warn(`Plugin "${plugin.name}" error during ${operation}`, error);
+    }
+    async invokeValueHook(plugin, executor, stage, operation, key, context, fallback) {
+        try {
+            const result = await executor();
+            return (typeof result === 'undefined' ? fallback : result);
+        }
+        catch (error) {
+            if (this.shouldPropagate(error)) {
+                throw error;
+            }
+            await this.dispatchPluginError(plugin, error, stage, operation, key, context);
+            return fallback;
+        }
+    }
+    async invokeVoidHook(plugin, executor, stage, operation, key, context) {
+        try {
+            await executor();
+        }
+        catch (error) {
+            if (this.shouldPropagate(error)) {
+                throw error;
+            }
+            await this.dispatchPluginError(plugin, error, stage, operation, key, context);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-manager.js","sourceRoot":"","sources":["../../src/core/plugin-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  BatchItems,\n  BatchResponse,\n  DbInfo,\n  LocalSpaceConfig,\n  LocalSpaceInstance,\n  LocalSpacePlugin,\n  PluginContext,\n  PluginErrorInfo,\n  PluginOperation,\n  PluginStage,\n} from '../types';\nimport { LocalSpaceError } from '../errors';\nimport { normalizeBatchEntries } from '../utils/helpers';\n\nexport class PluginAbortError extends Error {\n  constructor(message = 'Plugin aborted the operation') {\n    super(message);\n    this.name = 'PluginAbortError';\n  }\n}\n\ntype PluginHost = LocalSpaceInstance & {\n  _config: LocalSpaceConfig;\n  _dbInfo: DbInfo | null;\n};\n\ntype RegisteredPlugin = {\n  plugin: LocalSpacePlugin;\n  order: number;\n};\n\nconst sharedMetadataFor = (): Record<string, unknown> => Object.create(null);\n\nexport class PluginManager {\n  private readonly host: PluginHost;\n\n  private readonly sharedMetadata: Record<string, unknown> =\n    sharedMetadataFor();\n\n  private readonly pluginRegistry: RegisteredPlugin[] = [];\n\n  private readonly initialized = new WeakSet<LocalSpacePlugin>();\n\n  private readonly initPromises = new WeakMap<\n    LocalSpacePlugin,\n    Promise<void>\n  >();\n\n  private readonly destroyed = new WeakSet<LocalSpacePlugin>();\n\n  private readonly disabled = new WeakSet<LocalSpacePlugin>();\n\n  private orderCounter = 0;\n\n  constructor(host: PluginHost, initialPlugins: LocalSpacePlugin[] = []) {\n    this.host = host;\n    if (initialPlugins.length) {\n      this.registerPlugins(initialPlugins);\n    }\n  }\n\n  hasPlugins(): boolean {\n    return this.pluginRegistry.length > 0;\n  }\n\n  registerPlugins(plugins: LocalSpacePlugin[]): void {\n    for (const plugin of plugins) {\n      if (!plugin) continue;\n      this.pluginRegistry.push({ plugin, order: this.orderCounter++ });\n    }\n    this.sortPlugins();\n  }\n\n  private sortPlugins(): void {\n    this.pluginRegistry.sort((a, b) => {\n      const priorityA = a.plugin.priority ?? 0;\n      const priorityB = b.plugin.priority ?? 0;\n      if (priorityA === priorityB) {\n        return a.order - b.order;\n      }\n      return priorityB - priorityA;\n    });\n  }\n\n  private getActivePlugins(options?: {\n    reverse?: boolean;\n  }): LocalSpacePlugin[] {\n    const reverse = options?.reverse ?? false;\n    const plugins = this.pluginRegistry\n      .map((entry) => entry.plugin)\n      .filter((plugin) => {\n        if (this.disabled.has(plugin)) {\n          return false;\n        }\n        const enabled = plugin.enabled;\n        if (typeof enabled === 'function') {\n          try {\n            return !!enabled();\n          } catch (error) {\n            console.warn(\n              `Plugin \"${plugin.name}\" enabled() check failed`,\n              error\n            );\n            return false;\n          }\n        }\n        return enabled !== false;\n      });\n    return reverse ? plugins.slice().reverse() : plugins;\n  }\n\n  async ensureInitialized(): Promise<void> {\n    for (const plugin of this.getActivePlugins()) {\n      if (this.initialized.has(plugin)) {\n        continue;\n      }\n\n      if (typeof plugin.onInit !== 'function') {\n        this.initialized.add(plugin);\n        continue;\n      }\n\n      const pendingInit = this.initPromises.get(plugin);\n      if (pendingInit) {\n        await pendingInit;\n        continue;\n      }\n\n      const context = this.createContext(null);\n      const initPromise = (async () => {\n        try {\n          await plugin.onInit!(context);\n          this.initialized.add(plugin);\n        } catch (error) {\n          await this.dispatchPluginError(\n            plugin,\n            error,\n            'init',\n            'lifecycle',\n            undefined,\n            context\n          );\n          const policy = this.host._config.pluginInitPolicy ?? 'fail';\n          if (policy === 'disable-and-continue') {\n            this.disabled.add(plugin);\n            return;\n          }\n          throw error;\n        } finally {\n          this.initPromises.delete(plugin);\n        }\n      })();\n\n      this.initPromises.set(plugin, initPromise);\n      await initPromise;\n    }\n  }\n\n  createContext(operation: PluginOperation | null): PluginContext {\n    return {\n      instance: this.host,\n      driver: this.host.driver ? this.host.driver() : null,\n      dbInfo: this.host._dbInfo ?? null,\n      config: this.host._config,\n      metadata: this.sharedMetadata,\n      operation,\n      operationState: Object.create(null),\n    };\n  }\n\n  async beforeSet<T>(\n    key: string,\n    value: T,\n    context: PluginContext\n  ): Promise<T> {\n    let current = value;\n    for (const plugin of this.getActivePlugins()) {\n      if (!plugin.beforeSet) continue;\n      current = await this.invokeValueHook(\n        plugin,\n        () => plugin.beforeSet!(key, current, context),\n        'before',\n        'setItem',\n        key,\n        context,\n        current\n      );\n    }\n    return current;\n  }\n\n  async afterSet<T>(\n    key: string,\n    value: T,\n    context: PluginContext\n  ): Promise<void> {\n    for (const plugin of this.getActivePlugins({ reverse: true })) {\n      if (!plugin.afterSet) continue;\n      await this.invokeVoidHook(\n        plugin,\n        () => plugin.afterSet!(key, value, context),\n        'after',\n        'setItem',\n        key,\n        context\n      );\n    }\n  }\n\n  async beforeGet(key: string, context: PluginContext): Promise<string> {\n    let currentKey = key;\n    for (const plugin of this.getActivePlugins()) {\n      if (!plugin.beforeGet) continue;\n      currentKey = await this.invokeValueHook(\n        plugin,\n        () => plugin.beforeGet!(currentKey, context),\n        'before',\n        'getItem',\n        currentKey,\n        context,\n        currentKey\n      );\n    }\n    return currentKey;\n  }\n\n  async afterGet<T>(\n    key: string,\n    value: T | null,\n    context: PluginContext\n  ): Promise<T | null> {\n    let currentValue: T | null = value;\n    for (const plugin of this.getActivePlugins({ reverse: true })) {\n      if (!plugin.afterGet) continue;\n      currentValue = await this.invokeValueHook(\n        plugin,\n        () => plugin.afterGet!(key, currentValue, context),\n        'after',\n        'getItem',\n        key,\n        context,\n        currentValue\n      );\n    }\n    return currentValue;\n  }\n\n  async beforeRemove(key: string, context: PluginContext): Promise<string> {\n    let currentKey = key;\n    for (const plugin of this.getActivePlugins()) {\n      if (!plugin.beforeRemove) continue;\n      currentKey = await this.invokeValueHook(\n        plugin,\n        () => plugin.beforeRemove!(currentKey, context),\n        'before',\n        'removeItem',\n        currentKey,\n        context,\n        currentKey\n      );\n    }\n    return currentKey;\n  }\n\n  async afterRemove(key: string, context: PluginContext): Promise<void> {\n    for (const plugin of this.getActivePlugins({ reverse: true })) {\n      if (!plugin.afterRemove) continue;\n      await this.invokeVoidHook(\n        plugin,\n        () => plugin.afterRemove!(key, context),\n        'after',\n        'removeItem',\n        key,\n        context\n      );\n    }\n  }\n\n  async beforeSetItems<T>(\n    entries: BatchItems<T>,\n    context: PluginContext\n  ): Promise<BatchItems<T>> {\n    let current = entries;\n    for (const plugin of this.getActivePlugins()) {\n      if (!plugin.beforeSetItems) continue;\n      current = await this.invokeValueHook(\n        plugin,\n        () => plugin.beforeSetItems!(current, context),\n        'before',\n        'setItems',\n        undefined,\n        context,\n        current\n      );\n    }\n    return current;\n  }\n\n  async afterSetItems<T>(\n    entries: BatchResponse<T>,\n    context: PluginContext\n  ): Promise<BatchResponse<T>> {\n    let current = entries;\n    for (const plugin of this.getActivePlugins({ reverse: true })) {\n      if (!plugin.afterSetItems) continue;\n      current = await this.invokeValueHook(\n        plugin,\n        () => plugin.afterSetItems!(current, context),\n        'after',\n        'setItems',\n        undefined,\n        context,\n        current\n      );\n    }\n    return current;\n  }\n\n  async beforeGetItems(\n    keys: string[],\n    context: PluginContext\n  ): Promise<string[]> {\n    let currentKeys = keys;\n    for (const plugin of this.getActivePlugins()) {\n      if (!plugin.beforeGetItems) continue;\n      currentKeys = await this.invokeValueHook(\n        plugin,\n        () => plugin.beforeGetItems!(currentKeys, context),\n        'before',\n        'getItems',\n        undefined,\n        context,\n        currentKeys\n      );\n    }\n    return currentKeys;\n  }\n\n  async afterGetItems<T>(\n    entries: BatchResponse<T>,\n    context: PluginContext\n  ): Promise<BatchResponse<T>> {\n    let current = entries;\n    for (const plugin of this.getActivePlugins({ reverse: true })) {\n      if (!plugin.afterGetItems) continue;\n      current = await this.invokeValueHook(\n        plugin,\n        () => plugin.afterGetItems!(current, context),\n        'after',\n        'getItems',\n        undefined,\n        context,\n        current\n      );\n    }\n    return current;\n  }\n\n  async beforeRemoveItems(\n    keys: string[],\n    context: PluginContext\n  ): Promise<string[]> {\n    let currentKeys = keys;\n    for (const plugin of this.getActivePlugins()) {\n      if (!plugin.beforeRemoveItems) continue;\n      currentKeys = await this.invokeValueHook(\n        plugin,\n        () => plugin.beforeRemoveItems!(currentKeys, context),\n        'before',\n        'removeItems',\n        undefined,\n        context,\n        currentKeys\n      );\n    }\n    return currentKeys;\n  }\n\n  async afterRemoveItems(\n    keys: string[],\n    context: PluginContext\n  ): Promise<void> {\n    for (const plugin of this.getActivePlugins({ reverse: true })) {\n      if (!plugin.afterRemoveItems) continue;\n      await this.invokeVoidHook(\n        plugin,\n        () => plugin.afterRemoveItems!(keys, context),\n        'after',\n        'removeItems',\n        undefined,\n        context\n      );\n    }\n  }\n\n  async destroy(): Promise<void> {\n    const plugins = this.pluginRegistry\n      .map((entry) => entry.plugin)\n      .slice()\n      .reverse();\n    for (const plugin of plugins) {\n      if (this.destroyed.has(plugin) || this.disabled.has(plugin)) {\n        continue;\n      }\n      if (typeof plugin.onDestroy !== 'function') {\n        this.destroyed.add(plugin);\n        continue;\n      }\n      const context = this.createContext(null);\n      try {\n        await plugin.onDestroy(context);\n      } catch (error) {\n        await this.dispatchPluginError(\n          plugin,\n          error,\n          'destroy',\n          'lifecycle',\n          undefined,\n          context\n        );\n      } finally {\n        this.destroyed.add(plugin);\n      }\n    }\n  }\n\n  normalizeBatch<T>(items: BatchItems<T>): Array<{ key: string; value: T }> {\n    return normalizeBatchEntries(items);\n  }\n\n  private shouldPropagate(error: unknown): boolean {\n    return (\n      error instanceof LocalSpaceError || error instanceof PluginAbortError\n    );\n  }\n\n  private async dispatchPluginError(\n    plugin: LocalSpacePlugin,\n    error: unknown,\n    stage: PluginStage,\n    operation: PluginOperation,\n    key: string | undefined,\n    context: PluginContext\n  ): Promise<void> {\n    const info: PluginErrorInfo = {\n      plugin: plugin.name,\n      operation,\n      stage,\n      key,\n      context,\n      error,\n    };\n\n    if (typeof plugin.onError === 'function') {\n      try {\n        await plugin.onError(error, info);\n        return;\n      } catch (hookError) {\n        console.error(\n          `Plugin onError handler failed for \"${plugin.name}\"`,\n          hookError\n        );\n      }\n    }\n\n    console.warn(`Plugin \"${plugin.name}\" error during ${operation}`, error);\n  }\n\n  private async invokeValueHook<T>(\n    plugin: LocalSpacePlugin,\n    executor: () => Promise<T> | T,\n    stage: PluginStage,\n    operation: PluginOperation,\n    key: string | undefined,\n    context: PluginContext,\n    fallback: T\n  ): Promise<T> {\n    try {\n      const result = await executor();\n      return (typeof result === 'undefined' ? fallback : result) as T;\n    } catch (error) {\n      if (this.shouldPropagate(error)) {\n        throw error;\n      }\n      await this.dispatchPluginError(\n        plugin,\n        error,\n        stage,\n        operation,\n        key,\n        context\n      );\n      return fallback;\n    }\n  }\n\n  private async invokeVoidHook(\n    plugin: LocalSpacePlugin,\n    executor: () => Promise<void> | void,\n    stage: PluginStage,\n    operation: PluginOperation,\n    key: string | undefined,\n    context: PluginContext\n  ): Promise<void> {\n    try {\n      await executor();\n    } catch (error) {\n      if (this.shouldPropagate(error)) {\n        throw error;\n      }\n      await this.dispatchPluginError(\n        plugin,\n        error,\n        stage,\n        operation,\n        key,\n        context\n      );\n    }\n  }\n}\n"]}

package/dist/drivers/indexeddb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"indexeddb.d.ts","sourceRoot":"","sources":["../../src/drivers/indexeddb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EASP,MAAM,UAAU,CAAC;AAulElB,QAAA,MAAM,YAAY,EAAE,MAkBnB,CAAC;AAEF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"indexeddb.d.ts","sourceRoot":"","sources":["../../src/drivers/indexeddb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EASP,MAAM,UAAU,CAAC;AA4oElB,QAAA,MAAM,YAAY,EAAE,MAkBnB,CAAC;AAEF,eAAe,YAAY,CAAC"}