document-model 1.1.0-debug.1 → 1.1.0-debug.2

package/dist/browser/es/internal/index-B1lQN59e.js

@@ -0,0 +1,2340 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var _a;
+import { c as createReducer, i as isBaseAction, a as createExtendedState, b as createDocument, s as saveToFile, d as saveToFileHandle, l as loadFromFile, e as loadFromInput, f as createAction, B as BaseDocument, g as applyMixins, h as BaseActions } from "./object-9mR1JlXD.js";
+import "immer";
+import "jszip";
+import { z } from "zod";
+const SPLIT_LOWER_UPPER_RE = new RegExp("([\\p{Ll}\\d])(\\p{Lu})", "gu");
+const SPLIT_UPPER_UPPER_RE = new RegExp("(\\p{Lu})([\\p{Lu}][\\p{Ll}])", "gu");
+const SPLIT_SEPARATE_NUMBER_RE = new RegExp("(\\d)\\p{Ll}|(\\p{L})\\d", "u");
+const DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+const SPLIT_REPLACE_VALUE = "$1\0$2";
+const DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+function split(value) {
+  let result = value.trim();
+  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+  result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\0")
+    start++;
+  if (start === end)
+    return [];
+  while (result.charAt(end - 1) === "\0")
+    end--;
+  return result.slice(start, end).split(/\0/g);
+}
+function splitSeparateNumbers(value) {
+  const words = split(value);
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i];
+    const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+    if (match) {
+      const offset = match.index + (match[1] ?? match[2]).length;
+      words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+    }
+  }
+  return words;
+}
+function pascalCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  const lower = lowerFactory(options == null ? void 0 : options.locale);
+  const upper = upperFactory(options == null ? void 0 : options.locale);
+  const transform = (options == null ? void 0 : options.mergeAmbiguousCharacters) ? capitalCaseTransformFactory(lower, upper) : pascalCaseTransformFactory(lower, upper);
+  return prefix + words.map(transform).join((options == null ? void 0 : options.delimiter) ?? "") + suffix;
+}
+function lowerFactory(locale) {
+  return locale === false ? (input) => input.toLowerCase() : (input) => input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+  return locale === false ? (input) => input.toUpperCase() : (input) => input.toLocaleUpperCase(locale);
+}
+function capitalCaseTransformFactory(lower, upper) {
+  return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+}
+function pascalCaseTransformFactory(lower, upper) {
+  return (word, index) => {
+    const char0 = word[0];
+    const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
+    return initial + lower(word.slice(1));
+  };
+}
+function splitPrefixSuffix(input, options = {}) {
+  const splitFn = options.split ?? (options.separateNumbers ? splitSeparateNumbers : split);
+  const prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  const suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  let prefixIndex = 0;
+  let suffixIndex = input.length;
+  while (prefixIndex < input.length) {
+    const char = input.charAt(prefixIndex);
+    if (!prefixCharacters.includes(char))
+      break;
+    prefixIndex++;
+  }
+  while (suffixIndex > prefixIndex) {
+    const index = suffixIndex - 1;
+    const char = input.charAt(index);
+    if (!suffixCharacters.includes(char))
+      break;
+    suffixIndex = index;
+  }
+  return [
+    input.slice(0, prefixIndex),
+    splitFn(input.slice(prefixIndex, suffixIndex)),
+    input.slice(suffixIndex)
+  ];
+}
+function validateInitialState(initialState, allowEmptyState = false) {
+  const errors = [];
+  if (allowEmptyState && initialState === "")
+    return errors;
+  try {
+    const state = JSON.parse(initialState);
+    if (!allowEmptyState && !Object.keys(state).length) {
+      errors.push({
+        message: "Initial state cannot be empty",
+        details: {
+          initialState
+        }
+      });
+    }
+  } catch {
+    errors.push({
+      message: "Invalid initial state",
+      details: {
+        initialState
+      }
+    });
+  }
+  return errors;
+}
+function validateStateSchemaName(schema, documentName, scope = "", allowEmptySchema = true) {
+  const errors = [];
+  if (!allowEmptySchema && !schema) {
+    errors.push({
+      message: "State schema is required",
+      details: {
+        schema
+      }
+    });
+    return errors;
+  }
+  if (allowEmptySchema && !schema)
+    return errors;
+  const expectedTypeName = `type ${pascalCase(documentName)}${pascalCase(scope)}State`;
+  if (!schema.includes(expectedTypeName)) {
+    errors.push({
+      message: `Invalid state schema name. Expected ${expectedTypeName}`,
+      details: {
+        schema
+      }
+    });
+  }
+  return errors;
+}
+function validateModules(modules) {
+  const errors = [];
+  if (!modules.length) {
+    errors.push({
+      message: "Modules are required",
+      details: {
+        modules
+      }
+    });
+  }
+  const modulesError = modules.reduce(
+    (acc, mod) => [...acc, ...validateModule(mod)],
+    []
+  );
+  return [...errors, ...modulesError];
+}
+function validateModule(mod) {
+  const errors = [];
+  if (!mod.name) {
+    errors.push({
+      message: "Module name is required",
+      details: {
+        module: mod
+      }
+    });
+  }
+  if (!mod.operations.length) {
+    errors.push({
+      message: "Module operations are required",
+      details: {
+        module: mod
+      }
+    });
+  }
+  const operationErrors = mod.operations.reduce(
+    (acc, operation) => [...acc, ...validateModuleOperation(operation)],
+    []
+  );
+  return [...errors, ...operationErrors];
+}
+function validateModuleOperation(operation) {
+  const errors = [];
+  if (!operation.name) {
+    errors.push({
+      message: "Operation name is required",
+      details: {
+        operation
+      }
+    });
+  }
+  if (!operation.schema) {
+    errors.push({
+      message: "Operation schema is required",
+      details: {
+        operation
+      }
+    });
+  }
+  return errors;
+}
+const customUtils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  validateInitialState,
+  validateModule,
+  validateModuleOperation,
+  validateModules,
+  validateStateSchemaName
+}, Symbol.toStringTag, { value: "Module" }));
+const documentModel = {
+  id: "powerhouse/document-model",
+  name: "DocumentModel",
+  extension: "phdm",
+  description: "The Powerhouse Document Model describes the state and operations of a document type.",
+  author: {
+    name: "Powerhouse",
+    website: "https://www.powerhouse.inc/"
+  },
+  specifications: [
+    {
+      version: 1,
+      changeLog: [],
+      modules: [
+        {
+          name: "header",
+          operations: [
+            {
+              name: "SetModelName",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetModelId",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetModelExtension",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetModelDescription",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetAuthorName",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetAuthorWebsite",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        },
+        {
+          name: "versioning",
+          operations: [
+            {
+              name: "AddChangeLogItem",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "UpdateChangeLogItem",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "DeleteChangeLogItem",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReorderChangeLogItems",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReleaseNewVersion",
+              schema: null,
+              id: "",
+              description: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        },
+        {
+          name: "module",
+          operations: [
+            {
+              name: "AddModule",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetModuleName",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetModuleDescription",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "DeleteModule",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReorderModules",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        },
+        {
+          name: "operation-error",
+          operations: [
+            {
+              name: "AddOperationError",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationErrorCode",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationErrorName",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationErrorDescription",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationErrorTemplate",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "DeleteOperationError",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReorderOperationErrors",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        },
+        {
+          name: "operation-example",
+          operations: [
+            {
+              name: "AddOperationExample",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "UpdateOperationExample",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "DeleteOperationExample",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReorderOperationExamples",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        },
+        {
+          name: "operation",
+          operations: [
+            {
+              name: "AddOperation",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationName",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationSchema",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationDescription",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationTemplate",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetOperationReducer",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "MoveOperation",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "DeleteOperation",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReorderModuleOperations",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        },
+        {
+          name: "state",
+          operations: [
+            {
+              name: "SetStateSchema",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "SetInitialState",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "AddStateExample",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "UpdateStateExample",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "DeleteStateExample",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            },
+            {
+              name: "ReorderStateExamples",
+              id: "",
+              description: "",
+              schema: "",
+              template: "",
+              reducer: "",
+              examples: [],
+              errors: [],
+              scope: "global"
+            }
+          ],
+          id: "",
+          description: ""
+        }
+      ],
+      state: {
+        global: {
+          schema: "",
+          initialValue: '{\n    "id": "",\n    "name": "",\n    "extension": "",\n    "description": "",\n    "author": {\n        "name": "",\n        "website": ""\n    },\n    "specifications": [\n        {\n            "version": 1,\n            "changeLog": [],\n            "state": {\n                "schema": "",\n                "initialValue": "",\n                "examples": []\n            },\n            "modules": []\n        }\n    ]\n}',
+          examples: []
+        },
+        local: {
+          schema: "",
+          initialValue: `{}`,
+          examples: []
+        }
+      }
+    }
+  ]
+};
+const isDefinedNonNullAny = (v) => v !== void 0 && v !== null;
+const definedNonNullAnySchema = z.any().refine((v) => isDefinedNonNullAny(v));
+function AddChangeLogItemInputSchema() {
+  return z.object({
+    __typename: z.literal("AddChangeLogItemInput").optional(),
+    content: z.string(),
+    id: z.string(),
+    insertBefore: z.string().nullable()
+  });
+}
+function AddModuleInputSchema() {
+  return z.object({
+    description: z.string().nullish(),
+    id: z.string(),
+    name: z.string()
+  });
+}
+function AddOperationErrorInputSchema() {
+  return z.object({
+    errorCode: z.string().nullish(),
+    errorDescription: z.string().nullish(),
+    errorName: z.string().nullish(),
+    errorTemplate: z.string().nullish(),
+    id: z.string(),
+    operationId: z.string()
+  });
+}
+function AddOperationExampleInputSchema() {
+  return z.object({
+    example: z.string(),
+    id: z.string(),
+    operationId: z.string()
+  });
+}
+function AddOperationInputSchema() {
+  return z.object({
+    description: z.string().nullish(),
+    id: z.string(),
+    moduleId: z.string(),
+    name: z.string(),
+    reducer: z.string().nullish(),
+    schema: z.string().nullish(),
+    template: z.string().nullish(),
+    scope: OperationScopeSchema().nullish()
+  });
+}
+function AddStateExampleInputSchema() {
+  return z.object({
+    scope: z.string(),
+    example: z.string(),
+    id: z.string(),
+    insertBefore: z.string().nullish()
+  });
+}
+function AuthorSchema() {
+  return z.object({
+    __typename: z.literal("Author").optional(),
+    name: z.string(),
+    website: z.string().nullable()
+  });
+}
+function CodeExampleSchema() {
+  return z.object({
+    __typename: z.literal("CodeExample").optional(),
+    id: z.string(),
+    value: z.string()
+  });
+}
+function DeleteChangeLogItemInputSchema() {
+  return z.object({
+    __typename: z.literal("DeleteChangeLogItemInput").optional(),
+    id: z.string()
+  });
+}
+function DeleteModuleInputSchema() {
+  return z.object({
+    id: z.string()
+  });
+}
+function DeleteOperationErrorInputSchema() {
+  return z.object({
+    id: z.string()
+  });
+}
+function DeleteOperationExampleInputSchema() {
+  return z.object({
+    id: z.string()
+  });
+}
+function DeleteOperationInputSchema() {
+  return z.object({
+    id: z.string()
+  });
+}
+function DeleteStateExampleInputSchema() {
+  return z.object({
+    scope: z.string(),
+    id: z.string()
+  });
+}
+function OperationScopeSchema() {
+  return z.literal("global").or(z.literal("local"));
+}
+function DocumentModelInputSchema() {
+  return z.union([
+    AddChangeLogItemInputSchema(),
+    AddModuleInputSchema(),
+    AddOperationErrorInputSchema(),
+    AddOperationExampleInputSchema(),
+    AddOperationInputSchema(),
+    AddStateExampleInputSchema(),
+    DeleteChangeLogItemInputSchema(),
+    DeleteModuleInputSchema(),
+    DeleteOperationErrorInputSchema(),
+    DeleteOperationExampleInputSchema(),
+    DeleteOperationInputSchema(),
+    DeleteStateExampleInputSchema(),
+    MoveOperationInputSchema(),
+    ReorderChangeLogItemsInputSchema(),
+    ReorderModuleOperationsInputSchema(),
+    ReorderModulesInputSchema(),
+    ReorderOperationErrorsInputSchema(),
+    ReorderOperationExamplesInputSchema(),
+    ReorderStateExamplesInputSchema(),
+    SetAuthorNameInputSchema(),
+    SetAuthorWebsiteInputSchema(),
+    SetInitialStateInputSchema(),
+    SetModelDescriptionInputSchema(),
+    SetModelExtensionInputSchema(),
+    SetModelIdInputSchema(),
+    SetModelNameInputSchema(),
+    SetModuleDescriptionInputSchema(),
+    SetModuleNameInputSchema(),
+    SetOperationDescriptionInputSchema(),
+    SetOperationErrorCodeInputSchema(),
+    SetOperationErrorDescriptionInputSchema(),
+    SetOperationErrorNameInputSchema(),
+    SetOperationErrorTemplateInputSchema(),
+    SetOperationNameInputSchema(),
+    SetOperationReducerInputSchema(),
+    SetOperationSchemaInputSchema(),
+    SetOperationTemplateInputSchema(),
+    SetStateSchemaInputSchema(),
+    UpdateChangeLogItemInputSchema(),
+    UpdateOperationExampleInputSchema(),
+    UpdateStateExampleInputSchema()
+  ]);
+}
+function DocumentModelStateSchema() {
+  return z.object({
+    __typename: z.literal("DocumentModelState").optional(),
+    author: AuthorSchema(),
+    description: z.string(),
+    extension: z.string(),
+    id: z.string(),
+    name: z.string(),
+    specifications: z.array(DocumentSpecificationSchema())
+  });
+}
+function DocumentSpecificationSchema() {
+  return z.object({
+    __typename: z.literal("DocumentSpecification").optional(),
+    changeLog: z.array(z.string()),
+    modules: z.array(ModuleSchema()),
+    state: ScopeStateSchema(),
+    version: z.number()
+  });
+}
+function ModuleSchema() {
+  return z.object({
+    __typename: z.literal("Module").optional(),
+    description: z.string().nullable(),
+    id: z.string(),
+    name: z.string(),
+    operations: z.array(OperationSchema())
+  });
+}
+function MoveOperationInputSchema() {
+  return z.object({
+    newModuleId: z.string(),
+    operationId: z.string()
+  });
+}
+function OperationSchema() {
+  return z.object({
+    __typename: z.literal("Operation").optional(),
+    description: z.string().nullable(),
+    errors: z.array(OperationErrorSchema()),
+    examples: z.array(CodeExampleSchema()),
+    id: z.string(),
+    name: z.string().nullable(),
+    reducer: z.string().nullable(),
+    schema: z.string().nullable(),
+    template: z.string().nullable(),
+    scope: OperationScopeSchema()
+  });
+}
+function OperationErrorSchema() {
+  return z.object({
+    __typename: z.literal("OperationError").optional(),
+    code: z.string().nullable(),
+    description: z.string().nullable(),
+    id: z.string(),
+    name: z.string().nullable(),
+    template: z.string().nullable()
+  });
+}
+function ReorderChangeLogItemsInputSchema() {
+  return z.object({
+    __typename: z.literal("ReorderChangeLogItemsInput").optional(),
+    order: z.array(z.string())
+  });
+}
+function ReorderModuleOperationsInputSchema() {
+  return z.object({
+    moduleId: z.string(),
+    order: z.array(z.string())
+  });
+}
+function ReorderModulesInputSchema() {
+  return z.object({
+    order: z.array(z.string())
+  });
+}
+function ReorderOperationErrorsInputSchema() {
+  return z.object({
+    operationId: z.string(),
+    order: z.array(z.string())
+  });
+}
+function ReorderOperationExamplesInputSchema() {
+  return z.object({
+    operationId: z.string(),
+    order: z.array(z.string())
+  });
+}
+function ReorderStateExamplesInputSchema() {
+  return z.object({
+    scope: z.string(),
+    order: z.array(z.string())
+  });
+}
+function SetAuthorNameInputSchema() {
+  return z.object({
+    authorName: z.string()
+  });
+}
+function SetAuthorWebsiteInputSchema() {
+  return z.object({
+    authorWebsite: z.string()
+  });
+}
+function SetInitialStateInputSchema() {
+  return z.object({
+    scope: z.string(),
+    initialValue: z.string()
+  });
+}
+function SetModelDescriptionInputSchema() {
+  return z.object({
+    description: z.string()
+  });
+}
+function SetModelExtensionInputSchema() {
+  return z.object({
+    extension: z.string()
+  });
+}
+function SetModelIdInputSchema() {
+  return z.object({
+    id: z.string()
+  });
+}
+function SetModelNameInputSchema() {
+  return z.object({
+    name: z.string()
+  });
+}
+function SetModuleDescriptionInputSchema() {
+  return z.object({
+    description: z.string().nullish(),
+    id: z.string()
+  });
+}
+function SetModuleNameInputSchema() {
+  return z.object({
+    id: z.string(),
+    name: z.string().nullish()
+  });
+}
+function SetOperationDescriptionInputSchema() {
+  return z.object({
+    description: z.string().nullish(),
+    id: z.string()
+  });
+}
+function SetOperationErrorCodeInputSchema() {
+  return z.object({
+    errorCode: z.string().nullish(),
+    id: z.string()
+  });
+}
+function SetOperationErrorDescriptionInputSchema() {
+  return z.object({
+    errorDescription: z.string().nullish(),
+    id: z.string()
+  });
+}
+function SetOperationErrorNameInputSchema() {
+  return z.object({
+    errorName: z.string().nullish(),
+    id: z.string()
+  });
+}
+function SetOperationErrorTemplateInputSchema() {
+  return z.object({
+    errorTemplate: z.string().nullish(),
+    id: z.string()
+  });
+}
+function SetOperationNameInputSchema() {
+  return z.object({
+    id: z.string(),
+    name: z.string().nullish()
+  });
+}
+function SetOperationScopeInputSchema() {
+  return z.object({
+    id: z.string(),
+    scope: OperationScopeSchema()
+  });
+}
+function SetOperationReducerInputSchema() {
+  return z.object({
+    id: z.string(),
+    reducer: z.string().nullish()
+  });
+}
+function SetOperationSchemaInputSchema() {
+  return z.object({
+    id: z.string(),
+    schema: z.string().nullish()
+  });
+}
+function SetOperationTemplateInputSchema() {
+  return z.object({
+    id: z.string(),
+    template: z.string().nullish()
+  });
+}
+function SetStateSchemaInputSchema() {
+  return z.object({
+    scope: z.string(),
+    schema: z.string()
+  });
+}
+function StateSchema() {
+  return z.object({
+    __typename: z.literal("State").optional(),
+    examples: z.array(CodeExampleSchema()),
+    initialValue: z.string(),
+    schema: z.string()
+  });
+}
+function ScopeStateSchema() {
+  return z.object({
+    global: StateSchema(),
+    local: StateSchema()
+  });
+}
+function UpdateChangeLogItemInputSchema() {
+  return z.object({
+    __typename: z.literal("UpdateChangeLogItemInput").optional(),
+    id: z.string(),
+    newContent: z.string()
+  });
+}
+function UpdateOperationExampleInputSchema() {
+  return z.object({
+    example: z.string(),
+    id: z.string()
+  });
+}
+function UpdateStateExampleInputSchema() {
+  return z.object({
+    scope: z.string(),
+    id: z.string(),
+    newExample: z.string()
+  });
+}
+const zod = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AddChangeLogItemInputSchema,
+  AddModuleInputSchema,
+  AddOperationErrorInputSchema,
+  AddOperationExampleInputSchema,
+  AddOperationInputSchema,
+  AddStateExampleInputSchema,
+  AuthorSchema,
+  CodeExampleSchema,
+  DeleteChangeLogItemInputSchema,
+  DeleteModuleInputSchema,
+  DeleteOperationErrorInputSchema,
+  DeleteOperationExampleInputSchema,
+  DeleteOperationInputSchema,
+  DeleteStateExampleInputSchema,
+  DocumentModelInputSchema,
+  DocumentModelStateSchema,
+  DocumentSpecificationSchema,
+  ModuleSchema,
+  MoveOperationInputSchema,
+  OperationErrorSchema,
+  OperationSchema,
+  OperationScopeSchema,
+  ReorderChangeLogItemsInputSchema,
+  ReorderModuleOperationsInputSchema,
+  ReorderModulesInputSchema,
+  ReorderOperationErrorsInputSchema,
+  ReorderOperationExamplesInputSchema,
+  ReorderStateExamplesInputSchema,
+  ScopeStateSchema,
+  SetAuthorNameInputSchema,
+  SetAuthorWebsiteInputSchema,
+  SetInitialStateInputSchema,
+  SetModelDescriptionInputSchema,
+  SetModelExtensionInputSchema,
+  SetModelIdInputSchema,
+  SetModelNameInputSchema,
+  SetModuleDescriptionInputSchema,
+  SetModuleNameInputSchema,
+  SetOperationDescriptionInputSchema,
+  SetOperationErrorCodeInputSchema,
+  SetOperationErrorDescriptionInputSchema,
+  SetOperationErrorNameInputSchema,
+  SetOperationErrorTemplateInputSchema,
+  SetOperationNameInputSchema,
+  SetOperationReducerInputSchema,
+  SetOperationSchemaInputSchema,
+  SetOperationScopeInputSchema,
+  SetOperationTemplateInputSchema,
+  SetStateSchemaInputSchema,
+  StateSchema,
+  UpdateChangeLogItemInputSchema,
+  UpdateOperationExampleInputSchema,
+  UpdateStateExampleInputSchema,
+  definedNonNullAnySchema,
+  isDefinedNonNullAny
+}, Symbol.toStringTag, { value: "Module" }));
+const reducer$7 = {
+  setModelNameOperation(state, action) {
+    state.name = action.input.name;
+  },
+  setModelIdOperation(state, action) {
+    state.id = action.input.id;
+  },
+  setModelExtensionOperation(state, action) {
+    state.extension = action.input.extension;
+  },
+  setModelDescriptionOperation(state, action) {
+    state.description = action.input.description;
+  },
+  setAuthorNameOperation(state, action) {
+    state.author = state.author || { name: "", website: null };
+    state.author.name = action.input.authorName;
+  },
+  setAuthorWebsiteOperation(state, action) {
+    state.author = state.author || { name: "", website: null };
+    state.author.website = action.input.authorWebsite;
+  }
+};
+const reducer$6 = {
+  addChangeLogItemOperation(state, action) {
+    throw new Error(
+      'Reducer "addChangeLogItemOperation" not yet implemented'
+    );
+  },
+  updateChangeLogItemOperation(state, action) {
+    throw new Error(
+      'Reducer "updateChangeLogItemOperation" not yet implemented'
+    );
+  },
+  deleteChangeLogItemOperation(state, action) {
+    throw new Error(
+      'Reducer "deleteChangeLogItemOperation" not yet implemented'
+    );
+  },
+  reorderChangeLogItemsOperation(state, action) {
+    throw new Error(
+      'Reducer "reorderChangeLogItemsOperation" not yet implemented'
+    );
+  },
+  releaseNewVersionOperation(state, action) {
+    throw new Error(
+      'Reducer "releaseNewVersionOperation" not yet implemented'
+    );
+  }
+};
+const moduleSorter = (order) => {
+  const mapping = {};
+  order.forEach((key, index) => mapping[key] = index);
+  return (a, b) => (mapping[b.id] || 999999) - (mapping[a.id] || 999999);
+};
+const reducer$5 = {
+  addModuleOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    latestSpec.modules.push({
+      id: action.input.id,
+      name: action.input.name,
+      description: action.input.description || "",
+      operations: []
+    });
+  },
+  setModuleNameOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      if (latestSpec.modules[i].id === action.input.id) {
+        latestSpec.modules[i].name = action.input.name || "";
+      }
+    }
+  },
+  setModuleDescriptionOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      if (latestSpec.modules[i].id === action.input.id) {
+        latestSpec.modules[i].description = action.input.description || "";
+      }
+    }
+  },
+  deleteModuleOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    latestSpec.modules = latestSpec.modules.filter(
+      (m) => m.id != action.input.id
+    );
+  },
+  reorderModulesOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    latestSpec.modules.sort(moduleSorter(action.input.order));
+  }
+};
+const errorSorter = (order) => {
+  const mapping = {};
+  order.forEach((key, index) => mapping[key] = index);
+  return (a, b) => (mapping[b.id] || 999999) - (mapping[a.id] || 999999);
+};
+const reducer$4 = {
+  addOperationErrorOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        if (latestSpec.modules[i].operations[j].id == action.input.operationId) {
+          latestSpec.modules[i].operations[j].errors.push({
+            id: action.input.id,
+            name: action.input.errorName || "",
+            code: action.input.errorCode || "",
+            description: action.input.errorDescription || "",
+            template: action.input.errorTemplate || ""
+          });
+        }
+      }
+    }
+  },
+  setOperationErrorCodeOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        for (let k = 0; k < latestSpec.modules[i].operations[j].errors.length; k++) {
+          if (latestSpec.modules[i].operations[j].errors[k].id == action.input.id) {
+            latestSpec.modules[i].operations[j].errors[k].code = action.input.errorCode || "";
+          }
+        }
+      }
+    }
+  },
+  setOperationErrorNameOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        for (let k = 0; k < latestSpec.modules[i].operations[j].errors.length; k++) {
+          if (latestSpec.modules[i].operations[j].errors[k].id == action.input.id) {
+            latestSpec.modules[i].operations[j].errors[k].name = action.input.errorName || "";
+          }
+        }
+      }
+    }
+  },
+  setOperationErrorDescriptionOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        for (let k = 0; k < latestSpec.modules[i].operations[j].errors.length; k++) {
+          if (latestSpec.modules[i].operations[j].errors[k].id == action.input.id) {
+            latestSpec.modules[i].operations[j].errors[k].description = action.input.errorDescription || "";
+          }
+        }
+      }
+    }
+  },
+  setOperationErrorTemplateOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        for (let k = 0; k < latestSpec.modules[i].operations[j].errors.length; k++) {
+          if (latestSpec.modules[i].operations[j].errors[k].id == action.input.id) {
+            latestSpec.modules[i].operations[j].errors[k].template = action.input.errorTemplate || "";
+          }
+        }
+      }
+    }
+  },
+  deleteOperationErrorOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        latestSpec.modules[i].operations[j].errors = latestSpec.modules[i].operations[j].errors.filter((e) => e.id != action.input.id);
+      }
+    }
+  },
+  reorderOperationErrorsOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        if (latestSpec.modules[i].operations[j].id == action.input.operationId) {
+          latestSpec.modules[i].operations[j].errors.sort(
+            errorSorter(action.input.order)
+          );
+        }
+      }
+    }
+  }
+};
+const exampleSorter$1 = (order) => {
+  const mapping = {};
+  order.forEach((key, index) => mapping[key] = index);
+  return (a, b) => (mapping[b.id] || 999999) - (mapping[a.id] || 999999);
+};
+const reducer$3 = {
+  addOperationExampleOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        if (latestSpec.modules[i].operations[j].id == action.input.operationId) {
+          latestSpec.modules[i].operations[j].examples.push({
+            id: action.input.id,
+            value: action.input.example
+          });
+        }
+      }
+    }
+  },
+  updateOperationExampleOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        for (let k = 0; k < latestSpec.modules[i].operations[j].examples.length; k++) {
+          if (latestSpec.modules[i].operations[j].examples[k].id == action.input.id) {
+            latestSpec.modules[i].operations[j].examples[k].value = action.input.example;
+          }
+        }
+      }
+    }
+  },
+  deleteOperationExampleOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        latestSpec.modules[i].operations[j].examples = latestSpec.modules[i].operations[j].examples.filter(
+          (e) => e.id != action.input.id
+        );
+      }
+    }
+  },
+  reorderOperationExamplesOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        if (latestSpec.modules[i].operations[j].id == action.input.operationId) {
+          latestSpec.modules[i].operations[j].examples.sort(
+            exampleSorter$1(action.input.order)
+          );
+        }
+      }
+    }
+  }
+};
+const operationSorter = (order) => {
+  const mapping = {};
+  order.forEach((key, index) => mapping[key] = index);
+  return (a, b) => (mapping[b.id] || 999999) - (mapping[a.id] || 999999);
+};
+const reducer$2 = {
+  addOperationOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      if (latestSpec.modules[i].id == action.input.moduleId) {
+        latestSpec.modules[i].operations.push({
+          id: action.input.id,
+          name: action.input.name,
+          description: action.input.description || "",
+          schema: action.input.schema || "",
+          template: action.input.template || action.input.description || "",
+          reducer: action.input.reducer || "",
+          errors: [],
+          examples: [],
+          scope: action.input.scope || "global"
+        });
+      }
+    }
+  },
+  setOperationNameOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        if (latestSpec.modules[i].operations[j].id == action.input.id) {
+          latestSpec.modules[i].operations[j].name = action.input.name || "";
+        }
+      }
+    }
+  },
+  setOperationScopeOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        if (latestSpec.modules[i].operations[j].id == action.input.id) {
+          latestSpec.modules[i].operations[j].scope = action.input.scope || "global";
+        }
+      }
+    }
+  },
+  setOperationSchemaOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        if (latestSpec.modules[i].operations[j].id == action.input.id) {
+          latestSpec.modules[i].operations[j].schema = action.input.schema || "";
+        }
+      }
+    }
+  },
+  setOperationDescriptionOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        if (latestSpec.modules[i].operations[j].id == action.input.id) {
+          latestSpec.modules[i].operations[j].description = action.input.description || "";
+        }
+      }
+    }
+  },
+  setOperationTemplateOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        if (latestSpec.modules[i].operations[j].id == action.input.id) {
+          latestSpec.modules[i].operations[j].template = action.input.template || "";
+        }
+      }
+    }
+  },
+  setOperationReducerOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      for (let j = 0; j < latestSpec.modules[i].operations.length; j++) {
+        if (latestSpec.modules[i].operations[j].id == action.input.id) {
+          latestSpec.modules[i].operations[j].reducer = action.input.reducer || "";
+        }
+      }
+    }
+  },
+  moveOperationOperation(state, action) {
+    const moveOperations = [];
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      latestSpec.modules[i].operations = latestSpec.modules[i].operations.filter((operation) => {
+        if (operation.id == action.input.operationId) {
+          moveOperations.push(operation);
+          return false;
+        }
+        return true;
+      });
+    }
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      if (latestSpec.modules[i].id == action.input.newModuleId) {
+        latestSpec.modules[i].operations.push(...moveOperations);
+      }
+    }
+  },
+  deleteOperationOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      latestSpec.modules[i].operations = latestSpec.modules[i].operations.filter((operation) => operation.id != action.input.id);
+    }
+  },
+  reorderModuleOperationsOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    for (let i = 0; i < latestSpec.modules.length; i++) {
+      if (latestSpec.modules[i].id == action.input.moduleId) {
+        latestSpec.modules[i].operations.sort(
+          operationSorter(action.input.order)
+        );
+      }
+    }
+  }
+};
+const exampleSorter = (order) => {
+  const mapping = {};
+  order.forEach((key, index) => mapping[key] = index);
+  return (a, b) => (mapping[b.id] || 999999) - (mapping[a.id] || 999999);
+};
+const reducer$1 = {
+  setStateSchemaOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    if (Object.keys(latestSpec.state).includes(action.input.scope)) {
+      latestSpec.state[action.input.scope].schema = action.input.schema;
+    } else {
+      throw new Error(`Invalid scope: ${action.input.scope}`);
+    }
+  },
+  setInitialStateOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    if (Object.keys(latestSpec.state).includes(action.input.scope)) {
+      latestSpec.state[action.input.scope].initialValue = action.input.initialValue;
+    } else {
+      throw new Error(`Invalid scope: ${action.input.scope}`);
+    }
+  },
+  addStateExampleOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    if (Object.keys(latestSpec.state).includes(action.input.scope)) {
+      latestSpec.state[action.input.scope].examples.push({
+        id: action.input.id,
+        value: action.input.example
+      });
+    } else {
+      throw new Error(`Invalid scope: ${action.input.scope}`);
+    }
+  },
+  updateStateExampleOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    if (!Object.keys(latestSpec.state).includes(action.input.scope)) {
+      throw new Error(`Invalid scope: ${action.input.scope}`);
+    }
+    const examples = latestSpec.state[action.input.scope].examples;
+    for (let i = 0; i < examples.length; i++) {
+      if (examples[i].id == action.input.id) {
+        examples[i].value = action.input.newExample;
+      }
+    }
+  },
+  deleteStateExampleOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    if (Object.keys(latestSpec.state).includes(action.input.scope)) {
+      latestSpec.state[action.input.scope].examples = latestSpec.state[action.input.scope].examples.filter((e) => e.id != action.input.id);
+    } else {
+      throw new Error(`Invalid scope: ${action.input.scope}`);
+    }
+  },
+  reorderStateExamplesOperation(state, action) {
+    const latestSpec = state.specifications[state.specifications.length - 1];
+    if (Object.keys(latestSpec.state).includes(action.input.scope)) {
+      latestSpec.state[action.input.scope].examples.sort(exampleSorter(action.input.order));
+    } else {
+      throw new Error(`Invalid scope: ${action.input.scope}`);
+    }
+  }
+};
+const stateReducer = (state, action) => {
+  if (isBaseAction(action)) {
+    return state;
+  }
+  switch (action.type) {
+    case "SET_MODEL_NAME":
+      SetModelNameInputSchema().parse(action.input);
+      reducer$7.setModelNameOperation(state.global, action);
+      break;
+    case "SET_MODEL_ID":
+      SetModelIdInputSchema().parse(action.input);
+      reducer$7.setModelIdOperation(state.global, action);
+      break;
+    case "SET_MODEL_EXTENSION":
+      SetModelExtensionInputSchema().parse(action.input);
+      reducer$7.setModelExtensionOperation(state.global, action);
+      break;
+    case "SET_MODEL_DESCRIPTION":
+      SetModelDescriptionInputSchema().parse(action.input);
+      reducer$7.setModelDescriptionOperation(state.global, action);
+      break;
+    case "SET_AUTHOR_NAME":
+      SetAuthorNameInputSchema().parse(action.input);
+      reducer$7.setAuthorNameOperation(state.global, action);
+      break;
+    case "SET_AUTHOR_WEBSITE":
+      SetAuthorWebsiteInputSchema().parse(action.input);
+      reducer$7.setAuthorWebsiteOperation(state.global, action);
+      break;
+    case "ADD_CHANGE_LOG_ITEM":
+      AddChangeLogItemInputSchema().parse(action.input);
+      reducer$6.addChangeLogItemOperation(state.global, action);
+      break;
+    case "UPDATE_CHANGE_LOG_ITEM":
+      UpdateChangeLogItemInputSchema().parse(action.input);
+      reducer$6.updateChangeLogItemOperation(
+        state.global,
+        action
+      );
+      break;
+    case "DELETE_CHANGE_LOG_ITEM":
+      DeleteChangeLogItemInputSchema().parse(action.input);
+      reducer$6.deleteChangeLogItemOperation(
+        state.global,
+        action
+      );
+      break;
+    case "REORDER_CHANGE_LOG_ITEMS":
+      ReorderChangeLogItemsInputSchema().parse(action.input);
+      reducer$6.reorderChangeLogItemsOperation(
+        state.global,
+        action
+      );
+      break;
+    case "RELEASE_NEW_VERSION":
+      if (Object.keys(action.input).length > 0)
+        throw new Error(
+          "Expected empty input for action RELEASE_NEW_VERSION"
+        );
+      reducer$6.releaseNewVersionOperation(state.global, action);
+      break;
+    case "ADD_MODULE":
+      AddModuleInputSchema().parse(action.input);
+      reducer$5.addModuleOperation(state.global, action);
+      break;
+    case "SET_MODULE_NAME":
+      SetModuleNameInputSchema().parse(action.input);
+      reducer$5.setModuleNameOperation(state.global, action);
+      break;
+    case "SET_MODULE_DESCRIPTION":
+      SetModuleDescriptionInputSchema().parse(action.input);
+      reducer$5.setModuleDescriptionOperation(state.global, action);
+      break;
+    case "DELETE_MODULE":
+      DeleteModuleInputSchema().parse(action.input);
+      reducer$5.deleteModuleOperation(state.global, action);
+      break;
+    case "REORDER_MODULES":
+      ReorderModulesInputSchema().parse(action.input);
+      reducer$5.reorderModulesOperation(state.global, action);
+      break;
+    case "ADD_OPERATION_ERROR":
+      AddOperationErrorInputSchema().parse(action.input);
+      reducer$4.addOperationErrorOperation(
+        state.global,
+        action
+      );
+      break;
+    case "SET_OPERATION_ERROR_CODE":
+      SetOperationErrorCodeInputSchema().parse(action.input);
+      reducer$4.setOperationErrorCodeOperation(
+        state.global,
+        action
+      );
+      break;
+    case "SET_OPERATION_ERROR_NAME":
+      SetOperationErrorNameInputSchema().parse(action.input);
+      reducer$4.setOperationErrorNameOperation(
+        state.global,
+        action
+      );
+      break;
+    case "SET_OPERATION_ERROR_DESCRIPTION":
+      SetOperationErrorDescriptionInputSchema().parse(action.input);
+      reducer$4.setOperationErrorDescriptionOperation(
+        state.global,
+        action
+      );
+      break;
+    case "SET_OPERATION_ERROR_TEMPLATE":
+      SetOperationErrorTemplateInputSchema().parse(action.input);
+      reducer$4.setOperationErrorTemplateOperation(
+        state.global,
+        action
+      );
+      break;
+    case "DELETE_OPERATION_ERROR":
+      DeleteOperationErrorInputSchema().parse(action.input);
+      reducer$4.deleteOperationErrorOperation(
+        state.global,
+        action
+      );
+      break;
+    case "REORDER_OPERATION_ERRORS":
+      ReorderOperationErrorsInputSchema().parse(action.input);
+      reducer$4.reorderOperationErrorsOperation(
+        state.global,
+        action
+      );
+      break;
+    case "ADD_OPERATION_EXAMPLE":
+      AddOperationExampleInputSchema().parse(action.input);
+      reducer$3.addOperationExampleOperation(
+        state.global,
+        action
+      );
+      break;
+    case "UPDATE_OPERATION_EXAMPLE":
+      UpdateOperationExampleInputSchema().parse(action.input);
+      reducer$3.updateOperationExampleOperation(
+        state.global,
+        action
+      );
+      break;
+    case "DELETE_OPERATION_EXAMPLE":
+      DeleteOperationExampleInputSchema().parse(action.input);
+      reducer$3.deleteOperationExampleOperation(
+        state.global,
+        action
+      );
+      break;
+    case "REORDER_OPERATION_EXAMPLES":
+      ReorderOperationExamplesInputSchema().parse(action.input);
+      reducer$3.reorderOperationExamplesOperation(
+        state.global,
+        action
+      );
+      break;
+    case "ADD_OPERATION":
+      AddOperationInputSchema().parse(action.input);
+      reducer$2.addOperationOperation(state.global, action);
+      break;
+    case "SET_OPERATION_NAME":
+      SetOperationNameInputSchema().parse(action.input);
+      reducer$2.setOperationNameOperation(state.global, action);
+      break;
+    case "SET_OPERATION_SCOPE":
+      SetOperationScopeInputSchema().parse(action.input);
+      reducer$2.setOperationScopeOperation(state.global, action);
+      break;
+    case "SET_OPERATION_SCHEMA":
+      SetOperationSchemaInputSchema().parse(action.input);
+      reducer$2.setOperationSchemaOperation(state.global, action);
+      break;
+    case "SET_OPERATION_DESCRIPTION":
+      SetOperationDescriptionInputSchema().parse(action.input);
+      reducer$2.setOperationDescriptionOperation(
+        state.global,
+        action
+      );
+      break;
+    case "SET_OPERATION_TEMPLATE":
+      SetOperationTemplateInputSchema().parse(action.input);
+      reducer$2.setOperationTemplateOperation(
+        state.global,
+        action
+      );
+      break;
+    case "SET_OPERATION_REDUCER":
+      SetOperationReducerInputSchema().parse(action.input);
+      reducer$2.setOperationReducerOperation(state.global, action);
+      break;
+    case "MOVE_OPERATION":
+      MoveOperationInputSchema().parse(action.input);
+      reducer$2.moveOperationOperation(state.global, action);
+      break;
+    case "DELETE_OPERATION":
+      DeleteOperationInputSchema().parse(action.input);
+      reducer$2.deleteOperationOperation(state.global, action);
+      break;
+    case "REORDER_MODULE_OPERATIONS":
+      ReorderModuleOperationsInputSchema().parse(action.input);
+      reducer$2.reorderModuleOperationsOperation(
+        state.global,
+        action
+      );
+      break;
+    case "SET_STATE_SCHEMA":
+      SetStateSchemaInputSchema().parse(action.input);
+      reducer$1.setStateSchemaOperation(state.global, action);
+      break;
+    case "SET_INITIAL_STATE":
+      SetInitialStateInputSchema().parse(action.input);
+      reducer$1.setInitialStateOperation(state.global, action);
+      break;
+    case "ADD_STATE_EXAMPLE":
+      AddStateExampleInputSchema().parse(action.input);
+      reducer$1.addStateExampleOperation(state.global, action);
+      break;
+    case "UPDATE_STATE_EXAMPLE":
+      UpdateStateExampleInputSchema().parse(action.input);
+      reducer$1.updateStateExampleOperation(state.global, action);
+      break;
+    case "DELETE_STATE_EXAMPLE":
+      DeleteStateExampleInputSchema().parse(action.input);
+      reducer$1.deleteStateExampleOperation(state.global, action);
+      break;
+    case "REORDER_STATE_EXAMPLES":
+      ReorderStateExamplesInputSchema().parse(action.input);
+      reducer$1.reorderStateExamplesOperation(state.global, action);
+      break;
+    default:
+      return state;
+  }
+};
+const reducer = createReducer(stateReducer);
+const initialGlobalState = {
+  id: "",
+  name: "",
+  extension: "",
+  description: "",
+  author: {
+    name: "",
+    website: ""
+  },
+  specifications: [
+    {
+      version: 1,
+      changeLog: [],
+      state: {
+        global: {
+          schema: "",
+          initialValue: "",
+          examples: []
+        },
+        local: {
+          schema: "",
+          initialValue: "",
+          examples: []
+        }
+      },
+      modules: []
+    }
+  ]
+};
+const initialLocalState = {};
+const utils$1 = {
+  fileExtension: "phdm",
+  createState(state) {
+    return {
+      global: { ...initialGlobalState, ...state == null ? void 0 : state.global },
+      local: { ...initialLocalState, ...state == null ? void 0 : state.local }
+    };
+  },
+  createExtendedState(extendedState) {
+    return createExtendedState(
+      { ...extendedState, documentType: "powerhouse/document-model" },
+      utils$1.createState
+    );
+  },
+  createDocument(state) {
+    return createDocument(
+      utils$1.createExtendedState(state),
+      utils$1.createState
+    );
+  },
+  saveToFile(document, path, name) {
+    return saveToFile(document, path, "phdm", name);
+  },
+  saveToFileHandle(document, input) {
+    return saveToFileHandle(document, input);
+  },
+  loadFromFile(path) {
+    return loadFromFile(path, reducer);
+  },
+  loadFromInput(input) {
+    return loadFromInput(input, reducer);
+  }
+};
+const setModelName = (input) => createAction(
+  "SET_MODEL_NAME",
+  { ...input }
+);
+const setModelId = (input) => createAction(
+  "SET_MODEL_ID",
+  { ...input }
+);
+const setModelExtension = (input) => createAction(
+  "SET_MODEL_EXTENSION",
+  { ...input }
+);
+const setModelDescription = (input) => createAction(
+  "SET_MODEL_DESCRIPTION",
+  { ...input }
+);
+const setAuthorName = (input) => createAction(
+  "SET_AUTHOR_NAME",
+  { ...input }
+);
+const setAuthorWebsite = (input) => createAction(
+  "SET_AUTHOR_WEBSITE",
+  { ...input }
+);
+class DocumentModel_Header extends BaseDocument {
+  setModelName(input, options) {
+    return this.dispatch(setModelName(input), options);
+  }
+  setModelId(input, options) {
+    return this.dispatch(setModelId(input), options);
+  }
+  setModelExtension(input, options) {
+    return this.dispatch(setModelExtension(input), options);
+  }
+  setModelDescription(input, options) {
+    return this.dispatch(setModelDescription(input), options);
+  }
+  setAuthorName(input, options) {
+    return this.dispatch(setAuthorName(input), options);
+  }
+  setAuthorWebsite(input, options) {
+    return this.dispatch(setAuthorWebsite(input), options);
+  }
+}
+const addChangeLogItem = (input) => createAction(
+  "ADD_CHANGE_LOG_ITEM",
+  { ...input }
+);
+const updateChangeLogItem = (input) => createAction(
+  "UPDATE_CHANGE_LOG_ITEM",
+  { ...input }
+);
+const deleteChangeLogItem = (input) => createAction(
+  "DELETE_CHANGE_LOG_ITEM",
+  { ...input }
+);
+const reorderChangeLogItems = (input) => createAction(
+  "REORDER_CHANGE_LOG_ITEMS",
+  { ...input }
+);
+const releaseNewVersion = () => createAction(
+  "RELEASE_NEW_VERSION"
+);
+class DocumentModel_Versioning extends BaseDocument {
+  addChangeLogItem(input, options) {
+    return this.dispatch(addChangeLogItem(input), options);
+  }
+  updateChangeLogItem(input, options) {
+    return this.dispatch(updateChangeLogItem(input), options);
+  }
+  deleteChangeLogItem(input, options) {
+    return this.dispatch(deleteChangeLogItem(input), options);
+  }
+  reorderChangeLogItems(input, options) {
+    return this.dispatch(reorderChangeLogItems(input), options);
+  }
+  releaseNewVersion(options) {
+    return this.dispatch(releaseNewVersion(), options);
+  }
+}
+const addModule = (input) => createAction(
+  "ADD_MODULE",
+  { ...input }
+);
+const setModuleName = (input) => createAction(
+  "SET_MODULE_NAME",
+  { ...input }
+);
+const setModuleDescription = (input) => createAction(
+  "SET_MODULE_DESCRIPTION",
+  { ...input }
+);
+const deleteModule = (input) => createAction(
+  "DELETE_MODULE",
+  { ...input }
+);
+const reorderModules = (input) => createAction(
+  "REORDER_MODULES",
+  { ...input }
+);
+class DocumentModel_Module extends BaseDocument {
+  addModule(input, options) {
+    return this.dispatch(addModule(input), options);
+  }
+  setModuleName(input, options) {
+    return this.dispatch(setModuleName(input), options);
+  }
+  setModuleDescription(input, options) {
+    return this.dispatch(setModuleDescription(input), options);
+  }
+  deleteModule(input, options) {
+    return this.dispatch(deleteModule(input), options);
+  }
+  reorderModules(input, options) {
+    return this.dispatch(reorderModules(input), options);
+  }
+}
+const addOperationError = (input) => createAction(
+  "ADD_OPERATION_ERROR",
+  { ...input }
+);
+const setOperationErrorCode = (input) => createAction(
+  "SET_OPERATION_ERROR_CODE",
+  { ...input }
+);
+const setOperationErrorName = (input) => createAction(
+  "SET_OPERATION_ERROR_NAME",
+  { ...input }
+);
+const setOperationErrorDescription = (input) => createAction(
+  "SET_OPERATION_ERROR_DESCRIPTION",
+  { ...input }
+);
+const setOperationErrorTemplate = (input) => createAction(
+  "SET_OPERATION_ERROR_TEMPLATE",
+  { ...input }
+);
+const deleteOperationError = (input) => createAction(
+  "DELETE_OPERATION_ERROR",
+  { ...input }
+);
+const reorderOperationErrors = (input) => createAction(
+  "REORDER_OPERATION_ERRORS",
+  { ...input }
+);
+class DocumentModel_OperationError extends BaseDocument {
+  addOperationError(input, options) {
+    return this.dispatch(addOperationError(input), options);
+  }
+  setOperationErrorCode(input, options) {
+    return this.dispatch(setOperationErrorCode(input), options);
+  }
+  setOperationErrorName(input, options) {
+    return this.dispatch(setOperationErrorName(input), options);
+  }
+  setOperationErrorDescription(input, options) {
+    return this.dispatch(setOperationErrorDescription(input), options);
+  }
+  setOperationErrorTemplate(input, options) {
+    return this.dispatch(setOperationErrorTemplate(input), options);
+  }
+  deleteOperationError(input, options) {
+    return this.dispatch(deleteOperationError(input), options);
+  }
+  reorderOperationErrors(input, options) {
+    return this.dispatch(reorderOperationErrors(input), options);
+  }
+}
+const addOperationExample = (input) => createAction(
+  "ADD_OPERATION_EXAMPLE",
+  { ...input }
+);
+const updateOperationExample = (input) => createAction(
+  "UPDATE_OPERATION_EXAMPLE",
+  { ...input }
+);
+const deleteOperationExample = (input) => createAction(
+  "DELETE_OPERATION_EXAMPLE",
+  { ...input }
+);
+const reorderOperationExamples = (input) => createAction(
+  "REORDER_OPERATION_EXAMPLES",
+  { ...input }
+);
+class DocumentModel_OperationExample extends BaseDocument {
+  addOperationExample(input, options) {
+    return this.dispatch(addOperationExample(input), options);
+  }
+  updateOperationExample(input, options) {
+    return this.dispatch(updateOperationExample(input), options);
+  }
+  deleteOperationExample(input, options) {
+    return this.dispatch(deleteOperationExample(input), options);
+  }
+  reorderOperationExamples(input, options) {
+    return this.dispatch(reorderOperationExamples(input), options);
+  }
+}
+const addOperation = (input) => createAction(
+  "ADD_OPERATION",
+  { ...input }
+);
+const setOperationName = (input) => createAction(
+  "SET_OPERATION_NAME",
+  { ...input }
+);
+const setOperationScope = (input) => createAction(
+  "SET_OPERATION_SCOPE",
+  { ...input }
+);
+const setOperationSchema = (input) => createAction(
+  "SET_OPERATION_SCHEMA",
+  { ...input }
+);
+const setOperationDescription = (input) => createAction(
+  "SET_OPERATION_DESCRIPTION",
+  { ...input }
+);
+const setOperationTemplate = (input) => createAction(
+  "SET_OPERATION_TEMPLATE",
+  { ...input }
+);
+const setOperationReducer = (input) => createAction(
+  "SET_OPERATION_REDUCER",
+  { ...input }
+);
+const moveOperation = (input) => createAction(
+  "MOVE_OPERATION",
+  { ...input }
+);
+const deleteOperation = (input) => createAction(
+  "DELETE_OPERATION",
+  { ...input }
+);
+const reorderModuleOperations = (input) => createAction(
+  "REORDER_MODULE_OPERATIONS",
+  { ...input }
+);
+class DocumentModel_Operation extends BaseDocument {
+  addOperation(input, options) {
+    return this.dispatch(addOperation(input), options);
+  }
+  setOperationName(input, options) {
+    return this.dispatch(setOperationName(input), options);
+  }
+  setOperationScope(input, options) {
+    return this.dispatch(setOperationScope(input), options);
+  }
+  setOperationSchema(input, options) {
+    return this.dispatch(setOperationSchema(input), options);
+  }
+  setOperationDescription(input, options) {
+    return this.dispatch(setOperationDescription(input), options);
+  }
+  setOperationTemplate(input, options) {
+    return this.dispatch(setOperationTemplate(input), options);
+  }
+  setOperationReducer(input, options) {
+    return this.dispatch(setOperationReducer(input), options);
+  }
+  moveOperation(input, options) {
+    return this.dispatch(moveOperation(input), options);
+  }
+  deleteOperation(input, options) {
+    return this.dispatch(deleteOperation(input), options);
+  }
+  reorderModuleOperations(input, options) {
+    return this.dispatch(reorderModuleOperations(input), options);
+  }
+}
+const setStateSchema = (input) => createAction(
+  "SET_STATE_SCHEMA",
+  { ...input }
+);
+const setInitialState = (input) => createAction(
+  "SET_INITIAL_STATE",
+  { ...input }
+);
+const addStateExample = (input) => createAction(
+  "ADD_STATE_EXAMPLE",
+  { ...input }
+);
+const updateStateExample = (input) => createAction(
+  "UPDATE_STATE_EXAMPLE",
+  { ...input }
+);
+const deleteStateExample = (input) => createAction(
+  "DELETE_STATE_EXAMPLE",
+  { ...input }
+);
+const reorderStateExamples = (input) => createAction(
+  "REORDER_STATE_EXAMPLES",
+  { ...input }
+);
+class DocumentModel_State extends BaseDocument {
+  setStateSchema(input, options) {
+    return this.dispatch(setStateSchema(input), options);
+  }
+  setInitialState(input, options) {
+    return this.dispatch(setInitialState(input), options);
+  }
+  addStateExample(input, options) {
+    return this.dispatch(addStateExample(input), options);
+  }
+  updateStateExample(input, options) {
+    return this.dispatch(updateStateExample(input), options);
+  }
+  deleteStateExample(input, options) {
+    return this.dispatch(deleteStateExample(input), options);
+  }
+  reorderStateExamples(input, options) {
+    return this.dispatch(reorderStateExamples(input), options);
+  }
+}
+let DocumentModel$1 = (_a = class extends BaseDocument {
+  constructor(initialState, dispatch) {
+    super(reducer, utils$1.createDocument(initialState), dispatch);
+  }
+  saveToFile(path, name) {
+    return super.saveToFile(path, _a.fileExtension, name);
+  }
+  loadFromFile(path) {
+    return super.loadFromFile(path);
+  }
+  static async fromFile(path) {
+    const document = new this();
+    await document.loadFromFile(path);
+    return document;
+  }
+}, __publicField(_a, "fileExtension", "phdm"), _a);
+applyMixins(DocumentModel$1, [
+  DocumentModel_Header,
+  DocumentModel_Versioning,
+  DocumentModel_Module,
+  DocumentModel_OperationError,
+  DocumentModel_OperationExample,
+  DocumentModel_Operation,
+  DocumentModel_State
+]);
+const DocumentModelActions = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  addChangeLogItem,
+  addModule,
+  addOperation,
+  addOperationError,
+  addOperationExample,
+  addStateExample,
+  deleteChangeLogItem,
+  deleteModule,
+  deleteOperation,
+  deleteOperationError,
+  deleteOperationExample,
+  deleteStateExample,
+  moveOperation,
+  releaseNewVersion,
+  reorderChangeLogItems,
+  reorderModuleOperations,
+  reorderModules,
+  reorderOperationErrors,
+  reorderOperationExamples,
+  reorderStateExamples,
+  setAuthorName,
+  setAuthorWebsite,
+  setInitialState,
+  setModelDescription,
+  setModelExtension,
+  setModelId,
+  setModelName,
+  setModuleDescription,
+  setModuleName,
+  setOperationDescription,
+  setOperationErrorCode,
+  setOperationErrorDescription,
+  setOperationErrorName,
+  setOperationErrorTemplate,
+  setOperationName,
+  setOperationReducer,
+  setOperationSchema,
+  setOperationScope,
+  setOperationTemplate,
+  setStateSchema,
+  updateChangeLogItem,
+  updateOperationExample,
+  updateStateExample
+}, Symbol.toStringTag, { value: "Module" }));
+const Document = DocumentModel$1;
+const utils = { ...utils$1, ...customUtils };
+const actions = { ...BaseActions, ...DocumentModelActions };
+const module = {
+  Document,
+  reducer,
+  actions,
+  utils,
+  documentModel
+};
+const DocumentModel = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Document,
+  DocumentModel: DocumentModel$1,
+  actions,
+  documentModel,
+  module,
+  reducer,
+  utils,
+  validateInitialState,
+  validateModule,
+  validateModuleOperation,
+  validateModules,
+  validateStateSchemaName,
+  z: zod
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  DocumentModel as D,
+  DocumentModel$1 as a,
+  Document as b,
+  actions as c,
+  documentModel as d,
+  validateStateSchemaName as e,
+  validateModules as f,
+  validateModule as g,
+  validateModuleOperation as h,
+  module as m,
+  reducer as r,
+  utils as u,
+  validateInitialState as v,
+  zod as z
+};
+//# sourceMappingURL=index-B1lQN59e.js.map