@adobe/data 0.8.5 → 0.9.0

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

@@ -0,0 +1,993 @@
+/*MIT License
+
+© Copyright 2025 Adobe. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.*/
+import { describe, it, expect, vi } from "vitest";
+import { Database } from "../database.js";
+import { createReconcilingDatabase } from "../reconciling/create-reconciling-database.js";
+import { Store } from "../../store/index.js";
+import { F32 } from "../../../math/f32/index.js";
+import { toPromise } from "../../../observe/to-promise.js";
+import { createUndoRedoService } from "../../undo-redo-service/create-undo-redo-service.js";
+import { applyOperations } from "../transactional-store/apply-operations.js";
+// Test schemas
+const positionSchema = {
+    type: "object",
+    properties: {
+        x: F32.schema,
+        y: F32.schema,
+        z: F32.schema,
+    },
+    required: ["x", "y", "z"],
+    additionalProperties: false,
+};
+const healthSchema = {
+    type: "object",
+    properties: {
+        current: F32.schema,
+        max: F32.schema,
+    },
+    required: ["current", "max"],
+    additionalProperties: false,
+};
+const nameSchema = {
+    type: "string",
+    maxLength: 50,
+};
+const createStoreConfig = () => {
+    const baseStore = Store.create({
+        components: { position: positionSchema, health: healthSchema, name: nameSchema },
+        resources: {
+            time: { default: { delta: 0.016, elapsed: 0 } },
+            generating: { type: "boolean", default: false }
+        },
+        archetypes: {
+            Position: ["position"],
+            Health: ["health"],
+            PositionHealth: ["position", "health"],
+            PositionName: ["position", "name"],
+            Full: ["position", "health", "name"],
+        }
+    });
+    const actions = {
+        createPositionEntity(t, args) {
+            return t.archetypes.Position.insert(args);
+        },
+        createPositionHealthEntity(t, args) {
+            return t.archetypes.PositionHealth.insert(args);
+        },
+        createPositionNameEntity(t, args) {
+            return t.archetypes.PositionName.insert(args);
+        },
+        createFullEntity(t, args) {
+            return t.archetypes.Full.insert(args);
+        },
+        createEntityAndReturn(t, args) {
+            return t.archetypes.PositionName.insert(args);
+        },
+        updateEntity(t, args) {
+            t.update(args.entity, args.values);
+        },
+        deleteEntity(t, args) {
+            t.delete(args.entity);
+        },
+        updateTime(t, args) {
+            t.resources.time = args;
+        },
+        createFailingPositionEntity(t, args) {
+            const entity = t.archetypes.Position.insert(args);
+            throw new Error("Simulated failure");
+        },
+        startGenerating(t, args) {
+            if (args.progress < 1.0) {
+                t.resources.generating = true;
+            }
+            return -1;
+        },
+        deletePositionEntities(t) {
+            for (const entity of t.select(["position"])) {
+                t.delete(entity);
+            }
+        }
+    };
+    return { baseStore, actions };
+};
+function createTestDatabase() {
+    const { baseStore, actions } = createStoreConfig();
+    return Database.create(baseStore, actions);
+}
+describe("createDatabase", () => {
+    it("should apply committed entries in arrival order, ignoring commit time", () => {
+        const { baseStore, actions } = createStoreConfig();
+        const reconciling = createReconcilingDatabase(baseStore, actions);
+        reconciling.apply({
+            id: 1,
+            name: "createPositionNameEntity",
+            args: { position: { x: 10, y: 20, z: 30 }, name: "LateCommit" },
+            time: 5,
+        });
+        reconciling.apply({
+            id: 2,
+            name: "createPositionNameEntity",
+            args: { position: { x: 40, y: 50, z: 60 }, name: "EarlyCommit" },
+            time: 1,
+        });
+        const entities = reconciling.select(["name"]);
+        const namesById = entities
+            .map(entity => reconciling.read(entity)?.name)
+            .filter((name) => !!name);
+        expect(namesById).toHaveLength(2);
+        expect(namesById).toEqual(["LateCommit", "EarlyCommit"]);
+    });
+    it("should support deleting entities", () => {
+        const store = createTestDatabase();
+        const entity = store.transactions.createPositionEntity({ position: { x: 1, y: 2, z: 3 } });
+        store.transactions.deletePositionEntities();
+        expect(store.locate(entity)).toBeNull();
+    });
+    it("should roll back state when a transaction throws synchronously", () => {
+        const store = createTestDatabase();
+        expect(() => store.transactions.createFailingPositionEntity({
+            position: { x: 1, y: 2, z: 3 },
+        })).toThrow("Simulated failure");
+        const entities = store.select(["position"]);
+        expect(entities).toHaveLength(0);
+    });
+    it("should support transaction functions that return an Entity", () => {
+        const store = createTestDatabase();
+        // Execute a transaction that returns an Entity
+        const returnedEntity = store.transactions.createEntityAndReturn({
+            position: { x: 10, y: 20, z: 30 },
+            name: "ReturnedEntity"
+        });
+        // Verify that an Entity was returned
+        expect(returnedEntity).toBeDefined();
+        expect(typeof returnedEntity).toBe("number");
+        // Verify the entity exists in the store
+        const entityValues = store.read(returnedEntity);
+        expect(entityValues).toBeDefined();
+        expect(entityValues?.position).toEqual({ x: 10, y: 20, z: 30 });
+        expect(entityValues?.name).toBe("ReturnedEntity");
+        // Verify the entity can be found in the store using select
+        const selectedEntities = store.select(["position", "name"]);
+        expect(selectedEntities).toContain(returnedEntity);
+    });
+    describe("AsyncArgs Support", () => {
+        it("should handle Promise-based async arguments", async () => {
+            const store = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            // Create a promise that resolves to entity data
+            const entityDataPromise = Promise.resolve({
+                position: { x: 100, y: 200, z: 300 },
+                name: "AsyncEntity"
+            });
+            // Execute transaction with promise argument wrapped in function
+            store.transactions.createPositionNameEntity(() => entityDataPromise);
+            // Wait for the promise to resolve
+            await new Promise(resolve => setTimeout(resolve, 0));
+            // Verify the entity was created with the resolved data
+            const entities = store.select(["position", "name"]);
+            const createdEntity = entities.find(entityId => {
+                const values = store.read(entityId);
+                return values?.name === "AsyncEntity";
+            });
+            expect(createdEntity).toBeDefined();
+            const entityValues = store.read(createdEntity);
+            expect(entityValues?.position).toEqual({ x: 100, y: 200, z: 300 });
+            expect(entityValues?.name).toBe("AsyncEntity");
+            // Verify observer was notified
+            expect(observer).toHaveBeenCalledTimes(1);
+            unsubscribe();
+        });
+        it("should handle AsyncGenerator streaming arguments", async () => {
+            const store = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            // Create an async generator that yields multiple entity data
+            async function* entityDataStream() {
+                yield { position: { x: 1, y: 1, z: 1 }, name: "Stream1" };
+                yield { position: { x: 2, y: 2, z: 2 }, name: "Stream2" };
+                yield { position: { x: 3, y: 3, z: 3 }, name: "Stream3" };
+            }
+            // Execute transaction with async generator wrapped in function
+            store.transactions.createPositionNameEntity(() => entityDataStream());
+            // Wait for all entities to be processed
+            await new Promise(resolve => setTimeout(resolve, 10));
+            // Verify only the final entity was created (each yield replaces the previous)
+            // Now that rollback is working correctly and observably, we should see only the final entity
+            const entities = store.select(["position", "name"]);
+            const streamEntities = entities.filter(entityId => {
+                const values = store.read(entityId);
+                return values?.name?.startsWith("Stream");
+            });
+            // 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
+            expect(observer.mock.calls.length >= 3);
+            unsubscribe();
+        });
+        it("should handle AsyncGenerator with delays", async () => {
+            const store = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            // Create an async generator with delays
+            async function* delayedEntityStream() {
+                yield { position: { x: 10, y: 10, z: 10 }, name: "Delayed1" };
+                await new Promise(resolve => setTimeout(resolve, 5));
+                yield { position: { x: 20, y: 20, z: 20 }, name: "Delayed2" };
+                await new Promise(resolve => setTimeout(resolve, 5));
+                yield { position: { x: 30, y: 30, z: 30 }, name: "Delayed3" };
+            }
+            // Execute transaction with delayed async generator wrapped in function
+            store.transactions.createPositionNameEntity(() => delayedEntityStream());
+            // Wait for all entities to be processed
+            await new Promise(resolve => setTimeout(resolve, 20));
+            // Verify all entities were created
+            const entities = store.select(["position", "name"]);
+            const delayedEntities = entities.filter(entityId => {
+                const values = store.read(entityId);
+                return values?.name?.startsWith("Delayed");
+            });
+            expect(delayedEntities.length >= 3);
+            expect(observer.mock.calls.length >= 3);
+            unsubscribe();
+        });
+        it("should handle mixed sync and async arguments in the same transaction", async () => {
+            const store = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            // Create entities with different argument types
+            store.transactions.createPositionNameEntity({
+                position: { x: 1, y: 1, z: 1 },
+                name: "SyncEntity"
+            });
+            store.transactions.createPositionNameEntity(() => Promise.resolve({
+                position: { x: 2, y: 2, z: 2 },
+                name: "PromiseEntity"
+            }));
+            async function* streamEntityGenerator() {
+                yield { position: { x: 3, y: 3, z: 3 }, name: "StreamEntity" };
+            }
+            store.transactions.createPositionNameEntity(() => streamEntityGenerator());
+            // Wait for async operations
+            await new Promise(resolve => setTimeout(resolve, 10));
+            // Verify all entities were created
+            const entities = store.select(["position", "name"]);
+            const testEntities = entities.filter(entityId => {
+                const values = store.read(entityId);
+                return values?.name?.endsWith("Entity");
+            });
+            expect(testEntities.length >= 3);
+            const syncEntity = store.read(testEntities.find(e => store.read(e)?.name === "SyncEntity"));
+            const promiseEntity = store.read(testEntities.find(e => store.read(e)?.name === "PromiseEntity"));
+            const streamEntity = store.read(testEntities.find(e => store.read(e)?.name === "StreamEntity"));
+            expect(syncEntity?.position).toEqual({ x: 1, y: 1, z: 1 });
+            expect(promiseEntity?.position).toEqual({ x: 2, y: 2, z: 2 });
+            expect(streamEntity?.position).toEqual({ x: 3, y: 3, z: 3 });
+            expect(observer.mock.calls.length >= 3);
+            unsubscribe();
+        });
+        it("should handle AsyncGenerator that yields no values", async () => {
+            const store = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            // Create an empty async generator
+            async function* emptyStream() {
+                // Yields nothing
+            }
+            // Execute transaction with empty async generator wrapped in function
+            store.transactions.createPositionNameEntity(() => emptyStream());
+            // Wait for processing
+            await new Promise(resolve => setTimeout(resolve, 10));
+            // Verify no entities were created
+            const entities = store.select(["position", "name"]);
+            expect(entities).toHaveLength(0);
+            expect(observer).toHaveBeenCalledTimes(0);
+            unsubscribe();
+        });
+        it("should handle AsyncGenerator with error handling", async () => {
+            const store = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            // Create an async generator that throws an error
+            async function* errorStream() {
+                yield { position: { x: 1, y: 1, z: 1 }, name: "BeforeError" };
+                throw new Error("Test error");
+            }
+            // Execute transaction with error-throwing async generator wrapped in function
+            // 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 the transient entity was rolled back after the error
+            const entities = store.select(["position", "name"]);
+            const beforeErrorEntities = entities.filter(entityId => {
+                const values = store.read(entityId);
+                return values?.name === "BeforeError";
+            });
+            expect(beforeErrorEntities).toHaveLength(0);
+            expect(observer).toHaveBeenCalled();
+            unsubscribe();
+        });
+        it("should remove transient entries from reconciling queue when AsyncGenerator throws", async () => {
+            const store = createTestDatabase();
+            // Create an async generator that yields multiple times then throws
+            async function* multiYieldErrorStream() {
+                yield { position: { x: 1, y: 1, z: 1 }, name: "Yield1" };
+                await new Promise(resolve => setTimeout(resolve, 1));
+                yield { position: { x: 2, y: 2, z: 2 }, name: "Yield2" };
+                await new Promise(resolve => setTimeout(resolve, 1));
+                yield { position: { x: 3, y: 3, z: 3 }, name: "Yield3" };
+                throw new Error("Sequential transaction failed");
+            }
+            // Start the transaction
+            const transactionPromise = store.transactions.createPositionNameEntity(() => multiYieldErrorStream());
+            // Wait a bit to let some yields process
+            await new Promise(resolve => setTimeout(resolve, 5));
+            // Take a snapshot during processing; persistence should not expose
+            // internal reconciling metadata, but this must not throw.
+            const serializedDuring = store.toData();
+            expect(serializedDuring).toBeTruthy();
+            // Wait for the error
+            let error;
+            try {
+                await transactionPromise;
+            }
+            catch (e) {
+                error = e;
+            }
+            expect(error).toBeDefined();
+            expect(error.message).toBe("Sequential transaction failed");
+            // Wait for cleanup to complete
+            await new Promise(resolve => setTimeout(resolve, 10));
+            // Verify no persisted metadata is exposed and no error is thrown
+            const serializedAfter = store.toData();
+            expect(serializedAfter).toBeTruthy();
+            // Verify all entities are rolled back
+            const entities = store.select(["position", "name"]);
+            const yieldEntities = entities.filter(entityId => {
+                const values = store.read(entityId);
+                return values?.name?.startsWith("Yield");
+            });
+            expect(yieldEntities).toHaveLength(0);
+        });
+        it("should handle complex AsyncGenerator with conditional yielding", async () => {
+            const store = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            // Create a complex async generator with conditional logic
+            async function* conditionalStream() {
+                for (let i = 0; i < 5; i++) {
+                    if (i % 2 === 0) {
+                        yield {
+                            position: { x: i, y: i * 2, z: i * 3 },
+                            name: `Even${i}`
+                        };
+                    }
+                    await new Promise(resolve => setTimeout(resolve, 1));
+                }
+            }
+            // Execute transaction with conditional async generator wrapped in function
+            store.transactions.createPositionNameEntity(() => conditionalStream());
+            // Wait for processing
+            await new Promise(resolve => setTimeout(resolve, 20));
+            // Verify only the final entity was created (each yield replaces the previous)
+            // Now that rollback is working correctly and observably, we should see only the final entity
+            const entities = store.select(["position", "name"]);
+            const evenEntities = entities.filter(entityId => {
+                const values = store.read(entityId);
+                return values?.name?.startsWith("Even");
+            });
+            // 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
+            expect(observer.mock.calls.length >= 3);
+            unsubscribe();
+        });
+        it("should handle AsyncGenerator with yield then return", async () => {
+            const store = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            // Create an async generator that yields then returns
+            async function* yieldThenReturn() {
+                yield { position: { x: 1, y: 1, z: 1 }, name: "Yielded" };
+                return { position: { x: 2, y: 2, z: 2 }, name: "Returned" };
+            }
+            // Execute transaction with async generator
+            store.transactions.createPositionNameEntity(() => yieldThenReturn());
+            // Wait for processing
+            await new Promise(resolve => setTimeout(resolve, 10));
+            // Verify the return value was used (not the yield value)
+            const entities = store.select(["position", "name"]);
+            const returnedEntity = entities.find(entityId => {
+                const values = store.read(entityId);
+                return values?.name === "Returned";
+            });
+            expect(returnedEntity).toBeDefined();
+            const entityValues = store.read(returnedEntity);
+            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
+            // 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 = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            // Test multiple yields
+            async function* multipleYields() {
+                yield { position: { x: 1, y: 1, z: 1 }, name: "First" };
+                yield { position: { x: 2, y: 2, z: 2 }, name: "Second" };
+                yield { position: { x: 3, y: 3, z: 3 }, name: "Third" };
+            }
+            // Test yield then return
+            async function* yieldThenReturn() {
+                yield { position: { x: 10, y: 10, z: 10 }, name: "Yielded" };
+                return { position: { x: 20, y: 20, z: 20 }, name: "Returned" };
+            }
+            // Execute both actions
+            store.transactions.createPositionNameEntity(() => multipleYields());
+            store.transactions.createPositionNameEntity(() => yieldThenReturn());
+            // Wait for processing
+            await new Promise(resolve => setTimeout(resolve, 10));
+            // Verify both patterns work correctly
+            const entities = store.select(["position", "name"]);
+            const multipleYieldsEntity = entities.find(entityId => {
+                const values = store.read(entityId);
+                return values?.name === "Third";
+            });
+            const returnEntity = entities.find(entityId => {
+                const values = store.read(entityId);
+                return values?.name === "Returned";
+            });
+            expect(multipleYieldsEntity).toBeDefined();
+            expect(returnEntity).toBeDefined();
+            // Verify the correct final values for each pattern
+            const multipleYieldsValues = store.read(multipleYieldsEntity);
+            const returnValues = store.read(returnEntity);
+            expect(multipleYieldsValues?.position).toEqual({ x: 3, y: 3, z: 3 });
+            expect(multipleYieldsValues?.name).toBe("Third");
+            expect(returnValues?.position).toEqual({ x: 20, y: 20, z: 20 });
+            expect(returnValues?.name).toBe("Returned");
+            unsubscribe();
+        });
+        it("should handle AsyncGenerator with return only (no yields)", async () => {
+            const store = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            // Create an async generator that only returns
+            async function* returnOnly() {
+                // This generator yields nothing but returns a value
+                return { position: { x: 100, y: 200, z: 300 }, name: "ReturnOnly" };
+            }
+            // Execute transaction with async generator
+            store.transactions.createPositionNameEntity(() => returnOnly());
+            // Wait for processing
+            await new Promise(resolve => setTimeout(resolve, 10));
+            // Verify the return value was used
+            const entities = store.select(["position", "name"]);
+            const returnedEntity = entities.find(entityId => {
+                const values = store.read(entityId);
+                return values?.name === "ReturnOnly";
+            });
+            expect(returnedEntity).toBeDefined();
+            const entityValues = store.read(returnedEntity);
+            expect(entityValues?.position).toEqual({ x: 100, y: 200, z: 300 });
+            expect(entityValues?.name).toBe("ReturnOnly");
+            // Verify observer was notified only once (no intermediate yields)
+            expect(observer).toHaveBeenCalledTimes(1);
+            unsubscribe();
+        });
+        it("should handle AsyncGenerator with yield, return, yield (unreachable code)", async () => {
+            const store = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            // 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" };
+            }
+            // 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 unreachable yield)
+            const entities = store.select(["position", "name"]);
+            const returnedEntity = entities.find(entityId => {
+                const values = store.read(entityId);
+                return values?.name === "Returned";
+            });
+            expect(returnedEntity).toBeDefined();
+            const entityValues = store.read(returnedEntity);
+            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
+            // 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 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() {
+                        // This generator yields nothing but returns a value
+                        return { position: { x: 100, y: 200, z: 300 }, name: "ReturnOnly" };
+                    },
+                    expectedFinalName: "ReturnOnly",
+                    expectedFinalPosition: { x: 100, y: 200, z: 300 }
+                }
+            ];
+            // 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";
+                    }
+                    else if (pattern.name.includes("yield-then-return")) {
+                        return values?.name === "StepA";
+                    }
+                    // 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();
+            }
+        });
+    });
+    describe("toData/fromData functionality", () => {
+        it("should serialize and deserialize database state correctly", () => {
+            const store = createTestDatabase();
+            // Create some entities and update resources
+            const entity1 = store.transactions.createPositionEntity({
+                position: { x: 1, y: 2, z: 3 }
+            });
+            const entity2 = store.transactions.createFullEntity({
+                position: { x: 4, y: 5, z: 6 },
+                health: { current: 100, max: 100 },
+                name: "TestEntity"
+            });
+            store.transactions.updateTime({ delta: 0.033, elapsed: 1.5 });
+            // Serialize the database
+            const serializedData = store.toData();
+            // Create a new database and restore from serialized data
+            const newStore = createTestDatabase();
+            newStore.fromData(serializedData);
+            // Verify entities are restored
+            const restoredEntities = newStore.select(["position"]);
+            expect(restoredEntities).toHaveLength(2);
+            // Verify entity data is correct
+            const restoredData1 = newStore.read(restoredEntities[0]);
+            const restoredData2 = newStore.read(restoredEntities[1]);
+            expect(restoredData1).toEqual({
+                id: restoredEntities[0],
+                position: { x: 1, y: 2, z: 3 }
+            });
+            expect(restoredData2).toEqual({
+                id: restoredEntities[1],
+                position: { x: 4, y: 5, z: 6 },
+                health: { current: 100, max: 100 },
+                name: "TestEntity"
+            });
+            // Verify resources are restored
+            expect(newStore.resources.time).toEqual({ delta: 0.033, elapsed: 1.5 });
+        });
+        it("should restore applied entry ordering after serialization", () => {
+            const store = createTestDatabase();
+            store.transactions.createPositionNameEntity({
+                position: { x: 10, y: 20, z: 30 },
+                name: "LateCommit",
+            });
+            store.transactions.createPositionNameEntity({
+                position: { x: 40, y: 50, z: 60 },
+                name: "EarlyCommit",
+            });
+            const serializedData = store.toData();
+            const newStore = createTestDatabase();
+            newStore.fromData(serializedData);
+            newStore.transactions.createPositionNameEntity({
+                position: { x: 70, y: 80, z: 90 },
+                name: "EarliestCommit",
+            });
+            const entities = newStore.select(["name"]);
+            const names = entities
+                .map(entityId => newStore.read(entityId)?.name)
+                .filter((name) => Boolean(name));
+            expect(new Set(names)).toEqual(new Set(["EarliestCommit", "LateCommit", "EarlyCommit"]));
+        });
+        it("should preserve transaction functionality after restoration", () => {
+            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 = createTestDatabase();
+            newStore.fromData(serializedData);
+            // Verify transactions still work
+            const entity = newStore.transactions.createPositionEntity({
+                position: { x: 1, y: 2, z: 3 }
+            });
+            expect(entity).toBeDefined();
+            expect(typeof entity).toBe("number");
+            const entityData = newStore.read(entity);
+            expect(entityData).toEqual({
+                id: entity,
+                position: { x: 1, y: 2, z: 3 }
+            });
+            // Verify resource transactions work
+            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);
+        });
+    });
+    describe("No-op transaction prevention", () => {
+        it("should not emit a transaction that makes no changes", () => {
+            const store = createTestDatabase();
+            // Track how many times the observer is called
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            // Clear any initial calls
+            observer.mockClear();
+            // Create a no-op transaction (doesn't modify anything)
+            const { baseStore, actions } = createStoreConfig();
+            const database = Database.create(baseStore, {
+                ...actions,
+                noOpTransaction(t, _args) {
+                    // This transaction does nothing
+                }
+            });
+            const positionObserver = vi.fn();
+            const unsub = database.observe.components.position(positionObserver);
+            positionObserver.mockClear();
+            // Execute the no-op transaction
+            database.transactions.noOpTransaction({});
+            // Verify no notification was sent
+            expect(positionObserver).not.toHaveBeenCalled();
+            unsub();
+        });
+        it("should not add no-op actions to the undo stack", async () => {
+            const store = createTestDatabase();
+            // Create database with undo-redo service
+            const { baseStore, actions } = createStoreConfig();
+            const database = Database.create(baseStore, {
+                ...actions,
+                noOpTransaction(t, _args) {
+                    t.undoable = { coalesce: false };
+                    // This transaction does nothing
+                },
+                applyOperations(t, operations) {
+                    applyOperations(t, operations);
+                }
+            });
+            const undoRedo = createUndoRedoService(database);
+            // Execute the no-op transaction
+            database.transactions.noOpTransaction({});
+            // Verify the undo stack is empty (need to await the observable)
+            const undoStack = await toPromise(undoRedo.undoStack);
+            expect(undoStack).toHaveLength(0);
+        });
+        it("should emit a transaction that makes changes", () => {
+            const store = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = store.observe.components.position(observer);
+            observer.mockClear();
+            // Create an entity (makes changes)
+            store.transactions.createPositionEntity({ position: { x: 1, y: 2, z: 3 } });
+            // Verify notification was sent
+            expect(observer).toHaveBeenCalled();
+            unsubscribe();
+        });
+        it("should detect true no-op when transaction reads but doesn't modify", async () => {
+            const { baseStore, actions } = createStoreConfig();
+            const database = Database.create(baseStore, {
+                ...actions,
+                readOnlyTransaction(t, args) {
+                    t.undoable = { coalesce: false };
+                    // Just read the entity but don't modify it
+                    const current = t.read(args.entity);
+                    // Do nothing with the data - this is a true no-op
+                },
+                applyOperations(t, operations) {
+                    applyOperations(t, operations);
+                }
+            });
+            // Create an entity
+            const entity = database.transactions.createPositionEntity({ position: { x: 1, y: 2, z: 3 } });
+            const undoRedo = createUndoRedoService(database);
+            const initialStackLength = (await toPromise(undoRedo.undoStack)).length;
+            // Execute read-only transaction (true no-op)
+            database.transactions.readOnlyTransaction({ entity });
+            // Verify no new undo entry was added
+            const finalStackLength = (await toPromise(undoRedo.undoStack)).length;
+            expect(finalStackLength).toBe(initialStackLength);
+        });
+    });
+    it("should return the same instance when extended", () => {
+        const database = createTestDatabase();
+        const extended = database.extend({ components: {}, resources: {}, archetypes: {}, transactions: {} });
+        expect(extended).toBe(database);
+    });
+    describe("database.store.actions (unwrapped actions)", () => {
+        it("should expose unwrapped actions on store that execute directly", () => {
+            const database = createTestDatabase();
+            // Execute using unwrapped action
+            const entity = database.store.actions.createPositionEntity({
+                position: { x: 1, y: 2, z: 3 },
+            });
+            // Verify entity was created
+            expect(entity).toBeDefined();
+            const location = database.locate(entity);
+            expect(location).not.toBeNull();
+            expect(location?.archetype).toBe(database.archetypes.Position);
+        });
+        it("should not trigger observable notifications when using store.actions", async () => {
+            const database = createTestDatabase();
+            const transactionObserver = vi.fn();
+            const componentObserver = vi.fn();
+            // Subscribe to observables
+            const unsubscribeTransaction = database.observe.transactions(transactionObserver);
+            const unsubscribeComponent = database.observe.components.position(componentObserver);
+            // Execute using unwrapped action (should NOT notify)
+            database.store.actions.createPositionEntity({
+                position: { x: 1, y: 2, z: 3 },
+            });
+            // Wait for any potential async notifications
+            await Promise.resolve();
+            // Verify NO notifications were sent
+            expect(transactionObserver).not.toHaveBeenCalled();
+            expect(componentObserver).not.toHaveBeenCalled();
+            // Now use wrapped transaction to verify observers work
+            database.transactions.createPositionEntity({
+                position: { x: 4, y: 5, z: 6 },
+            });
+            await Promise.resolve();
+            // Verify notifications WERE sent for wrapped transaction
+            expect(transactionObserver).toHaveBeenCalledTimes(1);
+            expect(componentObserver).toHaveBeenCalledTimes(1);
+            unsubscribeTransaction();
+            unsubscribeComponent();
+        });
+        it("should not create undo entries when using store.actions", async () => {
+            const database = createTestDatabase();
+            // Track transaction notifications to verify behavior
+            const transactionObserver = vi.fn();
+            const unsubscribe = database.observe.transactions(transactionObserver);
+            // Execute using unwrapped action
+            database.store.actions.createPositionEntity({
+                position: { x: 1, y: 2, z: 3 },
+            });
+            await Promise.resolve();
+            // Verify NO transaction notification (meaning no undo entry would be created)
+            expect(transactionObserver).not.toHaveBeenCalled();
+            // Execute using wrapped transaction
+            database.transactions.createPositionEntity({
+                position: { x: 4, y: 5, z: 6 },
+            });
+            await Promise.resolve();
+            // Verify transaction notification WAS sent (meaning undo entry would be created)
+            expect(transactionObserver).toHaveBeenCalledTimes(1);
+            unsubscribe();
+        });
+        it("should support all transaction types on store.actions", () => {
+            const database = createTestDatabase();
+            // Test entity creation
+            const entity = database.store.actions.createPositionEntity({
+                position: { x: 1, y: 2, z: 3 },
+            });
+            expect(entity).toBeDefined();
+            expect(database.locate(entity)).not.toBeNull();
+            // Test entity update
+            database.store.actions.updateEntity({
+                entity,
+                values: { position: { x: 10, y: 20, z: 30 } },
+            });
+            expect(database.locate(entity)).not.toBeNull();
+            // Test resource update
+            database.store.actions.updateTime({ delta: 0.033, elapsed: 1.5 });
+            expect(database.resources.time).toEqual({ delta: 0.033, elapsed: 1.5 });
+            // Test entity deletion
+            database.store.actions.deleteEntity({ entity });
+            expect(database.locate(entity)).toBeNull();
+        });
+        it("should add new actions to store.actions when database is extended", () => {
+            const database = createTestDatabase();
+            // Verify original action exists
+            expect(database.store.actions.createPositionEntity).toBeDefined();
+            // Define extension with new transaction
+            const extensionSchema = {
+                components: {
+                    velocity: {
+                        type: "object",
+                        properties: {
+                            x: { type: "number", precision: 1, default: 0 },
+                            y: { type: "number", precision: 1, default: 0 },
+                            z: { type: "number", precision: 1, default: 0 },
+                        },
+                        required: ["x", "y", "z"],
+                        additionalProperties: false,
+                    },
+                },
+                resources: {},
+                archetypes: {
+                    Moving: ["position", "velocity"],
+                },
+                transactions: {
+                    createMovingEntity(t, args) {
+                        return t.archetypes.Moving.insert({
+                            position: args.position,
+                            velocity: args.velocity,
+                        });
+                    },
+                },
+            };
+            // Extend database
+            const extendedDatabase = database.extend(extensionSchema);
+            // Verify new action exists on store.actions
+            expect(extendedDatabase.store.actions.createMovingEntity).toBeDefined();
+            expect(typeof extendedDatabase.store.actions.createMovingEntity).toBe("function");
+            // Verify new action exists on transactions
+            expect(extendedDatabase.transactions.createMovingEntity).toBeDefined();
+            expect(typeof extendedDatabase.transactions.createMovingEntity).toBe("function");
+            // Test that the new unwrapped action works
+            const entity = extendedDatabase.store.actions.createMovingEntity({
+                position: { x: 1, y: 2, z: 3 },
+                velocity: { x: 0.1, y: 0.2, z: 0.3 },
+            });
+            expect(entity).toBeDefined();
+            const location = extendedDatabase.locate(entity);
+            expect(location).not.toBeNull();
+            // Verify entity was created successfully
+            expect(typeof entity).toBe("number");
+        });
+        it("should execute store.actions synchronously and return values immediately", () => {
+            const database = createTestDatabase();
+            // Unwrapped action should return immediately (no promise)
+            const entity = database.store.actions.createPositionEntity({
+                position: { x: 1, y: 2, z: 3 },
+            });
+            // Should be a number, not a promise
+            expect(typeof entity).toBe("number");
+            expect(entity).toBeGreaterThan(0);
+            // Verify entity exists immediately
+            const location = database.locate(entity);
+            expect(location).not.toBeNull();
+        });
+        it("should have store.actions work independently from transactions", async () => {
+            const database = createTestDatabase();
+            const observer = vi.fn();
+            const unsubscribe = database.observe.transactions(observer);
+            // Create entity using store.actions (no notification)
+            const entity1 = database.store.actions.createPositionEntity({
+                position: { x: 1, y: 2, z: 3 },
+            });
+            // Create entity using transactions (with notification)
+            const entity2 = database.transactions.createPositionEntity({
+                position: { x: 4, y: 5, z: 6 },
+            });
+            await Promise.resolve();
+            // Only one notification (from transactions, not store.actions)
+            expect(observer).toHaveBeenCalledTimes(1);
+            // Both entities should exist
+            expect(database.locate(entity1)).not.toBeNull();
+            expect(database.locate(entity2)).not.toBeNull();
+            unsubscribe();
+        });
+    });
+});
+//# sourceMappingURL=create-database.test.js.map