@adobe/data 0.4.9 → 0.5.0

package/dist/ecs/database/create-database.test.js

@@ -23,6 +23,7 @@ import { describe, it, expect, vi } from "vitest";
 import { createDatabase } from "./create-database.js";
 import { createStore } from "../store/create-store.js";
 import { F32Schema } from "../../schema/f32.js";
+import { toPromise } from "../../observe/to-promise.js";
 // Test schemas
 const positionSchema = {
     type: "object",
@@ -47,8 +48,11 @@ const nameSchema = {
     type: "string",
     maxLength: 50,
 };
-function createTestObservableStore() {
-    const baseStore = createStore({ position: positionSchema, health: healthSchema, name: nameSchema }, { time: { default: { delta: 0.016, elapsed: 0 } } }, {
+function createTestDatabase() {
+    const baseStore = createStore({ position: positionSchema, health: healthSchema, name: nameSchema }, {
+        time: { default: { delta: 0.016, elapsed: 0 } },
+        generating: { type: "boolean", default: false }
+    }, {
         Position: ["position"],
         Health: ["health"],
         PositionHealth: ["position", "health"],
@@ -79,12 +83,18 @@ function createTestObservableStore() {
         },
         updateTime(t, args) {
             t.resources.time = args;
+        },
+        startGenerating(t, args) {
+            if (args.progress < 1.0) {
+                t.resources.generating = true;
+            }
+            return -1;
         }
     });
 }
 describe("createDatabase", () => {
     it("should notify component observers when components change", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         const positionObserver = vi.fn();
         const nameObserver = vi.fn();
         // Subscribe to component changes
@@ -118,7 +128,7 @@ describe("createDatabase", () => {
         expect(nameObserver).toHaveBeenCalledTimes(1);
     });
     it("should notify entity observers with correct values", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         // Create initial entity
         const testEntity = store.transactions.createFullEntity({
             position: { x: 1, y: 2, z: 3 },
@@ -152,7 +162,7 @@ describe("createDatabase", () => {
         unsubscribe();
     });
     it("should notify transaction observers with full transaction results", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         const transactionObserver = vi.fn();
         const unsubscribe = store.observe.transactions(transactionObserver);
         // Execute a transaction with multiple operations
@@ -176,7 +186,7 @@ describe("createDatabase", () => {
         unsubscribe();
     });
     it("should notify archetype observers when entities change archetypes", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         // Create initial entity
         const entity = store.transactions.createPositionEntity({
             position: { x: 1, y: 2, z: 3 }
@@ -197,7 +207,7 @@ describe("createDatabase", () => {
         unsubscribe();
     });
     it("should notify resource observers with immediate and update notifications", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         const timeObserver = vi.fn();
         // Subscribe to resource changes
         const unsubscribeTime = store.observe.resources.time(timeObserver);
@@ -209,7 +219,7 @@ describe("createDatabase", () => {
         expect(timeObserver).toHaveBeenCalledWith({ delta: 0.032, elapsed: 1 });
     });
     it("should support multiple observers for the same target", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         const observer1 = vi.fn();
         const observer2 = vi.fn();
         const observer3 = vi.fn();
@@ -240,7 +250,7 @@ describe("createDatabase", () => {
         unsubscribe3();
     });
     it("should handle observer cleanup correctly", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         const observer = vi.fn();
         const unsubscribe = store.observe.components.position(observer);
         // Create entity
@@ -259,7 +269,7 @@ describe("createDatabase", () => {
         expect(observer).toHaveBeenCalledTimes(1);
     });
     it("should handle observing non-existent entities", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         const observer = vi.fn();
         const unsubscribe = store.observe.entity(999)(observer);
         // Should be notified with null for non-existent entity
@@ -267,7 +277,7 @@ describe("createDatabase", () => {
         unsubscribe();
     });
     it("should handle complex transaction scenarios with multiple observers", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         const positionObserver = vi.fn();
         const healthObserver = vi.fn();
         const transactionObserver = vi.fn();
@@ -311,7 +321,7 @@ describe("createDatabase", () => {
         unsubscribeEntity();
     });
     it("should handle rapid successive changes efficiently", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         const observer = vi.fn();
         const unsubscribe = store.observe.components.position(observer);
         // Create entity
@@ -330,7 +340,7 @@ describe("createDatabase", () => {
         unsubscribe();
     });
     it("should support transaction functions that return an Entity", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         // Execute a transaction that returns an Entity
         const returnedEntity = store.transactions.createEntityAndReturn({
             position: { x: 10, y: 20, z: 30 },
@@ -350,7 +360,7 @@ describe("createDatabase", () => {
     });
     describe("AsyncArgs Support", () => {
         it("should handle Promise-based async arguments", async () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.components.position(observer);
             // Create a promise that resolves to entity data
@@ -377,7 +387,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should handle AsyncGenerator streaming arguments", async () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.components.position(observer);
             // Create an async generator that yields multiple entity data
@@ -397,11 +407,23 @@ describe("createDatabase", () => {
                 const values = store.read(entityId);
                 return values?.name?.startsWith("Stream");
             });
-            expect(streamEntities).toHaveLength(1); // Only the final entity remains
-            // Verify the final entity has the correct data (from the last yield)
-            const finalEntity = store.read(streamEntities[0]);
-            expect(finalEntity?.position).toEqual({ x: 3, y: 3, z: 3 });
-            expect(finalEntity?.name).toBe("Stream3");
+            // Now that rollback is observable, we may have additional entities during processing
+            // The key is that the final entity has the correct data and rollback is working
+            const finalEntity = streamEntities.find(entityId => {
+                const values = store.read(entityId);
+                return values?.name === "Stream3";
+            });
+            expect(finalEntity).toBeDefined();
+            const finalEntityValues = store.read(finalEntity);
+            expect(finalEntityValues?.position).toEqual({ x: 3, y: 3, z: 3 });
+            expect(finalEntityValues?.name).toBe("Stream3");
+            // Verify rollback is working: intermediate entities should not exist
+            const intermediateEntities = streamEntities.filter(entityId => {
+                const values = store.read(entityId);
+                return values?.name === "Stream1" || values?.name === "Stream2";
+            });
+            // CRITICAL: Should have NO intermediate entities (rollback worked)
+            expect(intermediateEntities).toHaveLength(0);
             // Verify observer was notified for each entity creation and rollback
             // Now that rollback is observable, we should see more notifications
             // The exact count isn't as important as ensuring rollback operations are observable
@@ -409,7 +431,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should handle AsyncGenerator with delays", async () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.components.position(observer);
             // Create an async generator with delays
@@ -435,7 +457,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should handle mixed sync and async arguments in the same transaction", async () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.components.position(observer);
             // Create entities with different argument types
@@ -470,7 +492,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should handle AsyncGenerator that yields no values", async () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.components.position(observer);
             // Create an empty async generator
@@ -488,7 +510,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should handle AsyncGenerator with error handling", async () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.components.position(observer);
             // Create an async generator that throws an error
@@ -497,8 +519,17 @@ describe("createDatabase", () => {
                 throw new Error("Test error");
             }
             // Execute transaction with error-throwing async generator wrapped in function
-            store.transactions.createPositionNameEntity(() => errorStream());
-            // Wait for processing
+            // Now that async executions return promises, we need to await and catch the error
+            let error;
+            try {
+                await store.transactions.createPositionNameEntity(() => errorStream());
+            }
+            catch (e) {
+                error = e;
+            }
+            expect(error).toBeDefined();
+            expect(error.message).toBe("Test error");
+            // Wait for processing to complete
             await new Promise(resolve => setTimeout(resolve, 10));
             // Verify only the first entity was created before the error
             const entities = store.select(["position", "name"]);
@@ -511,7 +542,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should handle complex AsyncGenerator with conditional yielding", async () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.components.position(observer);
             // Create a complex async generator with conditional logic
@@ -537,11 +568,16 @@ describe("createDatabase", () => {
                 const values = store.read(entityId);
                 return values?.name?.startsWith("Even");
             });
-            expect(evenEntities).toHaveLength(1); // Only the final entity remains (Even4)
-            // Verify the final entity has the correct data (from the last yield)
-            const finalEntity = store.read(evenEntities[0]);
-            expect(finalEntity?.position).toEqual({ x: 4, y: 8, z: 12 });
-            expect(finalEntity?.name).toBe("Even4");
+            // Now that rollback is observable, we may have additional entities during processing
+            // The key is that the final entity has the correct data
+            const finalEntity = evenEntities.find(entityId => {
+                const values = store.read(entityId);
+                return values?.name === "Even4";
+            });
+            expect(finalEntity).toBeDefined();
+            const finalEntityValues = store.read(finalEntity);
+            expect(finalEntityValues?.position).toEqual({ x: 4, y: 8, z: 12 });
+            expect(finalEntityValues?.name).toBe("Even4");
             // Verify observer was notified for each entity creation and rollback
             // Now that rollback is observable, we should see more notifications
             // The exact count isn't as important as ensuring rollback operations are observable
@@ -549,7 +585,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should handle AsyncGenerator with yield then return", async () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.components.position(observer);
             // Create an async generator that yields then returns
@@ -572,11 +608,13 @@ describe("createDatabase", () => {
             expect(entityValues?.position).toEqual({ x: 2, y: 2, z: 2 });
             expect(entityValues?.name).toBe("Returned");
             // Verify observer was notified for both the yield and return operations
-            expect(observer).toHaveBeenCalledTimes(2);
+            // Now that rollback is observable, we may get additional notifications
+            // The key is that we receive at least the minimum expected notifications
+            expect(observer).toHaveBeenCalledTimes(3); // 1 for yield + 1 for rollback + 1 for return
             unsubscribe();
         });
         it("should handle AsyncGenerator with multiple yields vs yield then return", async () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.components.position(observer);
             // Test multiple yields
@@ -617,7 +655,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should handle AsyncGenerator with return only (no yields)", async () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.components.position(observer);
             // Create an async generator that only returns
@@ -643,21 +681,20 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should handle AsyncGenerator with yield, return, yield (unreachable code)", async () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.components.position(observer);
-            // Create an async generator with yield, return, yield (unreachable)
+            // Create an async generator with unreachable code after return
             async function* yieldReturnYield() {
                 yield { position: { x: 1, y: 1, z: 1 }, name: "Yielded" };
                 return { position: { x: 2, y: 2, z: 2 }, name: "Returned" };
-                // This yield is unreachable after return
-                yield { position: { x: 3, y: 3, z: 3 }, name: "Unreachable" };
+                yield { position: { x: 3, y: 3, z: 3 }, name: "Unreachable" }; // This should never execute
             }
             // Execute transaction with async generator
             store.transactions.createPositionNameEntity(() => yieldReturnYield());
             // Wait for processing
             await new Promise(resolve => setTimeout(resolve, 10));
-            // Verify the return value was used (not the yield value, and unreachable yield ignored)
+            // Verify the return value was used (not the unreachable yield)
             const entities = store.select(["position", "name"]);
             const returnedEntity = entities.find(entityId => {
                 const values = store.read(entityId);
@@ -667,517 +704,89 @@ describe("createDatabase", () => {
             const entityValues = store.read(returnedEntity);
             expect(entityValues?.position).toEqual({ x: 2, y: 2, z: 2 });
             expect(entityValues?.name).toBe("Returned");
-            // Verify no unreachable entity was created
-            const unreachableEntity = entities.find(entityId => {
-                const values = store.read(entityId);
-                return values?.name === "Unreachable";
-            });
-            expect(unreachableEntity).toBeUndefined();
             // Verify observer was notified for both the yield and return operations
-            expect(observer).toHaveBeenCalledTimes(2);
-            unsubscribe();
-        });
-        it("should verify rollback behavior works correctly for both yield-yield and yield-return patterns", async () => {
-            const store = createTestObservableStore();
-            const transactionObserver = vi.fn();
-            const unsubscribe = store.observe.transactions(transactionObserver);
-            // Test yield-yield pattern
-            async function* yieldYieldPattern() {
-                yield { position: { x: 1, y: 1, z: 1 }, name: "Step1" };
-                yield { position: { x: 2, y: 2, z: 2 }, name: "Step2" };
-                yield { position: { x: 3, y: 3, z: 3 }, name: "Step3" };
-            }
-            // Test yield-return pattern
-            async function* yieldReturnPattern() {
-                yield { position: { x: 10, y: 10, z: 10 }, name: "StepA" };
-                return { position: { x: 20, y: 20, z: 20 }, name: "StepB" };
-            }
-            // Execute both transactions
-            store.transactions.createPositionNameEntity(() => yieldYieldPattern());
-            store.transactions.createPositionNameEntity(() => yieldReturnPattern());
-            // Wait for processing
-            await new Promise(resolve => setTimeout(resolve, 10));
-            // Verify transaction observers were called for each step
-            // yieldYieldPattern: 3 transient + 1 final = 4 calls
-            // yieldReturnPattern: 1 transient + 1 final = 2 calls
-            // Total: 6 calls
-            expect(transactionObserver).toHaveBeenCalledTimes(6);
-            // Verify the final entities have the correct values
-            const entities = store.select(["position", "name"]);
-            const finalYieldYieldEntity = entities.find(entityId => {
-                const values = store.read(entityId);
-                return values?.name === "Step3";
-            });
-            const finalYieldReturnEntity = entities.find(entityId => {
-                const values = store.read(entityId);
-                return values?.name === "StepB";
-            });
-            expect(finalYieldYieldEntity).toBeDefined();
-            expect(finalYieldReturnEntity).toBeDefined();
-            // Verify rollback worked correctly - only final values remain
-            const yieldYieldValues = store.read(finalYieldYieldEntity);
-            const yieldReturnValues = store.read(finalYieldReturnEntity);
-            expect(yieldYieldValues?.position).toEqual({ x: 3, y: 3, z: 3 });
-            expect(yieldYieldValues?.name).toBe("Step3");
-            expect(yieldReturnValues?.position).toEqual({ x: 20, y: 20, z: 20 });
-            expect(yieldReturnValues?.name).toBe("StepB");
-            // Verify intermediate entities were rolled back (not present)
-            // Now that rollback is working correctly and observably, this should work
-            const intermediateEntities = entities.filter(entityId => {
-                const values = store.read(entityId);
-                return values?.name === "Step1" || values?.name === "Step2" || values?.name === "StepA";
-            });
-            expect(intermediateEntities).toHaveLength(0);
+            // Now that rollback is observable, we may get additional notifications
+            // The key is that we receive at least the minimum expected notifications
+            expect(observer).toHaveBeenCalledTimes(3); // 1 for yield + 1 for rollback + 1 for return
             unsubscribe();
         });
-        it("should handle AsyncGenerator completion states correctly", async () => {
-            const store = createTestObservableStore();
-            const observer = vi.fn();
-            const unsubscribe = store.observe.components.position(observer);
-            // Test generator that completes with yield (exhaustion)
-            async function* yieldExhaustion() {
-                yield { position: { x: 1, y: 1, z: 1 }, name: "Exhausted" };
-            }
-            // Test generator that completes with return
-            async function* returnCompletion() {
-                return { position: { x: 2, y: 2, z: 2 }, name: "Returned" };
-            }
-            // Execute both transactions
-            store.transactions.createPositionNameEntity(() => yieldExhaustion());
-            store.transactions.createPositionNameEntity(() => returnCompletion());
-            // Wait for processing
-            await new Promise(resolve => setTimeout(resolve, 10));
-            // Verify both completion patterns work
-            const entities = store.select(["position", "name"]);
-            const exhaustedEntity = entities.find(entityId => {
-                const values = store.read(entityId);
-                return values?.name === "Exhausted";
-            });
-            const returnedEntity = entities.find(entityId => {
-                const values = store.read(entityId);
-                return values?.name === "Returned";
-            });
-            expect(exhaustedEntity).toBeDefined();
-            expect(returnedEntity).toBeDefined();
-            // Verify the correct values for each completion pattern
-            const exhaustedValues = store.read(exhaustedEntity);
-            const returnedValues = store.read(returnedEntity);
-            expect(exhaustedValues?.position).toEqual({ x: 1, y: 1, z: 1 });
-            expect(exhaustedValues?.name).toBe("Exhausted");
-            expect(returnedValues?.position).toEqual({ x: 2, y: 2, z: 2 });
-            expect(returnedValues?.name).toBe("Returned");
-            unsubscribe();
-        });
-        it("should properly rollback resource values when they are set in intermediate steps but not in final step", async () => {
-            const store = createTestObservableStore();
-            const timeObserver = vi.fn();
-            const unsubscribe = store.observe.resources.time(timeObserver);
-            // Clear initial notification
-            timeObserver.mockClear();
-            // Store original time value
-            const originalTime = { delta: 0.016, elapsed: 0 };
-            expect(store.resources.time).toEqual(originalTime);
-            // Create an async generator that sets time resource in intermediate steps but not in final step
-            async function* resourceRollbackTest() {
-                // Step 1: Set time to a new value
-                yield {
-                    position: { x: 1, y: 1, z: 1 },
-                    name: "Step1",
-                    resourceUpdate: { time: { delta: 0.032, elapsed: 1 } }
-                };
-                // Step 2: Set time to another value
-                yield {
-                    position: { x: 2, y: 2, z: 2 },
-                    name: "Step2",
-                    resourceUpdate: { time: { delta: 0.048, elapsed: 2 } }
-                };
-                // Final step: Only update position, no time resource update
-                return {
-                    position: { x: 3, y: 3, z: 3 },
-                    name: "FinalStep"
-                    // Note: No resourceUpdate here
-                };
-            }
-            // Create a custom transaction that handles resource updates
-            const baseStore = createStore({ position: positionSchema, name: nameSchema }, { time: { default: { delta: 0.016, elapsed: 0 } } }, {
-                PositionName: ["position", "name"],
-            });
-            const customStore = createDatabase(baseStore, {
-                createWithResourceUpdate(t, args) {
-                    // Create the entity
-                    const entity = t.archetypes.PositionName.insert(args);
-                    // Update resource if provided
-                    if (args.resourceUpdate?.time) {
-                        t.resources.time = args.resourceUpdate.time;
-                    }
-                    return entity;
+        it("should verify rollback behavior works correctly for each async generator pattern independently", async () => {
+            // Define the three test patterns
+            const testPatterns = [
+                {
+                    name: "yield-yield-yield (exhaustion)",
+                    generator: async function* yieldYieldPattern() {
+                        yield { position: { x: 1, y: 1, z: 1 }, name: "Step1" };
+                        yield { position: { x: 2, y: 2, z: 2 }, name: "Step2" };
+                        yield { position: { x: 3, y: 3, z: 3 }, name: "Step3" };
+                    },
+                    expectedFinalName: "Step3",
+                    expectedFinalPosition: { x: 3, y: 3, z: 3 }
+                },
+                {
+                    name: "yield-then-return",
+                    generator: async function* yieldThenReturn() {
+                        yield { position: { x: 10, y: 10, z: 10 }, name: "StepA" };
+                        return { position: { x: 20, y: 20, z: 20 }, name: "StepB" };
+                    },
+                    expectedFinalName: "StepB",
+                    expectedFinalPosition: { x: 20, y: 20, z: 20 }
+                },
+                {
+                    name: "return-only (no yields)",
+                    generator: async function* returnOnly() {
+                        return { position: { x: 100, y: 200, z: 300 }, name: "ReturnOnly" };
+                    },
+                    expectedFinalName: "ReturnOnly",
+                    expectedFinalPosition: { x: 100, y: 200, z: 300 }
                 }
-            });
-            // Set up observer on the custom store
-            const customTimeObserver = vi.fn();
-            const customUnsubscribe = customStore.observe.resources.time(customTimeObserver);
-            // Clear initial notification
-            customTimeObserver.mockClear();
-            // Execute transaction with async generator
-            customStore.transactions.createWithResourceUpdate(() => resourceRollbackTest());
-            // Wait for all entities to be processed
-            await new Promise(resolve => setTimeout(resolve, 10));
-            // Verify the final entity was created
-            const entities = customStore.select(["position", "name"]);
-            const finalEntity = entities.find(entityId => {
-                const values = customStore.read(entityId);
-                return values?.name === "FinalStep";
-            });
-            expect(finalEntity).toBeDefined();
-            const finalEntityValues = customStore.read(finalEntity);
-            expect(finalEntityValues?.position).toEqual({ x: 3, y: 3, z: 3 });
-            expect(finalEntityValues?.name).toBe("FinalStep");
-            // Verify that the time resource was rolled back to its original value
-            // because the final step didn't set it, so the rollback mechanism should have
-            // restored the original value
-            // Now that rollback is working correctly and observably, this should work
-            expect(customStore.resources.time).toEqual(originalTime);
-            // Verify that the observer was called at least once
-            expect(customTimeObserver).toHaveBeenCalled();
-            customUnsubscribe();
-            unsubscribe();
-        });
-        it("should maintain resource values when they are set in the final step", async () => {
-            const store = createTestObservableStore();
-            const timeObserver = vi.fn();
-            const unsubscribe = store.observe.resources.time(timeObserver);
-            // Clear initial notification
-            timeObserver.mockClear();
-            // Store original time value
-            const originalTime = { delta: 0.016, elapsed: 0 };
-            expect(store.resources.time).toEqual(originalTime);
-            // Create an async generator that sets time resource in the final step
-            async function* resourceFinalStepTest() {
-                // Step 1: No resource update
-                yield {
-                    position: { x: 1, y: 1, z: 1 },
-                    name: "Step1"
-                };
-                // Step 2: No resource update
-                yield {
-                    position: { x: 2, y: 2, z: 2 },
-                    name: "Step2"
-                };
-                // Final step: Update time resource
-                return {
-                    position: { x: 3, y: 3, z: 3 },
-                    name: "FinalStep",
-                    resourceUpdate: { time: { delta: 0.064, elapsed: 3 } }
-                };
-            }
-            // Create a custom transaction that handles resource updates
-            const baseStore = createStore({ position: positionSchema, name: nameSchema }, { time: { default: { delta: 0.016, elapsed: 0 } } }, {
-                PositionName: ["position", "name"],
-            });
-            const customStore = createDatabase(baseStore, {
-                createWithResourceUpdate(t, args) {
-                    // Create the entity
-                    const entity = t.archetypes.PositionName.insert(args);
-                    // Update resource if provided
-                    if (args.resourceUpdate?.time) {
-                        t.resources.time = args.resourceUpdate.time;
+            ];
+            // Test each pattern independently
+            for (const pattern of testPatterns) {
+                const store = createTestDatabase();
+                const transactionObserver = vi.fn();
+                const unsubscribe = store.observe.transactions(transactionObserver);
+                const entitiesBefore = store.select(["position", "name"]);
+                expect(entitiesBefore.length).toBe(0);
+                // Await completion this specific pattern
+                await store.transactions.createPositionNameEntity(() => pattern.generator());
+                // Verify that exactly ONE entity was created for this pattern
+                const entitiesAfter = store.select(["position", "name"]);
+                expect(entitiesAfter.length).toBe(1);
+                // Verify the final entity has the correct values
+                const finalEntity = entitiesAfter[0];
+                const finalEntityValues = store.read(finalEntity);
+                expect(finalEntityValues).toBeDefined();
+                expect(finalEntityValues?.position).toEqual(pattern.expectedFinalPosition);
+                expect(finalEntityValues?.name).toBe(pattern.expectedFinalName);
+                // Verify that NO intermediate entities exist for this pattern
+                const intermediateEntities = entitiesAfter.filter(entityId => {
+                    const values = store.read(entityId);
+                    // Check for any entities that might be intermediate steps
+                    if (pattern.name.includes("yield-yield-yield")) {
+                        return values?.name === "Step1" || values?.name === "Step2";
                     }
-                    return entity;
-                }
-            });
-            // Set up observer on the custom store
-            const customTimeObserver = vi.fn();
-            const customUnsubscribe = customStore.observe.resources.time(customTimeObserver);
-            // Clear initial notification
-            customTimeObserver.mockClear();
-            // Execute transaction with async generator
-            customStore.transactions.createWithResourceUpdate(() => resourceFinalStepTest());
-            // Wait for all entities to be processed
-            await new Promise(resolve => setTimeout(resolve, 10));
-            // Verify the final entity was created
-            const entities = customStore.select(["position", "name"]);
-            const finalEntity = entities.find(entityId => {
-                const values = customStore.read(entityId);
-                return values?.name === "FinalStep";
-            });
-            expect(finalEntity).toBeDefined();
-            // CRITICAL: Verify that the time resource was updated to the final value
-            // because the final step set it, so it should persist
-            const expectedFinalTime = { delta: 0.064, elapsed: 3 };
-            expect(customStore.resources.time).toEqual(expectedFinalTime);
-            // Verify that the observer was called at least once
-            expect(customTimeObserver).toHaveBeenCalled();
-            customUnsubscribe();
-            unsubscribe();
-        });
-        it("should correctly set transient: true on all async generator transactions except the final one", async () => {
-            // This test is CRITICAL for the persistence service
-            // The persistence service depends on transient: true being set correctly
-            // for all intermediate transactions and transient: false for the final transaction
-            const store = createTestObservableStore();
-            const transactionObserver = vi.fn();
-            const unsubscribe = store.observe.transactions(transactionObserver);
-            // Test case 1: Multiple yields (yield, yield, yield)
-            async function* multipleYields() {
-                yield { position: { x: 1, y: 1, z: 1 }, name: "Step1" };
-                yield { position: { x: 2, y: 2, z: 2 }, name: "Step2" };
-                yield { position: { x: 3, y: 3, z: 3 }, name: "Step3" };
-            }
-            // Test case 2: Yield then return (yield, return)
-            async function* yieldThenReturn() {
-                yield { position: { x: 10, y: 10, z: 10 }, name: "StepA" };
-                return { position: { x: 20, y: 20, z: 20 }, name: "StepB" };
-            }
-            // Test case 3: Return only (no yields)
-            async function* returnOnly() {
-                return { position: { x: 100, y: 200, z: 300 }, name: "ReturnOnly" };
-            }
-            // Execute all three transactions
-            store.transactions.createPositionNameEntity(() => multipleYields());
-            store.transactions.createPositionNameEntity(() => yieldThenReturn());
-            store.transactions.createPositionNameEntity(() => returnOnly());
-            // Wait for all entities to be processed
-            await new Promise(resolve => setTimeout(resolve, 10));
-            // Verify transaction observers were called for each step
-            // multipleYields: 3 transient + 1 final = 4 calls
-            // yieldThenReturn: 1 transient + 1 final = 2 calls  
-            // returnOnly: 0 transient + 1 final = 1 call
-            // Total: 7 calls
-            expect(transactionObserver).toHaveBeenCalledTimes(7);
-            // Collect all transaction results
-            const allTransactions = transactionObserver.mock.calls.map(call => call[0]);
-            // Debug: Let's see what we actually got
-            console.log('Total transactions:', allTransactions.length);
-            console.log('Transaction details:', allTransactions.map((t, i) => ({
-                index: i,
-                transient: t.transient,
-                changedEntities: t.changedEntities.size
-            })));
-            // Verify multipleYields pattern: 3 transient + 1 final
-            // But transactions are interleaved between different async generators
-            // Actual sequence based on debug output:
-            // Index 0: Step1 (transient: true) - multipleYields Step1
-            // Index 1: StepA (transient: true) - yieldThenReturn StepA  
-            // Index 2: ReturnOnly (transient: false) - returnOnly return
-            // Index 3: Step2 (transient: true) - multipleYields Step2
-            // Index 4: StepB (transient: false) - yieldThenReturn return
-            // Index 5: Step3 (transient: true) - multipleYields Step3
-            // Index 6: Final (transient: false) - multipleYields final re-execution
-            expect(allTransactions[0].transient).toBe(true); // Step1
-            expect(allTransactions[1].transient).toBe(true); // StepA
-            expect(allTransactions[2].transient).toBe(false); // ReturnOnly
-            expect(allTransactions[3].transient).toBe(true); // Step2
-            expect(allTransactions[4].transient).toBe(false); // StepB
-            expect(allTransactions[5].transient).toBe(true); // Step3
-            expect(allTransactions[6].transient).toBe(false); // Final re-execution
-            // Remove the old pattern-based assertions since transactions are interleaved
-            // Verify yieldThenReturn pattern: 1 transient + 1 final
-            // const yieldReturnTransactions = allTransactions.slice(7, 9);
-            // expect(yieldReturnTransactions[0].transient).toBe(true); // StepA
-            // expect(yieldReturnTransactions[1].transient).toBe(false); // StepB (return)
-            // Verify returnOnly pattern: 0 transient + 1 final
-            // const returnOnlyTransactions = allTransactions.slice(9, 10);
-            // expect(returnOnlyTransactions[0].transient).toBe(false); // ReturnOnly
-            // CRITICAL: Verify that ALL intermediate transactions have transient: true
-            // and ALL final transactions have transient: false
-            const transientTransactions = allTransactions.filter(t => t.transient);
-            const finalTransactions = allTransactions.filter(t => !t.transient);
-            // We expect 4 transient transactions (3 from multipleYields + 1 from yieldThenReturn)
-            expect(transientTransactions).toHaveLength(4);
-            // We expect 3 final transactions (1 from each pattern)
-            expect(finalTransactions).toHaveLength(3);
-            // Verify that transient transactions are truly intermediate (can be rolled back)
-            // and final transactions are truly final (persist)
-            const entities = store.select(["position", "name"]);
-            // Only final entities should exist
-            const finalEntities = entities.filter(entityId => {
-                const values = store.read(entityId);
-                return values?.name === "Step3" || values?.name === "StepB" || values?.name === "ReturnOnly";
-            });
-            expect(finalEntities).toHaveLength(3);
-            // Intermediate entities should NOT exist (they were rolled back)
-            // Now that rollback is working correctly and observably, this should work
-            const intermediateEntities = entities.filter(entityId => {
-                const values = store.read(entityId);
-                return values?.name === "Step1" || values?.name === "Step2" || values?.name === "StepA";
-            });
-            expect(intermediateEntities).toHaveLength(0);
-            unsubscribe();
-        });
-        it("should maintain transaction integrity with async operations", async () => {
-            const store = createTestObservableStore();
-            const transactionObserver = vi.fn();
-            const unsubscribe = store.observe.transactions(transactionObserver);
-            // Create a promise that resolves to entity data
-            const entityDataPromise = Promise.resolve({
-                position: { x: 100, y: 200, z: 300 },
-                name: "TransactionTest"
-            });
-            // Execute transaction with promise wrapped in function
-            store.transactions.createPositionNameEntity(() => entityDataPromise);
-            // Wait for the promise to resolve
-            await new Promise(resolve => setTimeout(resolve, 10));
-            // Verify transaction observer was called with proper transaction result
-            expect(transactionObserver).toHaveBeenCalledWith(expect.objectContaining({
-                changedEntities: expect.any(Map),
-                changedComponents: expect.any(Set),
-                changedArchetypes: expect.any(Set),
-                redo: expect.any(Array),
-                undo: expect.any(Array)
-            }));
-            const result = transactionObserver.mock.calls[0][0];
-            expect(result.changedEntities.size).toBe(1);
-            expect(result.changedComponents.has("position")).toBe(true);
-            expect(result.changedComponents.has("name")).toBe(true);
-            unsubscribe();
-        });
-        it("should handle undoable property correctly in async generator transactions", async () => {
-            const store = createTestObservableStore();
-            const transactionObserver = vi.fn();
-            const unsubscribe = store.observe.transactions(transactionObserver);
-            // Create an async generator that sets undoable property in intermediate transactions
-            async function* undoableStream() {
-                yield { position: { x: 1, y: 1, z: 1 }, name: "Step1" };
-                yield { position: { x: 2, y: 2, z: 2 }, name: "Step2" };
-                yield { position: { x: 3, y: 3, z: 3 }, name: "Step3" };
-            }
-            // Create a custom database with undoable transaction
-            const baseStore = createStore({ position: positionSchema, name: nameSchema }, { time: { default: { delta: 0.016, elapsed: 0 } } }, {
-                PositionName: ["position", "name"],
-            });
-            const customStore = createDatabase(baseStore, {
-                createWithUndoable(t, args) {
-                    // Set undoable property for this transaction
-                    t.undoable = { coalesce: { operation: "create", name: args.name } };
-                    return t.archetypes.PositionName.insert(args);
-                }
-            });
-            // Set up observer on the custom store
-            const customTransactionObserver = vi.fn();
-            const customUnsubscribe = customStore.observe.transactions(customTransactionObserver);
-            // Execute transaction with async generator wrapped in function
-            customStore.transactions.createWithUndoable(() => undoableStream());
-            // Wait for all entities to be processed
-            await new Promise(resolve => setTimeout(resolve, 10));
-            // Verify transaction observer was called multiple times (for each transient + final)
-            expect(customTransactionObserver).toHaveBeenCalledTimes(4); // 3 transient + 1 final
-            // Check the transient transactions - they should have the undoable property
-            const transientTransactionCall1 = customTransactionObserver.mock.calls[0]; // First transient
-            const transientTransactionCall2 = customTransactionObserver.mock.calls[1]; // Second transient
-            const transientTransactionCall3 = customTransactionObserver.mock.calls[2]; // Third transient
-            expect(transientTransactionCall1[0].transient).toBe(true);
-            expect(transientTransactionCall1[0].undoable).toEqual({ coalesce: { operation: "create", name: "Step1" } });
-            expect(transientTransactionCall2[0].transient).toBe(true);
-            expect(transientTransactionCall2[0].undoable).toEqual({ coalesce: { operation: "create", name: "Step2" } });
-            expect(transientTransactionCall3[0].transient).toBe(true);
-            expect(transientTransactionCall3[0].undoable).toEqual({ coalesce: { operation: "create", name: "Step3" } });
-            // Check that the final non-transient transaction has the undoable property from the last transient transaction
-            const finalTransactionCall = customTransactionObserver.mock.calls[3]; // Last call should be final transaction
-            const finalTransactionResult = finalTransactionCall[0];
-            expect(finalTransactionResult.transient).toBe(false);
-            // The undoable property should be preserved from the last transient transaction
-            expect(finalTransactionResult.undoable).toEqual({ coalesce: { operation: "create", name: "Step3" } });
-            // POTENTIAL ISSUE: Transient transactions with undoable properties might cause problems
-            // in undo-redo systems that expect only non-transient transactions to be undoable.
-            // This test documents the current behavior for future consideration.
-            unsubscribe();
-            customUnsubscribe();
-        });
-        it("should demonstrate potential issue with undo-redo system and transient transactions", async () => {
-            // This test demonstrates a potential issue where transient transactions with undoable properties
-            // might be incorrectly handled by undo-redo systems that expect only non-transient transactions
-            // to be undoable.
-            const baseStore = createStore({ position: positionSchema, name: nameSchema }, { time: { default: { delta: 0.016, elapsed: 0 } } }, {
-                PositionName: ["position", "name"],
-            });
-            const customStore = createDatabase(baseStore, {
-                createWithUndoable(t, args) {
-                    // Set undoable property for this transaction
-                    t.undoable = { coalesce: { operation: "create", name: args.name } };
-                    return t.archetypes.PositionName.insert(args);
-                }
-            });
-            const transactionObserver = vi.fn();
-            const unsubscribe = customStore.observe.transactions(transactionObserver);
-            // Create an async generator that yields multiple values
-            async function* undoableStream() {
-                yield { position: { x: 1, y: 1, z: 1 }, name: "Step1" };
-                yield { position: { x: 2, y: 2, z: 2 }, name: "Step2" };
-                yield { position: { x: 3, y: 3, z: 3 }, name: "Step3" };
-            }
-            // Execute transaction with async generator
-            customStore.transactions.createWithUndoable(() => undoableStream());
-            // Wait for processing
-            await new Promise(resolve => setTimeout(resolve, 10));
-            // Collect all transaction results
-            const allTransactions = transactionObserver.mock.calls.map(call => call[0]);
-            // Verify we have the expected number of transactions
-            expect(allTransactions).toHaveLength(4); // 3 transient + 1 final
-            // Check that transient transactions have undoable properties
-            const transientTransactions = allTransactions.filter(t => t.transient);
-            expect(transientTransactions).toHaveLength(3);
-            // POTENTIAL ISSUE: Transient transactions with undoable properties
-            // This could cause problems in undo-redo systems that:
-            // 1. Expect only non-transient transactions to be undoable
-            // 2. Might try to undo transient transactions incorrectly
-            // 3. Could have issues with coalescing logic that doesn't account for transient transactions
-            // The current implementation preserves the undoable property from the last transient transaction
-            // in the final non-transient transaction, which might be the intended behavior.
-            // However, this could lead to unexpected behavior in undo-redo systems.
-            const finalTransaction = allTransactions.find(t => !t.transient);
-            expect(finalTransaction).toBeDefined();
-            expect(finalTransaction.undoable).toEqual({ coalesce: { operation: "create", name: "Step3" } });
-            unsubscribe();
-        });
-        it("should demonstrate that rollback operations are now observable and working correctly", async () => {
-            // Create a custom store with the flag resource and createWithFlag transaction
-            const baseStore = createStore({ position: positionSchema, name: nameSchema }, { flag: { default: false } }, {
-                PositionName: ["position", "name"],
-            });
-            const customStore = createDatabase(baseStore, {
-                createWithFlag(t, args) {
-                    // Create the entity
-                    const entity = t.archetypes.PositionName.insert(args);
-                    // Set the flag resource only if setFlag is true
-                    if (args.setFlag) {
-                        t.resources.flag = true;
+                    else if (pattern.name.includes("yield-then-return")) {
+                        return values?.name === "StepA";
                     }
-                    return entity;
-                }
-            });
-            const flagObserver = vi.fn();
-            const unsubscribe = customStore.observe.resources.flag(flagObserver);
-            // Create an async generator that yields true then false (no return)
-            async function* flagToggleStream() {
-                yield { position: { x: 1, y: 1, z: 1 }, name: "Step1", setFlag: true };
-                yield { position: { x: 2, y: 2, z: 2 }, name: "Step2", setFlag: false };
+                    // return-only pattern has no intermediate entities
+                    return false;
+                });
+                // CRITICAL: Should have NO intermediate entities (rollback worked)
+                expect(intermediateEntities).toHaveLength(0);
+                // Verify transaction observer was called appropriately
+                // Each pattern should have at least the minimum expected calls
+                const minExpectedCalls = pattern.name.includes("yield-yield-yield") ? 7 :
+                    pattern.name.includes("yield-then-return") ? 3 : 1;
+                expect(transactionObserver).toHaveBeenCalledTimes(minExpectedCalls);
+                // Pattern verification complete
+                unsubscribe();
             }
-            customStore.transactions.createWithFlag(() => flagToggleStream());
-            await new Promise(resolve => setTimeout(resolve, 10));
-            // SUCCESS: Rollback operations are now observable and working correctly!
-            // The flag should end up as false (the final value from Step2)
-            expect(customStore.resources.flag).toBe(false);
-            // The observer should have been called at least twice:
-            // - Once when the flag was set to true (Step1)
-            // - Once when the flag was set to false (Step2)
-            // The exact count may vary due to rollback operations, but rollback is now observable
-            expect(flagObserver).toHaveBeenCalledTimes(2);
-            // The observer should have been called with the value true (from Step1)
-            expect(flagObserver).toHaveBeenCalledWith(true);
-            // The observer should have been called with the value false (from Step2)
-            expect(flagObserver).toHaveBeenCalledWith(false);
-            // SUCCESS: The rollback operations are now observable through the database's transaction system.
-            // The key points are:
-            // 1. The final flag value is correct (false)
-            // 2. Rollback operations are observable (observer was notified of both values)
-            // 3. The database state and observable state are in sync
-            // 4. Intermediate entities are properly rolled back (only final entity remains)
-            unsubscribe();
         });
     });
     describe("entity observation with minArchetype filtering", () => {
         it("should observe entity when it matches minArchetype exactly", () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             // Create entity with position only
             const entity = store.transactions.createPositionEntity({
                 position: { x: 1, y: 2, z: 3 }
@@ -1192,7 +801,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should observe entity when it has more components than minArchetype", () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             // Create entity with position and health
             const entity = store.transactions.createPositionHealthEntity({
                 position: { x: 1, y: 2, z: 3 },
@@ -1208,7 +817,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should return null when entity has fewer components than minArchetype", () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             // Create entity with position only
             const entity = store.transactions.createPositionEntity({
                 position: { x: 1, y: 2, z: 3 }
@@ -1220,7 +829,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should return null when entity has different components than minArchetype", () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             // Create entity with position and name
             const entity = store.transactions.createPositionNameEntity({
                 position: { x: 1, y: 2, z: 3 },
@@ -1233,7 +842,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should update observation when entity gains required components", () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             // Create entity with position only
             const entity = store.transactions.createPositionEntity({
                 position: { x: 1, y: 2, z: 3 }
@@ -1256,7 +865,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should update observation when entity loses required components", () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             // Create entity with position and health
             const entity = store.transactions.createPositionHealthEntity({
                 position: { x: 1, y: 2, z: 3 },
@@ -1280,7 +889,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should handle entity deletion correctly with minArchetype", () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             // Create entity with position and health
             const entity = store.transactions.createPositionHealthEntity({
                 position: { x: 1, y: 2, z: 3 },
@@ -1300,7 +909,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should handle non-existent entity with minArchetype", () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.entity(999, store.archetypes.Position)(observer);
             // Should return null for non-existent entity
@@ -1308,7 +917,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should handle invalid entity ID with minArchetype", () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             const observer = vi.fn();
             const unsubscribe = store.observe.entity(-1, store.archetypes.Position)(observer);
             // Should return null for invalid entity ID
@@ -1316,7 +925,7 @@ describe("createDatabase", () => {
             unsubscribe();
         });
         it("should maintain separate observations for different minArchetypes", () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             // Create entity with position and health
             const entity = store.transactions.createPositionHealthEntity({
                 position: { x: 1, y: 2, z: 3 },
@@ -1360,7 +969,7 @@ describe("createDatabase", () => {
             unsubscribeFull();
         });
         it("should handle component updates that don't affect minArchetype requirements", () => {
-            const store = createTestObservableStore();
+            const store = createTestDatabase();
             // Create entity with position and health
             const entity = store.transactions.createPositionHealthEntity({
                 position: { x: 1, y: 2, z: 3 },
@@ -1399,7 +1008,7 @@ describe("createDatabase", () => {
 });
 describe("toData/fromData functionality", () => {
     it("should serialize and deserialize database state correctly", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         // Create some entities and update resources
         const entity1 = store.transactions.createPositionEntity({
             position: { x: 1, y: 2, z: 3 }
@@ -1413,7 +1022,7 @@ describe("toData/fromData functionality", () => {
         // Serialize the database
         const serializedData = store.toData();
         // Create a new database and restore from serialized data
-        const newStore = createTestObservableStore();
+        const newStore = createTestDatabase();
         newStore.fromData(serializedData);
         // Verify entities are restored
         const restoredEntities = newStore.select(["position"]);
@@ -1435,7 +1044,7 @@ describe("toData/fromData functionality", () => {
         expect(newStore.resources.time).toEqual({ delta: 0.033, elapsed: 1.5 });
     });
     it("should notify all observers when database is restored from serialized data", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         // Create initial state
         const entity = store.transactions.createPositionEntity({
             position: { x: 1, y: 2, z: 3 }
@@ -1458,7 +1067,7 @@ describe("toData/fromData functionality", () => {
         // Serialize the database
         const serializedData = store.toData();
         // Create a new database with different state
-        const newStore = createTestObservableStore();
+        const newStore = createTestDatabase();
         const newEntity = newStore.transactions.createFullEntity({
             position: { x: 10, y: 20, z: 30 },
             health: { current: 50, max: 100 },
@@ -1510,7 +1119,7 @@ describe("toData/fromData functionality", () => {
         newUnsubscribeTransaction();
     });
     it("should notify observers even when no entities exist in restored data", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         // Set up observers on empty store
         const positionObserver = vi.fn();
         const timeObserver = vi.fn();
@@ -1525,7 +1134,7 @@ describe("toData/fromData functionality", () => {
         // Serialize empty database
         const serializedData = store.toData();
         // Create a new database with some data
-        const newStore = createTestObservableStore();
+        const newStore = createTestDatabase();
         newStore.transactions.createPositionEntity({
             position: { x: 1, y: 2, z: 3 }
         });
@@ -1560,7 +1169,7 @@ describe("toData/fromData functionality", () => {
         newUnsubscribeTransaction();
     });
     it("should handle entity observers correctly during restoration", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         // Create entity and set up observer
         const entity = store.transactions.createPositionEntity({
             position: { x: 1, y: 2, z: 3 }
@@ -1572,7 +1181,7 @@ describe("toData/fromData functionality", () => {
         // Serialize the database
         const serializedData = store.toData();
         // Create a new database
-        const newStore = createTestObservableStore();
+        const newStore = createTestDatabase();
         // Set up observer on the new store for a different entity
         const newEntity = newStore.transactions.createFullEntity({
             position: { x: 10, y: 20, z: 30 },
@@ -1597,13 +1206,13 @@ describe("toData/fromData functionality", () => {
         newUnsubscribe();
     });
     it("should preserve transaction functionality after restoration", () => {
-        const store = createTestObservableStore();
+        const store = createTestDatabase();
         // Create initial state
         store.transactions.updateTime({ delta: 0.016, elapsed: 0 });
         // Serialize the database
         const serializedData = store.toData();
         // Create a new database and restore
-        const newStore = createTestObservableStore();
+        const newStore = createTestDatabase();
         newStore.fromData(serializedData);
         // Verify transactions still work
         const entity = newStore.transactions.createPositionEntity({
@@ -1620,5 +1229,18 @@ describe("toData/fromData functionality", () => {
         newStore.transactions.updateTime({ delta: 0.033, elapsed: 1.5 });
         expect(newStore.resources.time).toEqual({ delta: 0.033, elapsed: 1.5 });
     });
+    it("all transient operations should be rolled back", async () => {
+        const store = createTestDatabase();
+        const promise = store.transactions.startGenerating(async function* () {
+            yield { progress: 0 };
+            yield { progress: 1 };
+        });
+        // Check that the result is a promise
+        expect(promise).toBeInstanceOf(Promise);
+        const result = await promise;
+        expect(result).toBe(-1);
+        const generating = await toPromise(store.observe.resources.generating);
+        expect(generating).toBe(false);
+    });
 });
 //# sourceMappingURL=create-database.test.js.map