@dereekb/firebase 13.6.5 → 13.6.7

package/src/lib/common/firestore/cache/cache.memory.d.ts

@@ -0,0 +1,187 @@
+import { type Observable } from 'rxjs';
+import { type Maybe, type Milliseconds } from '@dereekb/util';
+import { type FirestoreCollectionType } from '../collection/collection';
+import { type FirestoreModelKey } from '../collection/collection';
+import { type FirestoreContextCacheFactory, type FirestoreCacheEntry, type FirestoreCacheEvent, type FirestoreContextCache } from './cache';
+/**
+ * Default TTL used by the in-memory cache when no TTL is specified.
+ *
+ * Set to 5 minutes.
+ */
+export declare const IN_MEMORY_CACHE_DEFAULT_TTL: Milliseconds;
+/**
+ * Delegate that handles actual cache storage for a single collection.
+ *
+ * Implementations provide the storage mechanism (e.g. in-memory Map, no storage for logging).
+ * The shared {@link makeFirestoreCollectionCache} handles TTL checking, event emission,
+ * and enabled/disabled state around the delegate.
+ *
+ * @template T - The document data type
+ */
+export interface FirestoreCollectionCacheDelegate<T> {
+    /**
+     * Gets a raw cached entry by key, without TTL or enabled checks.
+     */
+    get(key: FirestoreModelKey): Maybe<FirestoreCacheEntry<T>>;
+    /**
+     * Stores a cache entry by key.
+     */
+    set(key: FirestoreModelKey, entry: FirestoreCacheEntry<T>): void;
+    /**
+     * Deletes a cache entry by key.
+     */
+    delete(key: FirestoreModelKey): void;
+    /**
+     * Clears all entries.
+     */
+    clear(): void;
+}
+/**
+ * Creates an in-memory {@link FirestoreCollectionCacheDelegate} backed by a Map.
+ *
+ * @example
+ * ```ts
+ * const delegate = inMemoryFirestoreCollectionCacheDelegate<UserData>();
+ * ```
+ */
+export declare function inMemoryFirestoreCollectionCacheDelegate<T>(): FirestoreCollectionCacheDelegate<T>;
+/**
+ * Creates a no-storage {@link FirestoreCollectionCacheDelegate} that discards all data.
+ *
+ * Used by {@link readLoggingFirestoreContextCache} where only event emission matters.
+ *
+ * @example
+ * ```ts
+ * const delegate = noopFirestoreCollectionCacheDelegate<UserData>();
+ * ```
+ */
+export declare function noopFirestoreCollectionCacheDelegate<T>(): FirestoreCollectionCacheDelegate<T>;
+/**
+ * Configuration for {@link makeFirestoreContextCache}.
+ */
+export interface MakeFirestoreContextCacheConfig {
+    /**
+     * Default TTL applied to all collections unless overridden per-collection.
+     */
+    readonly defaultTtl: Milliseconds;
+    /**
+     * Creates a delegate for a new collection cache.
+     *
+     * Called once per collection type when the cache is first requested.
+     */
+    readonly createDelegate: <T>(collectionType: FirestoreCollectionType) => FirestoreCollectionCacheDelegate<T>;
+    /**
+     * Optional function that transforms the raw events observable before it is exposed as `events$`.
+     *
+     * Can be used to filter, map, or augment events. For example, the read-logging cache
+     * uses this to filter out 'miss' events since they are expected and not meaningful.
+     *
+     * When not provided, the raw events observable is used directly.
+     */
+    readonly mapEvents$?: (events$: Observable<FirestoreCacheEvent>) => Observable<FirestoreCacheEvent>;
+}
+/**
+ * Creates a {@link FirestoreContextCache} with shared event handling, enable/disable controls,
+ * and per-type management. The actual cache storage for each collection is handled by
+ * delegates created via {@link MakeFirestoreContextCacheConfig.createDelegate}.
+ *
+ * This is the shared foundation used by both {@link inMemoryFirestoreContextCache} and
+ * {@link readLoggingFirestoreContextCache}.
+ *
+ * @param config - Configuration including default TTL and delegate factory
+ * @returns A new context cache
+ *
+ * @example
+ * ```ts
+ * const contextCache = makeFirestoreContextCache({
+ *   defaultTtl: 60000,
+ *   createDelegate: () => inMemoryFirestoreCollectionCacheDelegate()
+ * });
+ * ```
+ */
+export declare function makeFirestoreContextCache(config: MakeFirestoreContextCacheConfig): FirestoreContextCache;
+/**
+ * Creates a {@link FirestoreContextCacheFactory} that stores cached documents in memory.
+ *
+ * Uses simple Map-based storage with TTL-based expiration. Suitable for
+ * client-side caching where the application lifecycle matches the cache lifecycle.
+ *
+ * @returns A factory function that creates in-memory context caches
+ *
+ * @example
+ * ```ts
+ * const factory = inMemoryFirestoreContextCacheFactory();
+ * const contextCache = factory({ defaultTtl: 60000 });
+ * ```
+ */
+export declare function inMemoryFirestoreContextCacheFactory(): FirestoreContextCacheFactory;
+/**
+ * Configuration for creating an in-memory {@link FirestoreContextCache}.
+ */
+export interface InMemoryFirestoreContextCacheConfig {
+    /**
+     * Default TTL applied to all collections unless overridden per-collection.
+     */
+    readonly defaultTtl?: Milliseconds;
+}
+/**
+ * Creates an in-memory {@link FirestoreContextCache} that manages per-collection
+ * caches with TTL-based expiration, per-type enable/disable, and event streaming.
+ *
+ * @param config - Optional configuration
+ * @returns A new context cache
+ *
+ * @example
+ * ```ts
+ * const contextCache = inMemoryFirestoreContextCache({ defaultTtl: 60000 });
+ * const userCache = contextCache.cacheForCollection<UserData>('user', { defaultTtl: 30000 });
+ * userCache.set('users/abc', { data: userData });
+ * ```
+ */
+export declare function inMemoryFirestoreContextCache(config?: InMemoryFirestoreContextCacheConfig): FirestoreContextCache;
+/**
+ * Creates a {@link FirestoreContextCacheFactory} that emits events for all cache interactions
+ * but does not actually store any data.
+ *
+ * Useful for analytics, debugging, and monitoring read patterns without the
+ * memory overhead of actual caching.
+ *
+ * @returns A factory function that creates read-logging context caches
+ *
+ * @example
+ * ```ts
+ * const factory = readLoggingFirestoreContextCacheFactory();
+ * const contextCache = factory();
+ * contextCache.events$.subscribe((event) => console.log(event));
+ * ```
+ */
+export declare function readLoggingFirestoreContextCacheFactory(): FirestoreContextCacheFactory;
+/**
+ * Configuration for creating a read-logging {@link FirestoreContextCache}.
+ */
+export interface ReadLoggingFirestoreContextCacheConfig {
+    /**
+     * Default TTL applied to all collections. Since no data is stored,
+     * this only affects what gets reported as a "miss" vs "hit" (always miss).
+     */
+    readonly defaultTtl?: Milliseconds;
+}
+/**
+ * Creates a {@link FirestoreContextCache} that emits events for all cache interactions
+ * but does not actually store any data. Every `get()` call results in a 'miss' event.
+ *
+ * Useful for tracking read patterns, debugging, and monitoring which documents
+ * are accessed and how often, without the memory overhead of actual caching.
+ *
+ * @param config - Optional configuration
+ * @returns A new read-logging context cache
+ *
+ * @example
+ * ```ts
+ * const contextCache = readLoggingFirestoreContextCache();
+ * contextCache.events$.subscribe((event) => {
+ *   console.log(`${event.type}: ${event.collectionType} ${event.key}`);
+ * });
+ * ```
+ */
+export declare function readLoggingFirestoreContextCache(config?: ReadLoggingFirestoreContextCacheConfig): FirestoreContextCache;

package/src/lib/common/firestore/cache/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cache';
+export * from './cache.memory';

package/src/lib/common/firestore/collection/collection.d.ts

@@ -3,6 +3,7 @@ import { type FirestoreDocument, type FirestoreDocumentAccessorFactory, type Fir
 import { type FirestoreItemPageIterationBaseConfig, type FirestoreItemPageIterationFactory } from '../query/iterator';
 import { type FirestoreQueryFactory } from '../query/query';
 import { type FirestoreDrivers } from '../driver/driver';
+import { type FirestoreCollectionCacheRef, type FirestoreCollectionCacheConfig } from '../cache/cache';
 import { type FirestoreCollectionQueryFactory } from './collection.query';
 import { type ArrayOrValue, type Maybe, type ModelKey, type ModelTypeString } from '@dereekb/util';
 /**
@@ -570,12 +571,12 @@ export interface FirestoreModelKeyRef {
  * @template D - The concrete FirestoreDocument subclass
  * @template A - The accessor type (limited or full)
  */
-export interface FirestoreCollectionLike<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>> extends FirestoreContextReference, FirestoreModelIdentityRef, QueryLikeReferenceRef<T>, FirestoreItemPageIterationFactory<T>, FirestoreQueryFactory<T>, LimitedFirestoreDocumentAccessorFactory<T, D, A>, LimitedFirestoreDocumentAccessorForTransactionFactory<T, D, A>, LimitedFirestoreDocumentAccessorForWriteBatchFactory<T, D, A>, FirestoreCollectionQueryFactory<T, D> {
+export interface FirestoreCollectionLike<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>> extends FirestoreContextReference, FirestoreModelIdentityRef, QueryLikeReferenceRef<T>, FirestoreItemPageIterationFactory<T>, FirestoreQueryFactory<T>, LimitedFirestoreDocumentAccessorFactory<T, D, A>, LimitedFirestoreDocumentAccessorForTransactionFactory<T, D, A>, LimitedFirestoreDocumentAccessorForWriteBatchFactory<T, D, A>, FirestoreCollectionQueryFactory<T, D>, FirestoreCollectionCacheRef<T> {
 }
 /**
  * FirestoreCollection configuration
  */
-export interface FirestoreCollectionConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends FirestoreContextReference, FirestoreDrivers, Omit<FirestoreItemPageIterationBaseConfig<T>, 'queryLike'>, Partial<QueryLikeReferenceRef<T>>, FirestoreDocumentAccessorFactoryConfig<T, D> {
+export interface FirestoreCollectionConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends FirestoreContextReference, FirestoreDrivers, Omit<FirestoreItemPageIterationBaseConfig<T>, 'queryLike'>, Partial<QueryLikeReferenceRef<T>>, FirestoreDocumentAccessorFactoryConfig<T, D>, Partial<FirestoreCollectionCacheConfig> {
 }
 /**
  * Full Firestore collection interface with document CRUD, querying, iteration, and context support.

package/src/lib/common/firestore/collection/collection.group.d.ts

@@ -1,4 +1,5 @@
 import { type FirestoreDocument, type LimitedFirestoreDocumentAccessorFactoryConfig } from '../accessor/document';
+import { type FirestoreCollectionCacheConfig } from '../cache/cache';
 import { type FirestoreItemPageIterationBaseConfig } from '../query/iterator';
 import { type FirestoreContextReference } from '../reference';
 import { type FirestoreDrivers } from '../driver/driver';
@@ -14,7 +15,7 @@ import { type FirestoreCollectionLike } from './collection';
  * @template T - The data type of the documents in the collection group
  * @template D - The FirestoreDocument type that wraps the data, defaults to FirestoreDocument<T>
  */
-export interface FirestoreCollectionGroupConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends FirestoreContextReference, FirestoreDrivers, FirestoreItemPageIterationBaseConfig<T>, LimitedFirestoreDocumentAccessorFactoryConfig<T, D> {
+export interface FirestoreCollectionGroupConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends FirestoreContextReference, FirestoreDrivers, FirestoreItemPageIterationBaseConfig<T>, LimitedFirestoreDocumentAccessorFactoryConfig<T, D>, Partial<FirestoreCollectionCacheConfig> {
 }
 /**
  * Interface for working with documents across a Firestore collection group.

package/src/lib/common/firestore/context.d.ts

@@ -1,5 +1,6 @@
 import { type FirestoreDocument, type SingleItemFirestoreCollectionDocumentIdentifierRef } from './accessor/document';
 import { type FirestoreCollection, type FirestoreCollectionConfig, type FirestoreCollectionWithParent, type SingleItemFirestoreCollection, type FirestoreCollectionGroup, type RootSingleItemFirestoreCollection } from './collection';
+import { type FirestoreContextCacheFactoryRef, type FirestoreContextCacheRef } from './cache/cache';
 import { type FirestoreDrivers } from './driver/driver';
 import { type WriteBatchFactoryReference, type RunTransactionFactoryReference } from './driver';
 import { type DocumentReference, type CollectionReference, type DocumentData, type Firestore, type CollectionGroup } from './types';
@@ -17,7 +18,7 @@ import { type QueryLikeReferenceRef } from './reference';
  *
  * @template F - The Firestore implementation type (defaults to standard Firestore)
  */
-export interface FirestoreContext<F extends Firestore = Firestore> extends RunTransactionFactoryReference, WriteBatchFactoryReference {
+export interface FirestoreContext<F extends Firestore = Firestore> extends RunTransactionFactoryReference, WriteBatchFactoryReference, FirestoreContextCacheRef {
     /**
      * The underlying Firestore instance.
      */
@@ -113,7 +114,7 @@ export interface FirestoreContext<F extends Firestore = Firestore> extends RunTr
  * @template T - The document data type in the collection
  * @template D - The FirestoreDocument implementation type
  */
-export type FirestoreContextFirestoreCollectionConfig<T, D extends FirestoreDocument<T>> = Omit<FirestoreCollectionConfig<T, D>, 'firestoreDriverIdentifier' | 'firestoreDriverType' | 'firestoreQueryDriver' | 'firestoreAccessorDriver'>;
+export type FirestoreContextFirestoreCollectionConfig<T, D extends FirestoreDocument<T>> = Omit<FirestoreCollectionConfig<T, D>, 'firestoreDriverIdentifier' | 'firestoreDriverType' | 'firestoreQueryDriver' | 'firestoreAccessorDriver' | 'cache'>;
 /**
  * Configuration for creating a RootSingleItemFirestoreCollection through a FirestoreContext.
  *
@@ -165,17 +166,34 @@ export interface FirestoreContextFirestoreCollectionWithParentConfig<T, PT, D ex
  */
 export interface FirestoreContextSingleItemFirestoreCollectionConfig<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> extends FirestoreContextFirestoreCollectionWithParentConfig<T, PT, D, PD>, Partial<SingleItemFirestoreCollectionDocumentIdentifierRef> {
 }
+/**
+ * Optional parameters for {@link FirestoreContextFactory} that configure context-level
+ * features like caching. These are separate from the platform drivers because they
+ * are app-level concerns, not platform-level concerns.
+ *
+ * @example
+ * ```ts
+ * const params: FirestoreContextFactoryParams = {
+ *   firestoreContextCacheFactory: inMemoryFirestoreContextCacheFactory()
+ * };
+ * const context = contextFactory(firestore, params);
+ * ```
+ */
+export interface FirestoreContextFactoryParams extends FirestoreContextCacheFactoryRef {
+}
 /**
  * Factory function type for creating FirestoreContext instances.
  *
- * Takes a Firestore instance and returns a fully configured FirestoreContext that wraps
- * the instance and provides additional functionality through the context interface.
+ * Takes a Firestore instance and optional params, and returns a fully configured
+ * FirestoreContext. The params allow app-level configuration (e.g. caching) to be
+ * provided at the DI injection site rather than at driver creation time.
  *
  * @template F - The Firestore implementation type
  * @param firestore - The Firestore instance to wrap
+ * @param params - Optional context-level configuration (e.g. cache factory)
  * @returns A FirestoreContext instance for the specified Firestore
  */
-export type FirestoreContextFactory<F extends Firestore = Firestore> = (firestore: F) => FirestoreContext;
+export type FirestoreContextFactory<F extends Firestore = Firestore> = (firestore: F, params?: FirestoreContextFactoryParams) => FirestoreContext;
 /**
  * Creates a factory function for generating FirestoreContext instances.
  *

package/src/lib/common/firestore/index.d.ts

@@ -1,4 +1,5 @@
 export * from './accessor';
+export * from './cache';
 export * from './snapshot';
 export * from './error';
 export * from './query';

package/test/index.cjs.js

@@ -1,10 +1,10 @@
 'use strict';
 
 var util = require('@dereekb/util');
-var test = require('@dereekb/util/test');
 var rulesUnitTesting = require('@firebase/rules-unit-testing');
 var firebase = require('@dereekb/firebase');
 var firestore = require('firebase/firestore');
+var test = require('@dereekb/util/test');
 var rxjs$1 = require('rxjs');
 var rxjs = require('@dereekb/rxjs');
 var dateFns = require('date-fns');
@@ -938,71 +938,113 @@ function _ts_generator$5(thisArg, body) {
  * A TestContextBuilderFunction for building firebase test context factories using @firebase/firebase and @firebase/rules-unit-testing. This means CLIENT TESTING ONLY. For server testing, look at @dereekb/firestore-server.
  *
  * This can be used to easily build a testing context that sets up RulesTestEnvironment for tests that sets itself up and tears itself down.
- */ var firebaseRulesUnitTestBuilder = test.testContextBuilder({
-    buildConfig: function buildConfig(input) {
-        var _ref;
-        var config = {
-            testEnvironment: (_ref = input === null || input === void 0 ? void 0 : input.testEnvironment) !== null && _ref !== void 0 ? _ref : {},
-            rulesContext: input === null || input === void 0 ? void 0 : input.rulesContext
-        };
-        return config;
-    },
-    buildFixture: function buildFixture() {
-        return new RulesUnitTestFirebaseTestingContextFixture();
-    },
-    setupInstance: function setupInstance(config) {
-        return _async_to_generator$5(function() {
-            var drivers, testEnvironment, rulesTestEnv, rulesTestContext;
-            return _ts_generator$5(this, function(_state) {
-                switch(_state.label){
-                    case 0:
+ *
+ * The {@link RulesTestEnvironment} is initialized once per test suite (`beforeAll`) and cleaned up
+ * once (`afterAll`), while fresh drivers and a {@link RulesTestContext} are created per test (`beforeEach`). This avoids
+ * repeated calls to `initializeTestEnvironment` (which hits the emulator's `PUT /internal/setRules` endpoint),
+ * preventing interference between parallel workers sharing the same Firebase Storage emulator. The Storage
+ * emulator maintains rules globally (not per-project), so concurrent `setRules` calls from multiple workers
+ * can momentarily leave the emulator in a transitional state that causes `storage/unauthorized` errors.
+ */ var firebaseRulesUnitTestBuilder = function firebaseRulesUnitTestBuilder(inputConfig) {
+    var _ref;
+    var config = {
+        testEnvironment: (_ref = inputConfig === null || inputConfig === void 0 ? void 0 : inputConfig.testEnvironment) !== null && _ref !== void 0 ? _ref : {},
+        rulesContext: inputConfig === null || inputConfig === void 0 ? void 0 : inputConfig.rulesContext
+    };
+    return function(buildTests) {
+        var fixture = new RulesUnitTestFirebaseTestingContextFixture();
+        var rulesTestEnvironment;
+        // Initialize the emulator environment once per test suite.
+        // This is the expensive operation that hits the emulator's REST API (e.g. PUT /internal/setRules).
+        beforeAll(function() {
+            return _async_to_generator$5(function() {
+                return _ts_generator$5(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                rulesUnitTesting.initializeTestEnvironment(config.testEnvironment)
+                            ];
+                        case 1:
+                            rulesTestEnvironment = _state.sent();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        // Clean up the emulator environment once after all tests complete.
+        afterAll(function() {
+            return _async_to_generator$5(function() {
+                return _ts_generator$5(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            if (!rulesTestEnvironment) return [
+                                3,
+                                2
+                            ];
+                            return [
+                                4,
+                                rulesTestEnvironment.cleanup().catch(function(e) {
+                                    console.warn('firebaseRulesUnitTestBuilder(): Failed to cleanup rules test environment', e);
+                                    throw e;
+                                })
+                            ];
+                        case 1:
+                            _state.sent();
+                            _state.label = 2;
+                        case 2:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        });
+        // Create fresh drivers and RulesTestContext per test.
+        // Drivers are recreated per test because the Firestore testing driver fuzzes collection names
+        // (via makeTestingFirestoreAccesorDriver) to provide data isolation between tests.
+        var clearInstance = null;
+        beforeEach(function() {
+            return _async_to_generator$5(function() {
+                var drivers, rulesTestContext, instance;
+                return _ts_generator$5(this, function(_state) {
+                    try {
                         drivers = _object_spread$1({}, makeTestingFirestoreDrivers(firebase.firebaseFirestoreClientDrivers()), makeTestingFirebaseStorageDrivers(firebase.firebaseStorageClientDrivers(), {
                             useTestDefaultBucket: true
                         }));
-                        testEnvironment = config.testEnvironment;
                         if (config.testEnvironment.collectionNames) {
                             drivers.firestoreAccessorDriver.initWithCollectionNames(config.testEnvironment.collectionNames);
-                            testEnvironment = _object_spread_props(_object_spread$1({}, testEnvironment), {
-                                firestore: rewriteEmulatorConfigRulesForFuzzedCollectionNames(testEnvironment.firestore)
-                            });
                         }
-                        return [
-                            4,
-                            rulesUnitTesting.initializeTestEnvironment(config.testEnvironment)
-                        ];
-                    case 1:
-                        rulesTestEnv = _state.sent();
-                        rulesTestContext = rulesTestContextForConfig(rulesTestEnv, config.rulesContext);
-                        return [
-                            2,
-                            new RulesUnitTestTestFirebaseInstance(drivers, rulesTestEnv, rulesTestContext)
-                        ];
-                }
-            });
-        })();
-    },
-    teardownInstance: function teardownInstance(instance, config) {
-        return _async_to_generator$5(function() {
-            return _ts_generator$5(this, function(_state) {
-                switch(_state.label){
-                    case 0:
-                        return [
-                            4,
-                            instance.rulesTestEnvironment.cleanup().catch(function(e) {
-                                console.warn('firebaseRulesUnitTestBuilder(): Failed to cleanup rules test environment', e);
-                                throw e;
-                            })
-                        ];
-                    case 1:
-                        _state.sent();
-                        return [
-                            2
-                        ];
-                }
-            });
-        })();
-    }
-});
+                        rulesTestContext = rulesTestContextForConfig(rulesTestEnvironment, config.rulesContext);
+                        instance = new RulesUnitTestTestFirebaseInstance(drivers, rulesTestEnvironment, rulesTestContext);
+                        clearInstance = fixture.setInstance(instance);
+                    } catch (e) {
+                        console.error('firebaseRulesUnitTestBuilder(): Failed building a test instance. Error: ', e);
+                        if (clearInstance) {
+                            clearInstance();
+                            clearInstance = null;
+                        }
+                        throw e;
+                    }
+                    return [
+                        2
+                    ];
+                });
+            })();
+        });
+        // Declare tests
+        buildTests(fixture);
+        // Clear the instance reference after each test.
+        afterEach(function() {
+            if (clearInstance) {
+                clearInstance();
+                clearInstance = null;
+            }
+        });
+    };
+};
 // MARK: Internal
 function rulesTestContextForConfig(rulesTestEnv, testingRulesConfig) {
     var rulesTestContext;
@@ -1014,18 +1056,6 @@ function rulesTestContextForConfig(rulesTestEnv, testingRulesConfig) {
     }
     return rulesTestContext;
 }
-function rewriteEmulatorConfigRulesForFuzzedCollectionNames(config, fuzzedCollectionNamesMap) {
-    if (config && config.rules) {
-        config = _object_spread_props(_object_spread$1({}, config), {
-            rules: rewriteRulesForFuzzedCollectionNames(config.rules)
-        });
-    }
-    return config;
-}
-function rewriteRulesForFuzzedCollectionNames(rules, fuzzedCollectionNamesMap) {
-    // TODO: rewrite the rules using regex matching/replacement.
-    return rules;
-}
 // MARK: Utility
 /**
  * Registers `beforeAll`/`afterAll` hooks to suppress verbose Firestore log output during tests.
@@ -1044,24 +1074,56 @@ function rewriteRulesForFuzzedCollectionNames(rules, fuzzedCollectionNamesMap) {
 /**
  * Default user ID used for the authenticated context in client-side Firebase tests.
  */ var TESTING_AUTHORIZED_FIREBASE_USER_ID = '0';
+/**
+ * Permissive Firestore security rules that allow all reads and writes.
+ */ var AUTHORIZED_FIRESTORE_RULES = "\nrules_version = '2';\nservice cloud.firestore {\n  match /databases/{database}/documents {\n    match /{document=**} {\n      allow read, write: if true;\n    }\n  }\n}\n";
+/**
+ * Permissive Firebase Storage security rules that allow all reads and writes.
+ */ var AUTHORIZED_STORAGE_RULES = "\nrules_version = '2';\nservice firebase.storage {\n  match /b/{bucket}/o {\n    match /{allPaths=**} {\n      allow read, write: if true;\n    }\n  }\n}\n";
 /**
  * Pre-configured {@link FirebaseTestContextFactory} that provides a fully authorized (all reads/writes allowed)
  * Firebase emulator context for both Firestore and Storage.
  *
  * Uses permissive security rules and authenticates as {@link TESTING_AUTHORIZED_FIREBASE_USER_ID}.
- * This is the most common base factory for client-side mock item tests.
+ *
+ * **Important:** Only use this factory for tests that actually need Firebase Storage access.
+ * Firestore-only tests should use {@link authorizedFirestoreOnlyFactory} instead to avoid
+ * interfering with the storage emulator's global rules endpoint during parallel test execution.
  *
  * @example
  * ```ts
- * const f = testWithMockItemCollectionFixture()(authorizedFirebaseFactory);
+ * const f = testWithMockItemStorageFixture()(authorizedFirebaseFactory);
  * ```
  */ var authorizedFirebaseFactory = firebaseRulesUnitTestBuilder({
     testEnvironment: {
         firestore: {
-            rules: "\n      rules_version = '2';\n      service cloud.firestore {\n        match /databases/{database}/documents {\n          match /{document=**} {\n            allow read, write: if true;\n          }\n        }\n      }\n      "
+            rules: AUTHORIZED_FIRESTORE_RULES
         },
         storage: {
-            rules: "\n      rules_version = '2';\n      service firebase.storage {\n        match /b/{bucket}/o {\n          match /{allPaths=**} {\n            allow read, write: if true;\n          }\n        }\n      }\n      "
+            rules: AUTHORIZED_STORAGE_RULES
+        }
+    },
+    rulesContext: {
+        userId: TESTING_AUTHORIZED_FIREBASE_USER_ID
+    }
+});
+/**
+ * Pre-configured {@link FirebaseTestContextFactory} that provides a fully authorized Firestore-only
+ * emulator context without configuring Storage rules.
+ *
+ * Use this for Firestore-only tests when running with parallel workers. The Firebase Storage
+ * emulator maintains rules globally (not per-project like Firestore), so `initializeTestEnvironment`
+ * calls that include storage rules from non-storage workers will hit `PUT /internal/setRules`
+ * concurrently, which can cause transient `storage/unauthorized` errors in the storage test worker.
+ *
+ * @example
+ * ```ts
+ * const f = testWithMockItemCollectionFixture()(authorizedFirestoreOnlyFactory);
+ * ```
+ */ var authorizedFirestoreOnlyFactory = firebaseRulesUnitTestBuilder({
+    testEnvironment: {
+        firestore: {
+            rules: AUTHORIZED_FIRESTORE_RULES
         }
     },
     rulesContext: {
@@ -2135,8 +2197,11 @@ function _is_native_reflect_construct$2() {
 /**
  * Convenience mock instance for collection tests within an authorized firebase context.
  *
+ * Uses {@link authorizedFirestoreOnlyFactory} to avoid touching the Storage emulator's
+ * global rules endpoint, preventing interference with parallel storage test workers.
+ *
  * Uses @firebase/firestore. This is ONLY for the client.
- */ var authorizedTestWithMockItemCollection = testWithMockItemCollectionFixture()(authorizedFirebaseFactory);
+ */ var authorizedTestWithMockItemCollection = testWithMockItemCollectionFixture()(authorizedFirestoreOnlyFactory);
 /**
  * Convenience mock instance for storage tests within an authorized firebase context.
  *
@@ -12483,6 +12548,8 @@ function _ts_generator(thisArg, body) {
     });
 }
 
+exports.AUTHORIZED_FIRESTORE_RULES = AUTHORIZED_FIRESTORE_RULES;
+exports.AUTHORIZED_STORAGE_RULES = AUTHORIZED_STORAGE_RULES;
 exports.MOCK_FIREBASE_MODEL_SERVICE_FACTORIES = MOCK_FIREBASE_MODEL_SERVICE_FACTORIES;
 exports.MOCK_SYSTEM_STATE_TYPE = MOCK_SYSTEM_STATE_TYPE;
 exports.MockItemCollectionFixture = MockItemCollectionFixture;
@@ -12506,6 +12573,7 @@ exports.TestFirestoreContextFixture = TestFirestoreContextFixture;
 exports.TestFirestoreInstance = TestFirestoreInstance;
 exports.allChildMockItemSubItemDeepsWithinMockItem = allChildMockItemSubItemDeepsWithinMockItem;
 exports.authorizedFirebaseFactory = authorizedFirebaseFactory;
+exports.authorizedFirestoreOnlyFactory = authorizedFirestoreOnlyFactory;
 exports.authorizedTestWithMockItemCollection = authorizedTestWithMockItemCollection;
 exports.authorizedTestWithMockItemStorage = authorizedTestWithMockItemStorage;
 exports.changeFirestoreLogLevelBeforeAndAfterTests = changeFirestoreLogLevelBeforeAndAfterTests;