@adobe/data 0.9.0 → 0.9.1

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

@@ -1,903 +0,0 @@
-/*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 { createDatabase } from "./public/create-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 transactions = {
-        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, transactions };
-};
-const createSequentialClock = (sequence, startFallback = 1) => {
-    let index = 0;
-    let current = Math.max(startFallback, 1);
-    return () => {
-        if (index < sequence.length) {
-            const value = sequence[index++];
-            current = Math.max(value, current);
-            return value;
-        }
-        current += 1;
-        return current;
-    };
-};
-function createTestDatabase(now = Date.now) {
-    const { baseStore, transactions } = createStoreConfig();
-    return createDatabase(baseStore, transactions, now);
-}
-describe("createDatabase", () => {
-    it("should replay out-of-order commits by absolute time in reconciling database", () => {
-        const { baseStore, transactions } = createStoreConfig();
-        const reconciling = createReconcilingDatabase(baseStore, transactions);
-        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(["EarlyCommit", "LateCommit"]);
-    });
-    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));
-            // Verify transient entry exists during processing
-            const serializedDuring = store.toData();
-            const transientEntries = serializedDuring.appliedEntries?.filter(e => e !== null && e !== undefined);
-            expect(transientEntries).toBeDefined();
-            if (transientEntries && transientEntries.length > 0) {
-                // If we caught it during processing, verify it's a transient entry
-                expect(transientEntries[0].args?.name).toMatch(/Yield[123]/);
-            }
-            // 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 the transient entry is removed from the reconciling queue
-            const serializedAfter = store.toData();
-            expect(serializedAfter.appliedEntries ?? []).toHaveLength(0);
-            // 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 transactions
-            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(createSequentialClock([2, 1], 2));
-            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();
-            expect(Array.isArray(serializedData.appliedEntries)).toBe(true);
-            const newStore = createTestDatabase(createSequentialClock([0.5], 1));
-            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 remove cancelled applied entries", async () => {
-            const store = createTestDatabase();
-            let rejectGenerator = () => { };
-            const generator = async function* () {
-                yield { position: { x: 1, y: 1, z: 1 }, name: "Transient" };
-                await new Promise((_, reject) => {
-                    rejectGenerator = reject;
-                });
-            };
-            const promise = store.transactions.createPositionNameEntity(generator);
-            // Allow the first yield to be processed
-            await new Promise(resolve => setTimeout(resolve, 0));
-            const serializedBefore = store.toData();
-            expect(serializedBefore.appliedEntries).toHaveLength(1);
-            const transientId = serializedBefore.appliedEntries[0].id;
-            store.cancelTransaction(transientId);
-            rejectGenerator(new Error("cancelled"));
-            await expect(promise).rejects.toThrow("cancelled");
-            const serializedAfter = store.toData();
-            expect(serializedAfter.appliedEntries ?? []).toHaveLength(0);
-            const entities = store.select(["position"]);
-            expect(entities).toHaveLength(0);
-        });
-        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, transactions } = createStoreConfig();
-            const database = createDatabase(baseStore, {
-                ...transactions,
-                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 transactions to the undo stack", async () => {
-            const store = createTestDatabase();
-            // Create database with undo-redo service
-            const { baseStore, transactions } = createStoreConfig();
-            const database = createDatabase(baseStore, {
-                ...transactions,
-                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, transactions } = createStoreConfig();
-            const database = createDatabase(baseStore, {
-                ...transactions,
-                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);
-        });
-    });
-    describe("extend", () => {
-        it("extends schema and exposes new archetypes and resources", () => {
-            const baseStore = Store.create({
-                components: { position: { type: "number" } },
-                resources: { gravity: { type: "number", default: 9.8 } },
-                archetypes: { Position: ["position"] },
-            });
-            const database = createDatabase(baseStore, {
-                setPosition(t, args) {
-                    t.update(args.entity, { position: args.position });
-                },
-            });
-            const original = baseStore.archetypes.Position.insert({ position: 1 });
-            database.transactions.setPosition({ entity: original, position: 2 });
-            expect(database.read(original)?.position).toBe(2);
-            const extendedDatabase = database.extend({
-                components: { velocity: { type: "number" } },
-                resources: { drag: { type: "number", default: 1 } },
-                archetypes: { Dynamic: ["position", "velocity"] },
-            });
-            const dynamic = baseStore.archetypes.Dynamic.insert({ position: 0, velocity: 5 });
-            expect(extendedDatabase.read(dynamic)?.velocity).toBe(5);
-            expect(extendedDatabase.resources.drag).toBe(1);
-            baseStore.resources.drag = 2;
-            expect(extendedDatabase.resources.drag).toBe(2);
-        });
-        it("throws when extending with conflicting schema", () => {
-            const baseStore = Store.create({
-                components: { position: { type: "number" } },
-                resources: {},
-                archetypes: { Position: ["position"] },
-            });
-            const database = createDatabase(baseStore, {});
-            expect(() => database.extend({
-                components: { position: { type: "string" } },
-                resources: {},
-                archetypes: {},
-            })).toThrow("Component schema for \"position\" must be identical when extending.");
-        });
-    });
-});
-//# sourceMappingURL=create-database.test.js.map