@vacantthinker/firefox-addon-framework-easy 2026.625.1220 → 2026.625.1620

package/dist/BaseArrayORM.d.ts

@@ -1,2 +1,37 @@
-export {};
+import { BaseObjectORM } from './BaseObjectORM';
+/**
+ * Abstract class for ORMs that store an Array of items (T[]).
+ * Includes atomic mutation methods to prevent race conditions.
+ */
+export declare abstract class BaseArrayORM<T> extends BaseObjectORM<T[]> {
+    private mutationQueue;
+    protected constructor(prefix: string, id: string);
+    /**
+     * Retrieves the current array. Returns a copy to prevent accidental
+     * by-reference mutations outside the ORM.
+     */
+    getArray(): Promise<T[]>;
+    /**
+     * Safely appends a new item to the array without race conditions.
+     */
+    push(item: T): Promise<void>;
+    /**
+     * Safely appends multiple items.
+     */
+    pushMany(items: T[]): Promise<void>;
+    /**
+     * Removes items that match the provided predicate function.
+     * @returns {Promise<number>} The number of items removed.
+     */
+    remove(predicate: (item: T) => boolean): Promise<number>;
+    /**
+     * Completely clears the array.
+     */
+    clearArray(): Promise<void>;
+    /**
+     * Internal mechanism to queue array mutations sequentially.
+     * Guarantees that concurrent pushes do not result in lost updates.
+     */
+    private mutateArray;
+}
 //# sourceMappingURL=BaseArrayORM.d.ts.map

package/dist/BaseArrayORM.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseArrayORM.d.ts","sourceRoot":"","sources":["../src/BaseArrayORM.ts"],"names":[],"mappings":""}
+{"version":3,"file":"BaseArrayORM.d.ts","sourceRoot":"","sources":["../src/BaseArrayORM.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;GAGG;AACH,8BAAsB,YAAY,CAAC,CAAC,CAAE,SAAQ,aAAa,CAAC,CAAC,EAAE,CAAC;IAG9D,OAAO,CAAC,aAAa,CAAoC;IAEzD,SAAS,aAAa,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAMhD;;;OAGG;IACU,QAAQ,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC;IAKrC;;OAEG;IACU,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAOzC;;OAEG;IACU,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAMhD;;;OAGG;IACU,MAAM,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAWrE;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxC;;;OAGG;YACW,WAAW;CAuB1B"}

package/dist/BaseArrayORM.js

@@ -1,86 +1,84 @@
-import { stoOpCheck, stoOpGet, stoOpRem, stoOpSet } from './opStorage';
+import { BaseObjectORM } from './BaseObjectORM';
 /**
- * Abstract base class BaseORM.
- * Provides encapsulated CRUD operations for JSON-serializable
- * Key-Value pairs. Uses Generics (T) to ensure type safety for
- * the stored object structure.
+ * Abstract class for ORMs that store an Array of items (T[]).
+ * Includes atomic mutation methods to prevent race conditions.
  */
-// FIX: Expand constraint to 'any[]' so TabMessageStorageData (an
-// array of tuples) is permitted.
-class BaseArrayORM {
-    id;
-    storageKey;
-    defaultValue;
-    // The Mutex "Lock" for preventing race conditions during
-    // initialization
-    initPromise = null;
-    constructor(prefix, id, defaultValue = []) {
-        if (new.target === BaseArrayORM) {
-            throw new TypeError('Cannot construct BaseArayORM' +
-                ' instances directly (Abstract Class).');
-        }
-        if (!prefix || !id) {
-            throw new Error('Both prefix and id must be specified.');
-        }
-        this.id = id;
-        const formattedPrefix = prefix.endsWith(' ') ?
-            prefix :
-            `${prefix} `;
-        this.storageKey = `${formattedPrefix}${id}`;
-        this.defaultValue = structuredClone(defaultValue);
+export class BaseArrayORM extends BaseObjectORM {
+    // A promise queue acting as a Mutex to serialize array mutations
+    mutationQueue = Promise.resolve();
+    constructor(prefix, id) {
+        // Correctly initialize with an empty array.
+        // BaseObjectORM accepts 'any[]' so this is type-safe.
+        super(prefix, id, []);
     }
     /**
-     * Retrieve the value associated with the bound key.
-     * @returns {Promise<T>}
+     * Retrieves the current array. Returns a copy to prevent accidental
+     * by-reference mutations outside the ORM.
      */
-    async get() {
-        if (!(await this.exists())) {
-            // Calls the lock-protected initialization instead of
-            // initDefaultObject directly
-            await this.safeInit();
-        }
-        return (await stoOpGet(this.storageKey));
+    async getArray() {
+        const data = await this.get();
+        return Array.isArray(data) ? [...data] : [];
     }
     /**
-     * Overwrite the value of the bound key completely.
-     * @param {T} value
-     * @returns {Promise<void>}
+     * Safely appends a new item to the array without race conditions.
      */
-    async set(value) {
-        await stoOpSet(this.storageKey, value ?? this.defaultValue);
+    async push(item) {
+        return this.mutateArray(async (currentArray) => {
+            currentArray.push(item);
+            return currentArray;
+        });
     }
     /**
-     * Wipe the bound key from storage.
-     * @returns {Promise<T>}
+     * Safely appends multiple items.
      */
-    async delete() {
-        const previousValue = await this.get();
-        await stoOpRem(this.storageKey);
-        return previousValue;
+    async pushMany(items) {
+        return this.mutateArray(async (currentArray) => {
+            return currentArray.concat(items);
+        });
     }
     /**
-     * Safely initialize the default object. Prevents multiple
-     * concurrent requests from writing the default value
-     * simultaneously.
+     * Removes items that match the provided predicate function.
+     * @returns {Promise<number>} The number of items removed.
      */
-    async safeInit() {
-        // If an initialization is already in progress, wait for it
-        if (this.initPromise) {
-            return this.initPromise;
-        }
-        // Start initialization and store the Promise as the lock
-        this.initPromise = this.initDefaultObject()
-            .finally(() => {
-            // Clear the lock whether the initialization succeeds or
-            // fails
-            this.initPromise = null;
+    async remove(predicate) {
+        let removedCount = 0;
+        await this.mutateArray(async (currentArray) => {
+            const initialLength = currentArray.length;
+            const filtered = currentArray.filter((item) => !predicate(item));
+            removedCount = initialLength - filtered.length;
+            return filtered;
         });
-        return this.initPromise;
+        return removedCount;
     }
-    async exists() {
-        return await stoOpCheck(this.storageKey);
+    /**
+     * Completely clears the array.
+     */
+    async clearArray() {
+        await this.set([]);
     }
-    async initDefaultObject() {
-        await stoOpSet(this.storageKey, this.defaultValue);
+    /**
+     * Internal mechanism to queue array mutations sequentially.
+     * Guarantees that concurrent pushes do not result in lost updates.
+     */
+    async mutateArray(mutator) {
+        this.mutationQueue = this.mutationQueue.then(async () => {
+            try {
+                let currentData = await this.get();
+                // Data integrity fallback
+                if (!Array.isArray(currentData)) {
+                    console.warn(`BaseArrayORM: Invalid data type for ${this.storageKey}. Resetting to Array.`);
+                    currentData = [];
+                }
+                const updatedArray = await mutator(currentData);
+                await this.set(updatedArray);
+            }
+            catch (error) {
+                console.error(`BaseArrayORM: Failed to mutate array for ${this.storageKey}`, error);
+                throw error;
+            }
+        }).catch(() => {
+            // Prevents queue deadlocks on individual transaction failures
+        });
+        return this.mutationQueue;
     }
 }

package/dist/BaseOneBooleanORM.d.ts

@@ -1,15 +1,35 @@
 import { BaseObjectORM } from './BaseObjectORM';
+interface BooleanState {
+    state: boolean;
+}
 /**
- * Abstract class for ORMs that store Map<string, V> data.
- * Automatically handles the conversion between internal
- * Record<string, V> and Map<string, V>.
+ * Abstract class for ORMs that store a single boolean state.
+ * Optimized to remove Map overhead and prevent race conditions.
  */
-export declare abstract class BaseOneBooleanORM extends BaseObjectORM<Record<string, boolean>> {
-    private readonly state;
+export declare abstract class BaseOneBooleanORM extends BaseObjectORM<BooleanState> {
+    private readonly stateKey;
+    private writeLock;
     protected constructor(prefix: string, id: string);
+    /**
+     * Retrieves the current boolean value.
+     */
     getValue(): Promise<boolean>;
+    /**
+     * Direct overwrite of the boolean value.
+     * Queued to prevent overwriting a concurrent toggle/update
+     * operation.
+     */
     setValue(value: boolean): Promise<void>;
-    private getMap;
-    private setMap;
+    /**
+     * Safely toggles or updates the value based on the previous
+     * state. This guarantees no race conditions during
+     * Read-Modify-Write cycles.
+     */
+    protected updateValue(updater: (prevValue: boolean) => boolean): Promise<void>;
+    /**
+     * Internal mechanism to queue state changes sequentially.
+     */
+    private atomicUpdate;
 }
+export {};
 //# sourceMappingURL=BaseOneBooleanORM.d.ts.map

package/dist/BaseOneBooleanORM.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseOneBooleanORM.d.ts","sourceRoot":"","sources":["../src/BaseOneBooleanORM.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAE9C;;;;GAIG;AACH,8BAAsB,iBAAkB,SAAQ,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IAEzC,SAAS,aAAa,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAKnC,QAAQ;IAKR,QAAQ,CAAC,KAAK,EAAE,OAAO;YAMtB,MAAM;YAKN,MAAM;CAGrB"}
+{"version":3,"file":"BaseOneBooleanORM.d.ts","sourceRoot":"","sources":["../src/BaseOneBooleanORM.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAG9C,UAAU,YAAY;IACpB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;GAGG;AACH,8BAAsB,iBAAkB,SAAQ,aAAa,CAAC,YAAY,CAAC;IACzE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IAIpC,OAAO,CAAC,SAAS,CAAoC;IAErD,SAAS,aAAa,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAKhD;;OAEG;IACU,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAKzC;;;;OAIG;IACU,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpD;;;;OAIG;cACa,WAAW,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpF;;OAEG;YACW,YAAY;CAoB3B"}

package/dist/BaseOneBooleanORM.js

@@ -1,29 +1,59 @@
 import { BaseObjectORM } from './BaseObjectORM';
 /**
- * Abstract class for ORMs that store Map<string, V> data.
- * Automatically handles the conversion between internal
- * Record<string, V> and Map<string, V>.
+ * Abstract class for ORMs that store a single boolean state.
+ * Optimized to remove Map overhead and prevent race conditions.
  */
 export class BaseOneBooleanORM extends BaseObjectORM {
-    state = "state";
+    stateKey = 'state';
+    // A promise queue acting as a Mutex to serialize write
+    // operations
+    writeLock = Promise.resolve();
     constructor(prefix, id) {
-        super(prefix, id, { "state": false });
-        // todo here cannot use this.state, why?
+        // Pass the default state directly to the parent
+        super(prefix, id, { state: false });
     }
+    /**
+     * Retrieves the current boolean value.
+     */
     async getValue() {
-        const map = await this.getMap();
-        return map.get(this.state) || false;
+        const data = await this.get();
+        return data?.[this.stateKey] ?? false;
     }
+    /**
+     * Direct overwrite of the boolean value.
+     * Queued to prevent overwriting a concurrent toggle/update
+     * operation.
+     */
     async setValue(value) {
-        const map = await this.getMap();
-        map.set(this.state, value);
-        await this.setMap(map);
+        return this.atomicUpdate(() => value);
     }
-    async getMap() {
-        const data = await this.get();
-        return new Map(Object.entries(data || {}));
+    /**
+     * Safely toggles or updates the value based on the previous
+     * state. This guarantees no race conditions during
+     * Read-Modify-Write cycles.
+     */
+    async updateValue(updater) {
+        return this.atomicUpdate(updater);
     }
-    async setMap(map) {
-        await this.set(Object.fromEntries(map));
+    /**
+     * Internal mechanism to queue state changes sequentially.
+     */
+    async atomicUpdate(updater) {
+        this.writeLock = this.writeLock.then(async () => {
+            try {
+                const currentData = await this.get();
+                const currentValue = currentData?.[this.stateKey] ?? false;
+                const newValue = updater(currentValue);
+                await this.set({ [this.stateKey]: newValue });
+            }
+            catch (error) {
+                console.error(`BaseOneBooleanORM: Failed to update state for ${this.storageKey}`, error);
+                throw error;
+            }
+        }).catch(() => {
+            // Catch prevents a single failure from permanently
+            // breaking the queue chain
+        });
+        return this.writeLock;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vacantthinker/firefox-addon-framework-easy",
-  "version": "2026.0625.1220",
+  "version": "2026.0625.1620",
   "description": "",
   "type": "module",
   "main": "dist/index.js",