@powerhousedao/vetra 4.1.0-dev.81 → 4.1.0-dev.83

package/dist/document-models/app-module/src/reducers/base-operations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-operations.d.ts","sourceRoot":"","sources":["../../../../../document-models/app-module/src/reducers/base-operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yCAAyC,CAAC;AAEjG,eAAO,MAAM,OAAO,EAAE,iCA2BrB,CAAC"}
+{"version":3,"file":"base-operations.d.ts","sourceRoot":"","sources":["../../../../../document-models/app-module/src/reducers/base-operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,yCAAyC,CAAC;AAEjG,eAAO,MAAM,OAAO,EAAE,iCA+BrB,CAAC"}

package/dist/document-models/app-module/src/reducers/base-operations.js

@@ -1,6 +1,10 @@
 export const reducer = {
     setAppNameOperation(state, action, dispatch) {
-        state.name = action.input.name;
+        const trimmedName = action.input.name.trim();
+        if (trimmedName === "") {
+            throw new Error("App name cannot be empty");
+        }
+        state.name = trimmedName;
     },
     setAppStatusOperation(state, action, dispatch) {
         state.status = action.input.status;

package/dist/document-models/app-module/src/tests/base-operations.test.js

@@ -2,47 +2,174 @@
  * This is a scaffold file meant for customization:
  * - change it by adding new tests or modifying the existing ones
  */
-import { generateMock } from "@powerhousedao/codegen";
 import { beforeEach, describe, expect, it } from "vitest";
 import * as creators from "../../gen/base-operations/creators.js";
 import { reducer } from "../../gen/reducer.js";
-import { z } from "../../gen/schema/index.js";
 import utils from "../../gen/utils.js";
 describe("BaseOperations Operations", () => {
     let document;
     beforeEach(() => {
         document = utils.createDocument();
     });
-    it("should handle setAppName operation", () => {
-        const input = generateMock(z.SetAppNameInputSchema());
-        const updatedDocument = reducer(document, creators.setAppName(input));
-        expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("SET_APP_NAME");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
-        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    describe("setAppName", () => {
+        it("should mutate state with new name", () => {
+            const input = { name: "My Test App" };
+            const updatedDocument = reducer(document, creators.setAppName(input));
+            expect(updatedDocument.state.global.name).toBe("My Test App");
+        });
+        it("should reject empty string and store error in operation", () => {
+            const input = { name: "" };
+            const updatedDocument = reducer(document, creators.setAppName(input));
+            // The operation should be recorded but with an error
+            expect(updatedDocument.operations.global).toHaveLength(1);
+            expect(updatedDocument.operations.global[0].error).toBe("App name cannot be empty");
+            // State should remain unchanged
+            expect(updatedDocument.state.global.name).toBe("");
+        });
+        it("should reject whitespace-only name and store error in operation", () => {
+            const input = { name: "   " };
+            const updatedDocument = reducer(document, creators.setAppName(input));
+            // The operation should be recorded but with an error
+            expect(updatedDocument.operations.global).toHaveLength(1);
+            expect(updatedDocument.operations.global[0].error).toBe("App name cannot be empty");
+            // State should remain unchanged
+            expect(updatedDocument.state.global.name).toBe("");
+        });
     });
-    it("should handle setAppStatus operation", () => {
-        const input = generateMock(z.SetAppStatusInputSchema());
-        const updatedDocument = reducer(document, creators.setAppStatus(input));
-        expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("SET_APP_STATUS");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
-        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    describe("setAppStatus", () => {
+        it("should mutate state with new status", () => {
+            const input = { status: "CONFIRMED" };
+            const updatedDocument = reducer(document, creators.setAppStatus(input));
+            expect(updatedDocument.state.global.status).toBe("CONFIRMED");
+        });
+        it("should transition from DRAFT to CONFIRMED", () => {
+            expect(document.state.global.status).toBe("DRAFT");
+            const updatedDocument = reducer(document, creators.setAppStatus({ status: "CONFIRMED" }));
+            expect(updatedDocument.state.global.status).toBe("CONFIRMED");
+        });
+        it("should transition from CONFIRMED to DRAFT", () => {
+            const confirmedDoc = reducer(document, creators.setAppStatus({ status: "CONFIRMED" }));
+            const updatedDocument = reducer(confirmedDoc, creators.setAppStatus({ status: "DRAFT" }));
+            expect(updatedDocument.state.global.status).toBe("DRAFT");
+        });
+        it("should handle setting same status twice", () => {
+            const firstUpdate = reducer(document, creators.setAppStatus({ status: "CONFIRMED" }));
+            const secondUpdate = reducer(firstUpdate, creators.setAppStatus({ status: "CONFIRMED" }));
+            expect(secondUpdate.state.global.status).toBe("CONFIRMED");
+            expect(secondUpdate.operations.global).toHaveLength(2);
+        });
     });
-    it("should handle addDocumentType operation", () => {
-        const input = generateMock(z.AddDocumentTypeInputSchema());
-        const updatedDocument = reducer(document, creators.addDocumentType(input));
-        expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_DOCUMENT_TYPE");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
-        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    describe("addDocumentType", () => {
+        it("should mutate state by adding document type to array", () => {
+            const input = {
+                documentType: "powerhouse/test",
+            };
+            const updatedDocument = reducer(document, creators.addDocumentType(input));
+            expect(updatedDocument.state.global.allowedDocumentTypes).toContain("powerhouse/test");
+        });
+        it("should initialize array when allowedDocumentTypes is null", () => {
+            // Initial state has allowedDocumentTypes as null
+            expect(document.state.global.allowedDocumentTypes).toBeNull();
+            const input = {
+                documentType: "powerhouse/first",
+            };
+            const updatedDocument = reducer(document, creators.addDocumentType(input));
+            expect(updatedDocument.state.global.allowedDocumentTypes).toEqual([
+                "powerhouse/first",
+            ]);
+        });
+        it("should add multiple document types sequentially", () => {
+            let updatedDoc = reducer(document, creators.addDocumentType({
+                documentType: "powerhouse/a",
+            }));
+            updatedDoc = reducer(updatedDoc, creators.addDocumentType({
+                documentType: "powerhouse/b",
+            }));
+            updatedDoc = reducer(updatedDoc, creators.addDocumentType({
+                documentType: "powerhouse/c",
+            }));
+            expect(updatedDoc.state.global.allowedDocumentTypes).toHaveLength(3);
+            expect(updatedDoc.state.global.allowedDocumentTypes).toContain("powerhouse/a");
+            expect(updatedDoc.state.global.allowedDocumentTypes).toContain("powerhouse/b");
+            expect(updatedDoc.state.global.allowedDocumentTypes).toContain("powerhouse/c");
+        });
+        it("should reject duplicate document types", () => {
+            const input = {
+                documentType: "powerhouse/duplicate",
+            };
+            // First addition should succeed
+            let updatedDoc = reducer(document, creators.addDocumentType(input));
+            expect(updatedDoc.state.global.allowedDocumentTypes).toHaveLength(1);
+            // Second addition with same documentType should not add duplicate (uses Set)
+            updatedDoc = reducer(updatedDoc, creators.addDocumentType({
+                documentType: "powerhouse/duplicate",
+            }));
+            // Should still only have 1 item (no duplicates in a Set)
+            expect(updatedDoc.state.global.allowedDocumentTypes).toHaveLength(1);
+            expect(updatedDoc.state.global.allowedDocumentTypes).toContain("powerhouse/duplicate");
+        });
+        it("should handle adding various documentType values", () => {
+            let updatedDoc = reducer(document, creators.addDocumentType({ documentType: "powerhouse/budget" }));
+            updatedDoc = reducer(updatedDoc, creators.addDocumentType({ documentType: "powerhouse/document-model" }));
+            updatedDoc = reducer(updatedDoc, creators.addDocumentType({ documentType: "custom/type" }));
+            expect(updatedDoc.state.global.allowedDocumentTypes).toContain("powerhouse/budget");
+            expect(updatedDoc.state.global.allowedDocumentTypes).toContain("powerhouse/document-model");
+            expect(updatedDoc.state.global.allowedDocumentTypes).toContain("custom/type");
+        });
     });
-    it("should handle removeDocumentType operation", () => {
-        const input = generateMock(z.RemoveDocumentTypeInputSchema());
-        const updatedDocument = reducer(document, creators.removeDocumentType(input));
-        expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_DOCUMENT_TYPE");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
-        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    describe("removeDocumentType", () => {
+        it("should mutate state by removing document type from array", () => {
+            // First add a document type
+            let updatedDoc = reducer(document, creators.addDocumentType({
+                documentType: "powerhouse/to-remove",
+            }));
+            expect(updatedDoc.state.global.allowedDocumentTypes).toContain("powerhouse/to-remove");
+            // Then remove it
+            updatedDoc = reducer(updatedDoc, creators.removeDocumentType({ documentType: "powerhouse/to-remove" }));
+            expect(updatedDoc.state.global.allowedDocumentTypes).not.toContain("powerhouse/to-remove");
+        });
+        it("should remove existing document type", () => {
+            let updatedDoc = reducer(document, creators.addDocumentType({
+                documentType: "powerhouse/existing",
+            }));
+            const lengthBefore = updatedDoc.state.global.allowedDocumentTypes?.length ?? 0;
+            updatedDoc = reducer(updatedDoc, creators.removeDocumentType({ documentType: "powerhouse/existing" }));
+            expect(updatedDoc.state.global.allowedDocumentTypes?.length).toBe(lengthBefore - 1);
+            expect(updatedDoc.state.global.allowedDocumentTypes?.includes("powerhouse/existing")).toBe(false);
+        });
+        it("should gracefully handle non-existent document type", () => {
+            const updatedDocument = reducer(document, creators.removeDocumentType({ documentType: "non-existent-type" }));
+            // Should result in empty array
+            expect(updatedDocument.state.global.allowedDocumentTypes).toEqual([]);
+        });
+        it("should handle null array gracefully", () => {
+            expect(document.state.global.allowedDocumentTypes).toBeNull();
+            const updatedDocument = reducer(document, creators.removeDocumentType({ documentType: "any-type" }));
+            expect(updatedDocument.state.global.allowedDocumentTypes).toEqual([]);
+        });
+        it("should add then immediately remove item", () => {
+            let updatedDoc = reducer(document, creators.addDocumentType({
+                documentType: "powerhouse/temp",
+            }));
+            updatedDoc = reducer(updatedDoc, creators.removeDocumentType({ documentType: "powerhouse/temp" }));
+            expect(updatedDoc.state.global.allowedDocumentTypes?.includes("powerhouse/temp")).toBe(false);
+            expect(updatedDoc.operations.global).toHaveLength(2);
+        });
+        it("should remove from list and preserve other items", () => {
+            let updatedDoc = reducer(document, creators.addDocumentType({
+                documentType: "powerhouse/a",
+            }));
+            updatedDoc = reducer(updatedDoc, creators.addDocumentType({
+                documentType: "powerhouse/b",
+            }));
+            updatedDoc = reducer(updatedDoc, creators.addDocumentType({
+                documentType: "powerhouse/c",
+            }));
+            updatedDoc = reducer(updatedDoc, creators.removeDocumentType({ documentType: "powerhouse/b" }));
+            expect(updatedDoc.state.global.allowedDocumentTypes).toHaveLength(2);
+            expect(updatedDoc.state.global.allowedDocumentTypes).toContain("powerhouse/a");
+            expect(updatedDoc.state.global.allowedDocumentTypes).toContain("powerhouse/c");
+            expect(updatedDoc.state.global.allowedDocumentTypes).not.toContain("powerhouse/b");
+        });
     });
 });

package/dist/document-models/app-module/src/tests/dnd-operations.test.js

@@ -13,12 +13,43 @@ describe("DndOperations Operations", () => {
     beforeEach(() => {
         document = utils.createDocument();
     });
-    it("should handle setDragAndDropEnabled operation", () => {
-        const input = generateMock(z.SetDragAndDropEnabledInputSchema());
-        const updatedDocument = reducer(document, creators.setDragAndDropEnabled(input));
-        expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("SET_DRAG_AND_DROP_ENABLED");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
-        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    describe("setDragAndDropEnabled", () => {
+        it("should handle setDragAndDropEnabled operation", () => {
+            const input = generateMock(z.SetDragAndDropEnabledInputSchema());
+            const updatedDocument = reducer(document, creators.setDragAndDropEnabled(input));
+            expect(updatedDocument.operations.global).toHaveLength(1);
+            expect(updatedDocument.operations.global[0].action.type).toBe("SET_DRAG_AND_DROP_ENABLED");
+            expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
+            expect(updatedDocument.operations.global[0].index).toEqual(0);
+        });
+        it("should mutate state with new enabled value", () => {
+            const input = { enabled: false };
+            const updatedDocument = reducer(document, creators.setDragAndDropEnabled(input));
+            expect(updatedDocument.state.global.isDragAndDropEnabled).toBe(false);
+        });
+        it("should enable drag and drop from initial state", () => {
+            // Initial state has isDragAndDropEnabled = true
+            expect(document.state.global.isDragAndDropEnabled).toBe(true);
+            const updatedDocument = reducer(document, creators.setDragAndDropEnabled({ enabled: true }));
+            expect(updatedDocument.state.global.isDragAndDropEnabled).toBe(true);
+        });
+        it("should disable drag and drop", () => {
+            const updatedDocument = reducer(document, creators.setDragAndDropEnabled({ enabled: false }));
+            expect(updatedDocument.state.global.isDragAndDropEnabled).toBe(false);
+        });
+        it("should toggle drag and drop in sequence", () => {
+            let updatedDoc = reducer(document, creators.setDragAndDropEnabled({ enabled: false }));
+            expect(updatedDoc.state.global.isDragAndDropEnabled).toBe(false);
+            updatedDoc = reducer(updatedDoc, creators.setDragAndDropEnabled({ enabled: true }));
+            expect(updatedDoc.state.global.isDragAndDropEnabled).toBe(true);
+            updatedDoc = reducer(updatedDoc, creators.setDragAndDropEnabled({ enabled: false }));
+            expect(updatedDoc.state.global.isDragAndDropEnabled).toBe(false);
+            expect(updatedDoc.operations.global).toHaveLength(3);
+        });
+        it("should update boolean field directly", () => {
+            const updatedDocument = reducer(document, creators.setDragAndDropEnabled({ enabled: false }));
+            expect(updatedDocument.state.global.isDragAndDropEnabled).toBeDefined();
+            expect(typeof updatedDocument.state.global.isDragAndDropEnabled).toBe("boolean");
+        });
     });
 });

package/dist/document-models/app-module/src/tests/document-model.test.js

@@ -2,17 +2,89 @@
  * This is a scaffold file meant for customization:
  * - change it by adding new tests or modifying the existing ones
  */
-import { describe, it, expect, beforeEach } from "vitest";
-import utils, { initialGlobalState, initialLocalState, } from "../../gen/utils.js";
+import { describe, expect, it } from "vitest";
+import * as baseCreators from "../../gen/base-operations/creators.js";
+import * as dndCreators from "../../gen/dnd-operations/creators.js";
+import { reducer } from "../../gen/reducer.js";
+import utils from "../../gen/utils.js";
 describe("App Module Document Model", () => {
-    it("should create a new App Module document", () => {
+    it("should have correct initial values", () => {
         const document = utils.createDocument();
-        expect(document).toBeDefined();
-        expect(document.header.documentType).toBe("powerhouse/app");
+        expect(document.state.global.name).toBe("");
+        expect(document.state.global.status).toBe("DRAFT");
+        expect(document.state.global.allowedDocumentTypes).toBeNull();
+        expect(document.state.global.isDragAndDropEnabled).toBe(true);
     });
-    it("should create a new App Module document with a valid initial state", () => {
+    it("should handle multiple operations and maintain consistency", () => {
         const document = utils.createDocument();
-        expect(document.state.global).toStrictEqual(initialGlobalState);
-        expect(document.state.local).toStrictEqual(initialLocalState);
+        let updatedDoc = reducer(document, baseCreators.setAppName({ name: "Test App" }));
+        updatedDoc = reducer(updatedDoc, baseCreators.setAppStatus({ status: "CONFIRMED" }));
+        updatedDoc = reducer(updatedDoc, baseCreators.addDocumentType({
+            documentType: "powerhouse/test",
+        }));
+        // Verify state consistency
+        expect(updatedDoc.state.global.name).toBe("Test App");
+        expect(updatedDoc.state.global.status).toBe("CONFIRMED");
+        expect(updatedDoc.state.global.allowedDocumentTypes).toHaveLength(1);
+    });
+    describe("Complex Scenarios", () => {
+        it("should handle locked configuration: disable DnD and clear document types", () => {
+            const document = utils.createDocument();
+            // Add some document types first
+            let updatedDoc = reducer(document, baseCreators.addDocumentType({ documentType: "powerhouse/type1" }));
+            updatedDoc = reducer(updatedDoc, baseCreators.addDocumentType({ documentType: "powerhouse/type2" }));
+            // Disable drag and drop
+            updatedDoc = reducer(updatedDoc, dndCreators.setDragAndDropEnabled({ enabled: false }));
+            expect(updatedDoc.state.global.isDragAndDropEnabled).toBe(false);
+            // Remove all document types
+            updatedDoc = reducer(updatedDoc, baseCreators.removeDocumentType({ documentType: "powerhouse/type1" }));
+            updatedDoc = reducer(updatedDoc, baseCreators.removeDocumentType({ documentType: "powerhouse/type2" }));
+            expect(updatedDoc.state.global.allowedDocumentTypes).toEqual([]);
+            // Set as confirmed to "lock" it
+            updatedDoc = reducer(updatedDoc, baseCreators.setAppStatus({ status: "CONFIRMED" }));
+            // Verify locked configuration
+            expect(updatedDoc.state.global.isDragAndDropEnabled).toBe(false);
+            expect(updatedDoc.state.global.allowedDocumentTypes).toHaveLength(0);
+            expect(updatedDoc.state.global.status).toBe("CONFIRMED");
+        });
+        it("should handle reset scenario: add new document types from scratch", () => {
+            const document = utils.createDocument();
+            // Start with null allowedDocumentTypes
+            expect(document.state.global.allowedDocumentTypes).toBeNull();
+            // Add new types from scratch
+            let updatedDoc = reducer(document, baseCreators.addDocumentType({
+                documentType: "powerhouse/new1",
+            }));
+            updatedDoc = reducer(updatedDoc, baseCreators.addDocumentType({
+                documentType: "powerhouse/new2",
+            }));
+            updatedDoc = reducer(updatedDoc, baseCreators.addDocumentType({
+                documentType: "powerhouse/new3",
+            }));
+            // Verify reset completed
+            expect(updatedDoc.state.global.allowedDocumentTypes).toHaveLength(3);
+            expect(updatedDoc.state.global.allowedDocumentTypes?.includes("powerhouse/new1")).toBe(true);
+            expect(updatedDoc.state.global.allowedDocumentTypes?.includes("powerhouse/new2")).toBe(true);
+            expect(updatedDoc.state.global.allowedDocumentTypes?.includes("powerhouse/new3")).toBe(true);
+        });
+        it("should maintain state integrity with complex add/remove sequences", () => {
+            const document = utils.createDocument();
+            // Add multiple types
+            let updatedDoc = reducer(document, baseCreators.addDocumentType({ documentType: "type-a" }));
+            updatedDoc = reducer(updatedDoc, baseCreators.addDocumentType({ documentType: "type-b" }));
+            updatedDoc = reducer(updatedDoc, baseCreators.addDocumentType({ documentType: "type-c" }));
+            expect(updatedDoc.state.global.allowedDocumentTypes).toHaveLength(3);
+            // Remove middle one
+            updatedDoc = reducer(updatedDoc, baseCreators.removeDocumentType({ documentType: "type-b" }));
+            expect(updatedDoc.state.global.allowedDocumentTypes).toHaveLength(2);
+            // Add it back with different name
+            updatedDoc = reducer(updatedDoc, baseCreators.addDocumentType({ documentType: "type-b-new" }));
+            expect(updatedDoc.state.global.allowedDocumentTypes).toHaveLength(3);
+            // Verify content
+            expect(updatedDoc.state.global.allowedDocumentTypes?.includes("type-a")).toBe(true);
+            expect(updatedDoc.state.global.allowedDocumentTypes?.includes("type-c")).toBe(true);
+            expect(updatedDoc.state.global.allowedDocumentTypes?.includes("type-b-new")).toBe(true);
+            expect(updatedDoc.state.global.allowedDocumentTypes?.includes("type-b")).toBe(false);
+        });
     });
 });

package/dist/document-models/document-editor/src/reducers/base-operations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-operations.d.ts","sourceRoot":"","sources":["../../../../../document-models/document-editor/src/reducers/base-operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sCAAsC,EAAE,MAAM,yCAAyC,CAAC;AAEtG,eAAO,MAAM,OAAO,EAAE,sCAkBrB,CAAC"}
+{"version":3,"file":"base-operations.d.ts","sourceRoot":"","sources":["../../../../../document-models/document-editor/src/reducers/base-operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sCAAsC,EAAE,MAAM,yCAAyC,CAAC;AAEtG,eAAO,MAAM,OAAO,EAAE,sCAgCrB,CAAC"}

package/dist/document-models/document-editor/src/reducers/base-operations.js

@@ -1,8 +1,17 @@
 export const reducer = {
     setEditorNameOperation(state, action, dispatch) {
-        state.name = action.input.name;
+        const trimmedName = action.input.name.trim();
+        if (trimmedName === "") {
+            throw new Error("Editor name cannot be empty");
+        }
+        state.name = trimmedName;
     },
     addDocumentTypeOperation(state, action, dispatch) {
+        // Check for duplicate ID
+        const existingId = state.documentTypes.find((dt) => dt.id === action.input.id);
+        if (existingId) {
+            throw new Error(`Document type with id "${action.input.id}" already exists`);
+        }
         state.documentTypes.push({
             id: action.input.id,
             documentType: action.input.documentType,

package/dist/document-models/document-editor/src/tests/base-operations.test.js

@@ -2,39 +2,153 @@
  * This is a scaffold file meant for customization:
  * - change it by adding new tests or modifying the existing ones
  */
-import { generateMock } from "@powerhousedao/codegen";
 import { beforeEach, describe, expect, it } from "vitest";
 import * as creators from "../../gen/base-operations/creators.js";
 import { reducer } from "../../gen/reducer.js";
-import { z } from "../../gen/schema/index.js";
 import utils from "../../gen/utils.js";
 describe("BaseOperations Operations", () => {
     let document;
     beforeEach(() => {
         document = utils.createDocument();
     });
-    it("should handle setEditorName operation", () => {
-        const input = generateMock(z.SetEditorNameInputSchema());
-        const updatedDocument = reducer(document, creators.setEditorName(input));
-        expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("SET_EDITOR_NAME");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
-        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    describe("setEditorName", () => {
+        it("should mutate state with new name", () => {
+            const input = { name: "My Editor" };
+            const updatedDocument = reducer(document, creators.setEditorName(input));
+            expect(updatedDocument.state.global.name).toBe("My Editor");
+        });
+        it("should reject empty string and store error in operation", () => {
+            const input = { name: "" };
+            const updatedDocument = reducer(document, creators.setEditorName(input));
+            expect(updatedDocument.operations.global).toHaveLength(1);
+            expect(updatedDocument.operations.global[0].error).toBe("Editor name cannot be empty");
+            expect(updatedDocument.state.global.name).toBe("");
+        });
     });
-    it("should handle addDocumentType operation", () => {
-        const input = generateMock(z.AddDocumentTypeInputSchema());
-        const updatedDocument = reducer(document, creators.addDocumentType(input));
-        expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("ADD_DOCUMENT_TYPE");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
-        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    describe("setEditorStatus", () => {
+        it("should mutate state with new status", () => {
+            const input = { status: "CONFIRMED" };
+            const updatedDocument = reducer(document, creators.setEditorStatus(input));
+            expect(updatedDocument.state.global.status).toBe("CONFIRMED");
+        });
+        it("should transition from DRAFT to CONFIRMED", () => {
+            expect(document.state.global.status).toBe("DRAFT");
+            const updatedDocument = reducer(document, creators.setEditorStatus({ status: "CONFIRMED" }));
+            expect(updatedDocument.state.global.status).toBe("CONFIRMED");
+        });
+        it("should transition from CONFIRMED to DRAFT", () => {
+            const confirmedDoc = reducer(document, creators.setEditorStatus({ status: "CONFIRMED" }));
+            const updatedDocument = reducer(confirmedDoc, creators.setEditorStatus({ status: "DRAFT" }));
+            expect(updatedDocument.state.global.status).toBe("DRAFT");
+        });
     });
-    it("should handle removeDocumentType operation", () => {
-        const input = generateMock(z.RemoveDocumentTypeInputSchema());
-        const updatedDocument = reducer(document, creators.removeDocumentType(input));
-        expect(updatedDocument.operations.global).toHaveLength(1);
-        expect(updatedDocument.operations.global[0].action.type).toBe("REMOVE_DOCUMENT_TYPE");
-        expect(updatedDocument.operations.global[0].action.input).toStrictEqual(input);
-        expect(updatedDocument.operations.global[0].index).toEqual(0);
+    describe("addDocumentType", () => {
+        it("should mutate state by adding document type to array", () => {
+            const input = {
+                id: "test-type-1",
+                documentType: "powerhouse/test",
+            };
+            const updatedDocument = reducer(document, creators.addDocumentType(input));
+            expect(updatedDocument.state.global.documentTypes).toContainEqual({
+                id: "test-type-1",
+                documentType: "powerhouse/test",
+            });
+        });
+        it("should add to empty array from initial state", () => {
+            expect(document.state.global.documentTypes).toEqual([]);
+            const input = {
+                id: "first-type",
+                documentType: "powerhouse/first",
+            };
+            const updatedDocument = reducer(document, creators.addDocumentType(input));
+            expect(updatedDocument.state.global.documentTypes).toEqual([
+                { id: "first-type", documentType: "powerhouse/first" },
+            ]);
+        });
+        it("should add multiple document types sequentially", () => {
+            let updatedDoc = reducer(document, creators.addDocumentType({
+                id: "type-1",
+                documentType: "powerhouse/a",
+            }));
+            updatedDoc = reducer(updatedDoc, creators.addDocumentType({
+                id: "type-2",
+                documentType: "powerhouse/b",
+            }));
+            updatedDoc = reducer(updatedDoc, creators.addDocumentType({
+                id: "type-3",
+                documentType: "powerhouse/c",
+            }));
+            expect(updatedDoc.state.global.documentTypes).toHaveLength(3);
+            expect(updatedDoc.state.global.documentTypes[0]).toEqual({
+                id: "type-1",
+                documentType: "powerhouse/a",
+            });
+            expect(updatedDoc.state.global.documentTypes[1]).toEqual({
+                id: "type-2",
+                documentType: "powerhouse/b",
+            });
+            expect(updatedDoc.state.global.documentTypes[2]).toEqual({
+                id: "type-3",
+                documentType: "powerhouse/c",
+            });
+        });
+        it("should reject duplicate IDs and store error in operation", () => {
+            const input = {
+                id: "duplicate",
+                documentType: "powerhouse/first",
+            };
+            let updatedDoc = reducer(document, creators.addDocumentType(input));
+            expect(updatedDoc.state.global.documentTypes).toHaveLength(1);
+            expect(updatedDoc.operations.global[0].error).toBeUndefined();
+            updatedDoc = reducer(updatedDoc, creators.addDocumentType({
+                id: "duplicate",
+                documentType: "powerhouse/second",
+            }));
+            expect(updatedDoc.operations.global).toHaveLength(2);
+            expect(updatedDoc.operations.global[1].error).toBe('Document type with id "duplicate" already exists');
+            expect(updatedDoc.state.global.documentTypes).toHaveLength(1);
+        });
+    });
+    describe("removeDocumentType", () => {
+        it("should mutate state by removing document type from array", () => {
+            let updatedDoc = reducer(document, creators.addDocumentType({
+                id: "to-remove",
+                documentType: "powerhouse/test",
+            }));
+            updatedDoc = reducer(updatedDoc, creators.removeDocumentType({ id: "to-remove" }));
+            expect(updatedDoc.state.global.documentTypes).not.toContainEqual({
+                id: "to-remove",
+                documentType: "powerhouse/test",
+            });
+        });
+        it("should remove existing ID", () => {
+            let updatedDoc = reducer(document, creators.addDocumentType({
+                id: "existing",
+                documentType: "powerhouse/test",
+            }));
+            const lengthBefore = updatedDoc.state.global.documentTypes.length;
+            updatedDoc = reducer(updatedDoc, creators.removeDocumentType({ id: "existing" }));
+            expect(updatedDoc.state.global.documentTypes.length).toBe(lengthBefore - 1);
+            expect(updatedDoc.state.global.documentTypes.find((dt) => dt.id === "existing")).toBeUndefined();
+        });
+        it("should gracefully handle non-existent ID", () => {
+            const initialState = document.state.global.documentTypes;
+            const updatedDocument = reducer(document, creators.removeDocumentType({ id: "non-existent-id" }));
+            expect(updatedDocument.state.global.documentTypes).toEqual(initialState);
+        });
+        it("should handle empty array gracefully", () => {
+            expect(document.state.global.documentTypes).toEqual([]);
+            const updatedDocument = reducer(document, creators.removeDocumentType({ id: "any-id" }));
+            expect(updatedDocument.state.global.documentTypes).toEqual([]);
+        });
+        it("should add then immediately remove item", () => {
+            let updatedDoc = reducer(document, creators.addDocumentType({
+                id: "temp-type",
+                documentType: "powerhouse/temp",
+            }));
+            updatedDoc = reducer(updatedDoc, creators.removeDocumentType({ id: "temp-type" }));
+            expect(updatedDoc.state.global.documentTypes.find((dt) => dt.id === "temp-type")).toBeUndefined();
+            expect(updatedDoc.operations.global).toHaveLength(2);
+        });
     });
 });