strata-storage 2.7.0 → 2.8.0

package/dist/features/compression.js

@@ -34,8 +34,12 @@ export class CompressionManager {
                 return data;
             }
             return {
+                // Tag the on-disk format so decompress() can pick the right decoder.
+                // Older releases wrote `algorithm: 'lz'` with a UTF-16-char codec that
+                // corrupted non-Latin1 data; the current byte-LZW format is tagged
+                // distinctly and old 'lz' payloads still read via the legacy path.
                 data: compressed,
-                algorithm: this.config.algorithm,
+                algorithm: CompressionManager.FORMAT,
                 originalSize,
                 compressedSize,
             };
@@ -52,7 +56,12 @@ export class CompressionManager {
             if (!this.isCompressedData(compressedData)) {
                 return compressedData;
             }
-            const decompressed = this.lzDecompress(compressedData.data);
+            // Route by stored format tag: the current byte-LZW format vs. the legacy
+            // UTF-16-char codec written by <= 2.7.0 (algorithm 'lz'), so existing
+            // compressed-at-rest values keep decoding after upgrade.
+            const decompressed = compressedData.algorithm === CompressionManager.FORMAT
+                ? this.lzDecompress(compressedData.data)
+                : this.legacyLzDecompress(compressedData.data);
             return JSON.parse(decompressed);
         }
         catch (error) {
@@ -70,120 +79,198 @@ export class CompressionManager {
             'originalSize' in data &&
             'compressedSize' in data);
     }
+    // Format tag stored in CompressedData.algorithm for the current byte-LZW
+    // codec. Payloads written by <= 2.7.0 are tagged 'lz' and decode via the
+    // legacy path; anything tagged FORMAT uses the current decoder.
+    static FORMAT = 'lz-u8';
+    // Freeze the LZW dictionary at 16 bits so every token serializes to exactly
+    // two bytes; both encoder and decoder stop growing the dictionary at the same
+    // point, staying in sync. 0xFFFF entries is ample for storage-sized values;
+    // beyond it, already-learned phrases still compress, just no new ones.
+    static LZW_MAX_CODE = 0xffff;
     /**
-     * LZ-string compression implementation
+     * LZ compression over UTF-8 bytes.
+     *
+     * The alphabet is bytes (0–255), so the literal-vs-dictionary-code
+     * discriminator (`< 256`) on decompress is correct for ALL input — including
+     * CJK / emoji / symbols whose code points are ≥ 256. (Operating on raw UTF-16
+     * chars previously misclassified any such literal as a dictionary code and
+     * silently corrupted the stored value, or threw on read.)
      */
     lzCompress(uncompressed) {
-        if (uncompressed == null)
+        const bytes = new TextEncoder().encode(uncompressed);
+        if (bytes.length === 0)
             return '';
-        const context = new Map();
-        const out = [];
-        let currentChar;
-        let phrase = uncompressed.charAt(0);
-        let code = 256;
-        for (let i = 1; i < uncompressed.length; i++) {
-            currentChar = uncompressed.charAt(i);
-            if (context.has(phrase + currentChar)) {
-                phrase += currentChar;
+        const dictionary = new Map();
+        let nextCode = 256;
+        const tokens = [];
+        let phrase = String.fromCharCode(bytes[0]); // byte-string (each char 0–255)
+        for (let i = 1; i < bytes.length; i++) {
+            const current = String.fromCharCode(bytes[i]);
+            const combined = phrase + current;
+            if (dictionary.has(combined)) {
+                phrase = combined;
             }
             else {
-                if (phrase.length > 1) {
-                    out.push(String.fromCharCode(context.get(phrase)));
-                }
-                else {
-                    out.push(phrase);
+                // `phrase` is always either a single byte (literal) or an existing
+                // dictionary entry, so the lookup below is always defined.
+                tokens.push(phrase.length === 1 ? phrase.charCodeAt(0) : dictionary.get(phrase));
+                if (nextCode <= CompressionManager.LZW_MAX_CODE) {
+                    dictionary.set(combined, nextCode++);
                 }
-                context.set(phrase + currentChar, code);
-                code++;
-                phrase = currentChar;
+                phrase = current;
             }
         }
-        if (phrase.length > 1) {
-            out.push(String.fromCharCode(context.get(phrase)));
+        tokens.push(phrase.length === 1 ? phrase.charCodeAt(0) : dictionary.get(phrase));
+        // Serialize each token as a 16-bit big-endian value, then base64.
+        const out = new Uint8Array(tokens.length * 2);
+        for (let i = 0; i < tokens.length; i++) {
+            out[i * 2] = (tokens[i] >> 8) & 0xff;
+            out[i * 2 + 1] = tokens[i] & 0xff;
         }
-        else {
-            out.push(phrase);
-        }
-        return this.encodeToBase64(out.join(''));
+        return this.bytesToBase64(out);
     }
     /**
-     * LZ-string decompression implementation
+     * LZ decompression — inverse of {@link lzCompress}, reconstructing UTF-8 bytes
+     * then decoding them back to the original string.
      */
     lzDecompress(compressed) {
-        if (compressed == null)
+        if (!compressed)
             return '';
-        if (compressed === '')
+        const inBytes = this.base64ToBytes(compressed);
+        const tokenCount = inBytes.length >> 1;
+        if (tokenCount === 0)
             return '';
-        const decoded = this.decodeFromBase64(compressed);
         const dictionary = new Map();
-        let currentChar = decoded.charAt(0);
-        let oldPhrase = currentChar;
-        const out = [currentChar];
-        let code = 256;
-        let phrase;
-        for (let i = 1; i < decoded.length; i++) {
-            const currentCode = decoded.charCodeAt(i);
-            if (currentCode < 256) {
-                phrase = decoded.charAt(i);
+        let nextCode = 256;
+        const readToken = (i) => (inBytes[i * 2] << 8) | inBytes[i * 2 + 1];
+        // The first token is always a literal byte (the dictionary starts empty).
+        let oldPhrase = String.fromCharCode(readToken(0));
+        const out = [oldPhrase];
+        for (let i = 1; i < tokenCount; i++) {
+            const code = readToken(i);
+            let phrase;
+            if (code < 256) {
+                phrase = String.fromCharCode(code);
+            }
+            else if (dictionary.has(code)) {
+                phrase = dictionary.get(code);
             }
             else {
-                phrase = dictionary.get(currentCode) || oldPhrase + currentChar;
+                // Classic LZW edge: the code equals the entry we are about to define.
+                phrase = oldPhrase + oldPhrase.charAt(0);
             }
             out.push(phrase);
-            currentChar = phrase.charAt(0);
-            dictionary.set(code, oldPhrase + currentChar);
-            code++;
+            if (nextCode <= CompressionManager.LZW_MAX_CODE) {
+                dictionary.set(nextCode++, oldPhrase + phrase.charAt(0));
+            }
             oldPhrase = phrase;
         }
-        return out.join('');
+        // `out` holds byte-strings; rebuild the byte sequence and UTF-8 decode it.
+        const joined = out.join('');
+        const bytes = new Uint8Array(joined.length);
+        for (let i = 0; i < joined.length; i++) {
+            bytes[i] = joined.charCodeAt(i) & 0xff;
+        }
+        return new TextDecoder().decode(bytes);
     }
-    /**
-     * Base64 encoding for compressed data
-     */
-    encodeToBase64(input) {
+    static B64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    /** Base64-encode raw bytes (btoa when available, else a pure-JS fallback). */
+    bytesToBase64(bytes) {
         if (typeof btoa !== 'undefined') {
-            // Browser environment
-            return btoa(unescape(encodeURIComponent(input)));
+            let binary = '';
+            const chunk = 0x8000;
+            for (let i = 0; i < bytes.length; i += chunk) {
+                binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+            }
+            return btoa(binary);
         }
-        // Pure JS implementation for Node.js or other environments
-        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        const chars = CompressionManager.B64_CHARS;
         let result = '';
-        let i = 0;
-        while (i < input.length) {
-            const a = input.charCodeAt(i++);
-            const b = i < input.length ? input.charCodeAt(i++) : 0;
-            const c = i < input.length ? input.charCodeAt(i++) : 0;
+        for (let i = 0; i < bytes.length; i += 3) {
+            const a = bytes[i];
+            const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+            const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
             const bitmap = (a << 16) | (b << 8) | c;
             result += chars.charAt((bitmap >> 18) & 63);
             result += chars.charAt((bitmap >> 12) & 63);
-            result += i - 2 < input.length ? chars.charAt((bitmap >> 6) & 63) : '=';
-            result += i - 1 < input.length ? chars.charAt(bitmap & 63) : '=';
+            result += i + 1 < bytes.length ? chars.charAt((bitmap >> 6) & 63) : '=';
+            result += i + 2 < bytes.length ? chars.charAt(bitmap & 63) : '=';
         }
         return result;
     }
+    /** Decode a base64 string back to raw bytes (atob when available, else pure-JS). */
+    base64ToBytes(input) {
+        if (typeof atob !== 'undefined') {
+            const binary = atob(input);
+            const bytes = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++) {
+                bytes[i] = binary.charCodeAt(i) & 0xff;
+            }
+            return bytes;
+        }
+        const chars = CompressionManager.B64_CHARS;
+        const clean = input.replace(/[^A-Za-z0-9+/]/g, '');
+        const bytes = [];
+        for (let i = 0; i < clean.length; i += 4) {
+            const e1 = chars.indexOf(clean.charAt(i));
+            const e2 = chars.indexOf(clean.charAt(i + 1));
+            const e3 = chars.indexOf(clean.charAt(i + 2));
+            const e4 = chars.indexOf(clean.charAt(i + 3));
+            const bitmap = (e1 << 18) | (Math.max(e2, 0) << 12) | (Math.max(e3, 0) << 6) | Math.max(e4, 0);
+            bytes.push((bitmap >> 16) & 255);
+            if (e3 !== -1)
+                bytes.push((bitmap >> 8) & 255);
+            if (e4 !== -1)
+                bytes.push(bitmap & 255);
+        }
+        return new Uint8Array(bytes);
+    }
     /**
-     * Base64 decoding for compressed data
+     * Legacy decoder for payloads written by <= 2.7.0 (algorithm 'lz'): the
+     * original UTF-16-char LZW over the raw string with a `decodeURIComponent`
+     * base64 layer. Kept read-only so existing compressed-at-rest values still
+     * decode after upgrading to the current byte-LZW codec. (That codec corrupted
+     * non-Latin1 input, so legacy payloads are Latin1 in practice.)
      */
-    decodeFromBase64(input) {
-        if (typeof atob !== 'undefined') {
-            // Browser environment
-            return decodeURIComponent(escape(atob(input)));
+    legacyLzDecompress(compressed) {
+        if (!compressed)
+            return '';
+        const decoded = typeof atob !== 'undefined'
+            ? decodeURIComponent(escape(atob(compressed)))
+            : this.legacyDecodeFromBase64(compressed);
+        const dictionary = new Map();
+        let currentChar = decoded.charAt(0);
+        let oldPhrase = currentChar;
+        const out = [currentChar];
+        let code = 256;
+        for (let i = 1; i < decoded.length; i++) {
+            const currentCode = decoded.charCodeAt(i);
+            const phrase = currentCode < 256
+                ? decoded.charAt(i)
+                : dictionary.get(currentCode) || oldPhrase + currentChar;
+            out.push(phrase);
+            currentChar = phrase.charAt(0);
+            dictionary.set(code, oldPhrase + currentChar);
+            code++;
+            oldPhrase = phrase;
         }
-        // Pure JS implementation
-        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        return out.join('');
+    }
+    legacyDecodeFromBase64(input) {
+        const chars = `${CompressionManager.B64_CHARS}=`;
         let result = '';
-        let i = 0;
-        input = input.replace(/[^A-Za-z0-9+/]/g, '');
-        while (i < input.length) {
-            const encoded1 = chars.indexOf(input.charAt(i++));
-            const encoded2 = chars.indexOf(input.charAt(i++));
-            const encoded3 = chars.indexOf(input.charAt(i++));
-            const encoded4 = chars.indexOf(input.charAt(i++));
-            const bitmap = (encoded1 << 18) | (encoded2 << 12) | (encoded3 << 6) | encoded4;
+        const clean = input.replace(/[^A-Za-z0-9+/]/g, '');
+        for (let i = 0; i < clean.length; i += 4) {
+            const e1 = chars.indexOf(clean.charAt(i));
+            const e2 = chars.indexOf(clean.charAt(i + 1));
+            const e3 = chars.indexOf(clean.charAt(i + 2));
+            const e4 = chars.indexOf(clean.charAt(i + 3));
+            const bitmap = (e1 << 18) | (e2 << 12) | (e3 << 6) | e4;
             result += String.fromCharCode((bitmap >> 16) & 255);
-            if (encoded3 !== 64)
+            if (e3 !== 64 && e3 !== -1)
                 result += String.fromCharCode((bitmap >> 8) & 255);
-            if (encoded4 !== 64)
+            if (e4 !== 64 && e4 !== -1)
                 result += String.fromCharCode(bitmap & 255);
         }
         return result;

package/dist/features/encryption/index.d.ts

@@ -1,2 +1 @@
 export * from "../encryption.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/features/encryption.d.ts

@@ -118,4 +118,3 @@ export declare class EncryptionManager {
      */
     hash(data: string): Promise<string>;
 }
-//# sourceMappingURL=encryption.d.ts.map

package/dist/features/integrity.d.ts

@@ -13,4 +13,3 @@ export declare function computeChecksum(value: unknown): string;
  * stored (nothing to verify) so this is safe to call unconditionally.
  */
 export declare function verifyChecksum(value: unknown, expected: string | undefined): boolean;
-//# sourceMappingURL=integrity.d.ts.map

package/dist/features/migration.d.ts

@@ -14,4 +14,3 @@ export declare class MigrationManager {
     private getCurrentVersion;
     private setVersion;
 }
-//# sourceMappingURL=migration.d.ts.map

package/dist/features/migration.js

@@ -1,6 +1,7 @@
 /**
  * Migration utilities for storage upgrades
  */
+import { MigrationError } from "../utils/errors.js";
 export class MigrationManager {
     migrations = [];
     register(migration) {
@@ -22,9 +23,13 @@ export class MigrationManager {
         }
         else {
             for (const migration of migrationsToRun.reverse()) {
-                if (migration.down) {
-                    await migration.down(adapter);
+                // An irreversible migration must NOT silently lower the stored version
+                // (that would claim a rollback that never reverted the data). Fail
+                // before touching anything so the version stays consistent with data.
+                if (!migration.down) {
+                    throw new MigrationError(`Cannot roll back migration ${migration.version}: it has no down() and is irreversible.`);
                 }
+                await migration.down(adapter);
                 await this.setVersion(adapter, migration.version - 1);
             }
         }

package/dist/features/observer/index.d.ts

@@ -1,2 +1 @@
 export * from "../observer.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/features/observer.d.ts

@@ -17,4 +17,3 @@ export declare class StorageObserver {
      */
     clear(): void;
 }
-//# sourceMappingURL=observer.d.ts.map

package/dist/features/query/index.d.ts

@@ -1,2 +1 @@
 export * from "../query.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/features/query.d.ts

@@ -68,6 +68,7 @@ export declare class QueryEngine {
     /**
      * Set nested value in object using dot notation
      */
+    private static readonly FORBIDDEN_KEYS;
     private setNestedValue;
     /**
      * Delete nested value from object using dot notation
@@ -78,4 +79,3 @@ export declare class QueryEngine {
  * Create a query engine instance
  */
 export declare function createQueryEngine(): QueryEngine;
-//# sourceMappingURL=query.d.ts.map

package/dist/features/query.js

@@ -73,7 +73,15 @@ export class QueryEngine {
                 // Otherwise check if value equals any operand value
                 return operand.some((v) => this.equals(value, v));
             case '$nin':
-                return Array.isArray(operand) && !operand.some((v) => this.equals(value, v));
+                if (!Array.isArray(operand))
+                    return false;
+                // Mirror $in: for an array field, "not in" means none of its items
+                // match any operand value (the previous code compared the whole array
+                // to each scalar operand, giving wrong results for array fields).
+                if (Array.isArray(value)) {
+                    return !operand.some((v) => value.some((item) => this.equals(item, v)));
+                }
+                return !operand.some((v) => this.equals(value, v));
             case '$regex':
                 return this.matchesRegex(value, operand);
             case '$exists':
@@ -272,8 +280,10 @@ export class QueryEngine {
             }
         }
         else {
-            // Exclusion mode - include all except specified fields
-            result.value = { ...item };
+            // Exclusion mode - include all except specified fields. Spread the item's
+            // own fields directly onto result (NOT under a `value` wrapper, which left
+            // the excluded keys unreachable and returned the whole item unchanged).
+            Object.assign(result, item);
             for (const [key, exclude] of Object.entries(projection)) {
                 if (exclude === 0 || exclude === false) {
                     this.deleteNestedValue(result, key);
@@ -285,17 +295,28 @@ export class QueryEngine {
     /**
      * Set nested value in object using dot notation
      */
+    static FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
     setNestedValue(obj, path, value) {
         const parts = path.split('.');
         let current = obj;
         for (let i = 0; i < parts.length - 1; i++) {
             const part = parts[i];
-            if (!(part in current) || typeof current[part] !== 'object') {
+            // Refuse prototype-polluting paths and use own-property checks only — `in`
+            // walks the prototype chain, so a '__proto__.x' path could reach
+            // Object.prototype.
+            if (QueryEngine.FORBIDDEN_KEYS.has(part))
+                return;
+            if (!Object.prototype.hasOwnProperty.call(current, part) ||
+                typeof current[part] !== 'object' ||
+                current[part] === null) {
                 current[part] = {};
             }
             current = current[part];
         }
-        current[parts[parts.length - 1]] = value;
+        const last = parts[parts.length - 1];
+        if (QueryEngine.FORBIDDEN_KEYS.has(last))
+            return;
+        current[last] = value;
     }
     /**
      * Delete nested value from object using dot notation
@@ -305,7 +326,9 @@ export class QueryEngine {
         let current = obj;
         for (let i = 0; i < parts.length - 1; i++) {
             const part = parts[i];
-            if (!(part in current) || typeof current[part] !== 'object') {
+            if (!Object.prototype.hasOwnProperty.call(current, part) ||
+                typeof current[part] !== 'object' ||
+                current[part] === null) {
                 return;
             }
             current = current[part];

package/dist/features/sync/index.d.ts

@@ -1,2 +1 @@
 export * from "../sync.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/features/sync.d.ts

@@ -100,4 +100,3 @@ export declare class SyncManager extends EventEmitter {
  * Create a sync manager instance
  */
 export declare function createSyncManager(config?: SyncConfig): SyncManager;
-//# sourceMappingURL=sync.d.ts.map

package/dist/features/sync.js

@@ -247,9 +247,24 @@ export class SyncManager extends EventEmitter {
             return this.config.conflictResolution(values);
         }
         switch (this.config.conflictResolution) {
-            case 'latest':
-                // Return the last value (most recent)
-                return values[values.length - 1];
+            case 'latest': {
+                // Most-recent-wins by the StorageValue `updated` timestamp so two tabs
+                // with concurrent same-key writes converge on the genuinely newest
+                // value, instead of each applying the other's (last-received-wins, which
+                // diverges and lets a delayed older message clobber a newer local
+                // write). Falls back to positional-last when values carry no timestamp.
+                let newest = values[values.length - 1];
+                let newestTime = isStorageValue(newest) ? newest.updated : undefined;
+                for (const candidate of values) {
+                    if (!isStorageValue(candidate))
+                        continue;
+                    if (typeof newestTime !== 'number' || candidate.updated >= newestTime) {
+                        newest = candidate;
+                        newestTime = candidate.updated;
+                    }
+                }
+                return newest;
+            }
             case 'merge':
                 if (values.every(isStorageValue)) {
                     const wrappers = values;

package/dist/features/ttl/index.d.ts

@@ -1,2 +1 @@
 export * from "../ttl.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/features/ttl.d.ts

@@ -121,4 +121,3 @@ export declare class TTLManager extends EventEmitter {
  * Create a TTL manager instance
  */
 export declare function createTTLManager(config?: TTLConfig): TTLManager;
-//# sourceMappingURL=ttl.d.ts.map

package/dist/features/ttl.js

@@ -32,10 +32,12 @@ export class TTLManager extends EventEmitter {
             const time = options.expireAt instanceof Date ? options.expireAt.getTime() : options.expireAt;
             return time > Date.now() ? time : undefined;
         }
-        // Expire after a certain date
+        // Expire after a certain date — documented as an alias of expireAt, so it
+        // gets the same past-guard (a past time yields no expiry rather than an
+        // entry that is dead on arrival).
         if (options.expireAfter) {
             const afterTime = options.expireAfter instanceof Date ? options.expireAfter.getTime() : options.expireAfter;
-            return afterTime;
+            return afterTime > Date.now() ? afterTime : undefined;
         }
         // TTL from now
         if (options.ttl) {

package/dist/firebase.d.ts

@@ -23,4 +23,3 @@ export declare function enableFirebaseSync(storage: Strata, config: FirebaseSync
  * Check if Firebase is available in the environment
  */
 export declare function isFirebaseAvailable(): Promise<boolean>;
-//# sourceMappingURL=firebase.d.ts.map

package/dist/firebase.js

@@ -6,6 +6,35 @@ function isStorageValue(value) {
         'created' in value &&
         'updated' in value);
 }
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Recursively drop `undefined`-valued keys. Firestore `setDoc()` and Realtime
+ * Database `set()` both throw on `undefined` field values, and the StorageValue
+ * wrapper Strata builds always carries `expires`/`tags`/`metadata` keys that are
+ * `undefined` for a plain write — so writing it verbatim breaks the happy path.
+ * Only plain objects/arrays are traversed, so Dates and other class instances
+ * are preserved as-is.
+ */
+function stripUndefined(input) {
+    if (Array.isArray(input)) {
+        return input.map((item) => stripUndefined(item));
+    }
+    if (isPlainObject(input)) {
+        const out = {};
+        for (const [key, val] of Object.entries(input)) {
+            if (val === undefined)
+                continue;
+            out[key] = stripUndefined(val);
+        }
+        return out;
+    }
+    return input;
+}
 function normalizeRemoteValue(value) {
     if (!value)
         return null;
@@ -71,7 +100,7 @@ export async function enableFirebaseSync(storage, config) {
                 },
                 async set(key, value) {
                     const docRef = doc(db, collectionName, key);
-                    await setDoc(docRef, value);
+                    await setDoc(docRef, stripUndefined(value));
                 },
                 async remove(key) {
                     const docRef = doc(db, collectionName, key);
@@ -168,7 +197,7 @@ export async function enableFirebaseSync(storage, config) {
                     return snapshot.exists() ? normalizeRemoteValue(snapshot.val()) : null;
                 },
                 async set(key, value) {
-                    await set(ref(db, `strata-storage/${key}`), value);
+                    await set(ref(db, `strata-storage/${key}`), stripUndefined(value));
                 },
                 async remove(key) {
                     await remove(ref(db, `strata-storage/${key}`));
@@ -230,6 +259,14 @@ export async function enableFirebaseSync(storage, config) {
             // Cast to unknown first to bypass type checking for custom adapter
             storage.registerAdapter(realtimeAdapter);
         }
+        // Attach the freshly registered adapters to the active set so they join
+        // multi-adapter operations (subscribe/keys/clear/size) immediately — not
+        // only after an explicit `{ storage: 'firestore' }` call. Mirrors
+        // registerCapacitorAdapters(). Without this, a top-level subscribe() issued
+        // before any firestore op never wires up the onSnapshot listener.
+        if (config.firestore || config.realtimeDatabase) {
+            await storage.refreshAdapters();
+        }
         // Firebase sync enabled successfully
     }
     catch (error) {

package/dist/index.d.ts

@@ -18,10 +18,10 @@ export { computeChecksum, verifyChecksum } from "./features/integrity.js";
 export { MigrationManager } from "./features/migration.js";
 export type { Migration } from "./features/migration.js";
 export { StrataError, StorageError, IntegrityError, QuotaExceededError, EncryptionError, CompressionError, SerializationError, ValidationError, NotSupportedError, AdapterNotAvailableError, } from "./utils/errors.js";
-export type { StorageType, StorageOptions, StorageValue, StorageAdapter, AdapterConfig, QueryOptions, SyncConfig, EncryptionConfig, CompressionConfig, ObserverCallback, StorageEvent, StorageCapabilities, StorageMetadata, TTLConfig, StrataConfig, StorageChange, SubscriptionCallback, UnsubscribeFunction, } from "./types.js";
+export type { StorageType, StorageOptions, StorageValue, StorageAdapter, AdapterConfig, QueryOptions, SyncConfig, EncryptionConfig, CompressionConfig, ObserverCallback, StorageEvent, StorageCapabilities, StorageMetadata, TTLConfig, StrataConfig, StorageChange, SubscriptionCallback, UnsubscribeFunction, } from "./types/index.js";
 export { isValidKey, isValidValue, serializeValue, deserializeValue, generateId, createError, retry, debounce, throttle, } from "./utils/index.js";
 import { Strata } from "./core/Strata.js";
-import type { StrataConfig } from "./types.js";
+import type { StrataConfig } from "./types/index.js";
 /**
  * Register the standard web storage adapters on a Strata instance: memory,
  * localStorage, sessionStorage, indexedDB, cookies, and cache. Exported so any
@@ -55,4 +55,3 @@ declare const storage: Strata;
 declare function ensureInitialized(): Promise<void>;
 export { storage, ensureInitialized };
 export default storage;
-//# sourceMappingURL=index.d.ts.map

package/dist/integrations/angular/index.d.ts

@@ -155,4 +155,3 @@ export declare class StrataModule {
  */
 export declare function provideStrata(instanceOrConfig?: Strata | StrataConfig): Provider[];
 export type { Strata, StrataConfig, StorageOptions, StorageChange };
-//# sourceMappingURL=index.d.ts.map

package/dist/integrations/index.d.ts

@@ -12,4 +12,3 @@
  * Angular:
  * import { StrataModule, StrataService } from 'strata-storage/angular';
  */
-//# sourceMappingURL=index.d.ts.map

package/dist/integrations/react/index.d.ts

@@ -72,4 +72,3 @@ export declare function useStorageTTL(key: string, options?: StorageOptions): {
     persist: () => Promise<void>;
 };
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/integrations/vue/index.d.ts

@@ -100,4 +100,3 @@ export declare function createStrataComposables(strata: Strata): {
     };
 };
 export type { Strata, StrataConfig, StorageOptions };
-//# sourceMappingURL=index.d.ts.map