@powerhousedao/shared 6.0.0-dev.105 → 6.0.0-dev.107

package/dist/document-model/index.js

@@ -1,3 +1,3409 @@
-export * from "./core/constants.js";
-export * from "./core/ph-types.js";
+import { ZodError, z } from "zod";
+import stringifyJson, { stringify } from "safe-stable-stringify";
+import { createHash } from "sha1-uint8array";
+import JSZip from "jszip";
+import { castDraft, create, unsafe } from "mutative";
+import { pascalCase } from "change-case";
+//#region document-model/crypto.ts
+const hashBrowser = (data, algorithm = "sha1", encoding = "base64", _params) => {
+	if (!["sha1"].includes(algorithm)) throw new Error(`Hashing algorithm not supported: "${algorithm}". Available: sha1`);
+	if (!["base64", "hex"].includes(encoding)) throw new Error(`Hash encoding not supported: "${encoding}". Available: base64, hex`);
+	const hash = hashUIntArray(data, algorithm);
+	if (encoding === "hex") return uint8ArrayToHex(hash);
+	return uint8ArrayToBase64(hash);
+};
+function uint8ArrayToBase64(uint8Array) {
+	let binaryString = "";
+	for (let i = 0; i < uint8Array.length; i++) binaryString += String.fromCharCode(uint8Array[i]);
+	return btoa(binaryString);
+}
+function uint8ArrayToHex(uint8Array) {
+	return Array.from(uint8Array).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function hashUIntArray(data, algorithm = "sha1") {
+	if (!["sha1"].includes(algorithm)) throw new Error("Hashing algorithm not supported: Available: sha1");
+	return createHash("sha1").update(data).digest();
+}
+function getUnixTimestamp(date) {
+	return (new Date(date).getTime() / 1e3).toFixed(0);
+}
+function buildOperationSignatureParams({ documentId, signer, action, previousStateHash }) {
+	const { scope, type } = action;
+	return [
+		getUnixTimestamp(/* @__PURE__ */ new Date()),
+		signer.app.key,
+		hashBrowser([
+			documentId,
+			scope,
+			type,
+			stringifyJson(action.input)
+		].join("")),
+		previousStateHash
+	];
+}
+const textEncode = new TextEncoder();
+function buildOperationSignatureMessage(params) {
+	const message = params.join("");
+	const prefix = "Signed Operation:\n" + message.length.toString();
+	return textEncode.encode(prefix + message);
+}
+function ab2hex(ab) {
+	const view = ArrayBuffer.isView(ab) ? ab : new Uint8Array(ab);
+	return Array.prototype.map.call(view, (x) => ("00" + x.toString(16)).slice(-2)).join("");
+}
+function hex2ab(hex) {
+	return new Uint8Array(hex.match(/[\da-f]{2}/gi)?.map(function(h) {
+		return parseInt(h, 16);
+	}) ?? []);
+}
+//#endregion
+//#region document-model/errors.ts
+const FileSystemError = /* @__PURE__ */ new Error("File system not available.");
+var InvalidActionInputError = class extends Error {
+	data;
+	constructor(data) {
+		super();
+		this.name = "InvalidActionInputError";
+		this.data = data;
+		this.message = this.message || `Invalid action input: ${JSON.stringify(data, null, 2)}`;
+	}
+};
+var InvalidActionInputZodError = class extends InvalidActionInputError {
+	issues;
+	constructor(issues) {
+		super(issues);
+		this.issues = issues;
+		this.name = "InvalidActionInputZodError";
+	}
+};
+var HashMismatchError = class extends Error {
+	_scope;
+	_document;
+	_operation;
+	constructor(scope, document, operation) {
+		super();
+		this.name = "HashMismatchError";
+		this._document = document;
+		this._scope = scope;
+		this._operation = operation;
+		this.message = JSON.stringify({
+			error: `Hash mismatch on document ${document.header.id}, scope ${scope}, index ${operation.index}`,
+			document,
+			operation
+		}, null, 1);
+	}
+	get document() {
+		return this._document;
+	}
+	get scope() {
+		return this._scope;
+	}
+	get operation() {
+		return this._operation;
+	}
+};
+//#endregion
+//#region document-model/schemas.ts
+const isDefinedNonNullAny = (v) => v !== void 0 && v !== null;
+const definedNonNullAnySchema = z.any().refine((v) => isDefinedNonNullAny(v));
+const Load_StateSchema = z.enum(["LOAD_STATE"]);
+const PruneSchema = z.enum(["PRUNE"]);
+const RedoSchema = z.enum(["REDO"]);
+const Set_NameSchema = z.enum(["SET_NAME"]);
+const UndoSchema = z.enum(["UNDO"]);
+function OperationScopeSchema() {
+	return z.string();
+}
+function DocumentActionSchema() {
+	return z.union([
+		LoadStateActionSchema(),
+		PruneActionSchema(),
+		RedoActionSchema(),
+		SetNameActionSchema(),
+		UndoActionSchema()
+	]);
+}
+function DocumentFileSchema() {
+	return z.object({
+		__typename: z.literal("DocumentFile").optional(),
+		data: z.string(),
+		extension: z.string().nullable(),
+		fileName: z.string().nullable(),
+		mimeType: z.string()
+	});
+}
+function LoadStateActionSchema() {
+	return z.object({
+		id: z.string(),
+		timestampUtcMs: z.string(),
+		input: z.lazy(() => LoadStateActionInputSchema()),
+		type: Load_StateSchema,
+		scope: OperationScopeSchema()
+	});
+}
+function LoadStateActionInputSchema() {
+	return z.object({
+		operations: z.number(),
+		state: z.lazy(() => LoadStateActionStateInputSchema())
+	});
+}
+function LoadStateActionStateInputSchema() {
+	return z.object({
+		data: z.unknown().nullish(),
+		name: z.string()
+	});
+}
+function PruneActionSchema() {
+	return z.object({
+		id: z.string(),
+		timestampUtcMs: z.string(),
+		input: z.lazy(() => PruneActionInputSchema()),
+		type: PruneSchema,
+		scope: OperationScopeSchema()
+	});
+}
+function PruneActionInputSchema() {
+	return z.object({
+		end: z.number().nullish(),
+		start: z.number().nullish()
+	});
+}
+function RedoActionInputSchema() {
+	return z.object({ count: z.number() });
+}
+function RedoActionSchema() {
+	return z.object({
+		id: z.string(),
+		timestampUtcMs: z.string().datetime(),
+		input: RedoActionInputSchema(),
+		type: RedoSchema,
+		scope: OperationScopeSchema()
+	});
+}
+function SetNameActionInputSchema() {
+	return z.object({ name: z.string() });
+}
+function SetNameActionSchema() {
+	return z.object({
+		id: z.string(),
+		timestampUtcMs: z.string().datetime(),
+		input: SetNameActionInputSchema(),
+		type: Set_NameSchema,
+		scope: z.literal("global")
+	});
+}
+function UndoActionInputSchema() {
+	return z.object({ count: z.number() });
+}
+function UndoActionSchema() {
+	return z.object({
+		id: z.string(),
+		timestampUtcMs: z.string().datetime(),
+		input: UndoActionInputSchema(),
+		type: UndoSchema,
+		scope: OperationScopeSchema()
+	});
+}
+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 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 DocumentModelGlobalStateSchema() {
+	return z.object({
+		__typename: z.literal("DocumentModelGlobalState").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().int()
+	});
+}
+function ModuleSchema() {
+	return z.object({
+		__typename: z.literal("ModuleSpecification").optional(),
+		description: z.string().nullable(),
+		id: z.string(),
+		name: z.string(),
+		operations: z.array(OperationSpecificationSchema())
+	});
+}
+function MoveOperationInputSchema() {
+	return z.object({
+		newModuleId: z.string(),
+		operationId: z.string()
+	});
+}
+function OperationSpecificationSchema() {
+	return z.object({
+		__typename: z.literal("OperationSpecification").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("OperationErrorSpecification").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()
+	});
+}
+//#endregion
+//#region document-model/utils.ts
+function generateId(method) {
+	if (method && method.toString() !== "UUIDv4") throw new Error(`Id generation method not supported: "${method.toString()}"`);
+	return globalThis.crypto.randomUUID();
+}
+/**
+* Derives a deterministic operation ID from stable properties.
+*/
+function deriveOperationId(documentId, scope, branch, actionId) {
+	return hashBrowser(`${documentId}:${scope}:${branch}:${actionId}`, "sha1", "hex").slice(0, 32);
+}
+//#endregion
+//#region document-model/actions.ts
+/**
+* Cancels the last `count` operations.
+*
+* @param count - Number of operations to cancel
+* @category Actions
+*/
+const undo = (count = 1, scope = "global") => createAction("UNDO", { count }, void 0, UndoActionInputSchema, scope);
+/**
+* Cancels the last `count` {@link undo | UNDO} operations.
+*
+* @param count - Number of UNDO operations to cancel
+* @category Actions
+*/
+const redo = (count = 1, scope = "global") => createAction("REDO", { count }, void 0, RedoActionInputSchema, scope);
+/**
+* Joins multiple operations into a single {@link loadState | LOAD_STATE} operation.
+*
+* @remarks
+* Useful to keep operations history smaller. Operations to prune are selected by index,
+* similar to the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice | slice} method in Arrays.
+*
+* @param start - Index of the first operation to prune
+* @param end - Index of the last operation to prune
+* @category Actions
+*/
+const prune = (start, end, scope = "global") => createAction("PRUNE", {
+	start,
+	end
+}, void 0, PruneActionInputSchema, scope);
+/**
+* Replaces the state of the document.
+*
+* @remarks
+* This action shouldn't be used directly. It is dispatched by the {@link prune} action.
+*
+* @param state - State to be set in the document.
+* @param operations - Number of operations that were removed from the previous state.
+* @category Actions
+*/
+const loadState = (state, operations) => createAction("LOAD_STATE", {
+	state,
+	operations
+}, void 0, LoadStateActionInputSchema);
+const noop = (scope = "global") => createAction("NOOP", {}, void 0, void 0, scope);
+/**
+* Helper function to be used by action creators.
+*
+* @remarks
+* Creates an action with the given type and input properties. The input
+* properties default to an empty object.
+*
+* @typeParam A - Type of the action to be returned.
+*
+* @param type - The type of the action.
+* @param input - The input properties of the action.
+* @param attachments - The attachments included in the action.
+* @param validator - The validator to use for the input properties.
+* @param scope - The scope of the action, can either be 'global' or 'local'.
+* @param skip - The number of operations to skip before this new action is applied.
+*
+* @throws Error if the type is empty or not a string.
+*
+* @returns The new action.
+*/
+function createAction(type, input, attachments, validator, scope = "global") {
+	if (!type) throw new Error("Empty action type");
+	if (typeof type !== "string") throw new Error(`Invalid action type: ${JSON.stringify(type)}`);
+	const action = {
+		id: generateId(),
+		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
+		type,
+		input,
+		scope
+	};
+	if (attachments) action.attachments = attachments;
+	try {
+		validator?.().parse(action.input);
+	} catch (error) {
+		if (error instanceof ZodError) throw new InvalidActionInputZodError(error.issues);
+		throw new InvalidActionInputError(error);
+	}
+	return action;
+}
+/**
+* This function should be used instead of { ...action } to ensure
+* that extra properties are not included in the action.
+*/
+const actionFromAction = (action) => {
+	return {
+		id: action.id,
+		timestampUtcMs: action.timestampUtcMs,
+		type: action.type,
+		input: action.input,
+		scope: action.scope,
+		context: action.context,
+		attachments: action.attachments
+	};
+};
+const operationFromAction = (action, index, skip, context) => {
+	return {
+		...action,
+		action,
+		id: deriveOperationId(context.documentId, context.scope, context.branch, action.id),
+		timestampUtcMs: action.timestampUtcMs,
+		hash: "",
+		error: void 0,
+		index,
+		skip
+	};
+};
+const operationFromOperation = (operation, index, skip, context) => {
+	const id = deriveOperationId(context.documentId, context.scope, context.branch, operation.action.id);
+	return {
+		...operation,
+		hash: "",
+		error: void 0,
+		index,
+		skip,
+		id
+	};
+};
+const operationWithContext = (operation, context) => {
+	if (!operation.action) throw new Error("Operation has no action");
+	return {
+		...operation,
+		action: {
+			...operation.action,
+			context
+		}
+	};
+};
+const actionContext = () => ({});
+const actionSigner = (user, app, signatures = []) => ({
+	user,
+	app,
+	signatures
+});
+async function buildOperationSignature(context, signMethod) {
+	const params = buildOperationSignatureParams(context);
+	const signature = await signMethod(buildOperationSignatureMessage(params));
+	return [...params, `0x${ab2hex(signature)}`];
+}
+async function buildSignedAction(action, reducer, document, signer, signHandler) {
+	const scopeOperations = reducer(document, action, void 0, { reuseOperationResultingState: true }).operations[action.scope];
+	if (!scopeOperations) throw new Error(`No operations found for scope: ${action.scope}`);
+	const operation = scopeOperations.at(-1);
+	if (!operation) throw new Error("Action was not applied");
+	const previousStateHash = scopeOperations.at(-2)?.hash ?? "";
+	const signature = await buildOperationSignature({
+		documentId: document.header.id,
+		signer,
+		action,
+		previousStateHash
+	}, signHandler);
+	return operationWithContext(operation, { signer: actionSigner(signer.user, signer.app, [...signer.signatures, signature]) });
+}
+async function verifyOperationSignature(signature, signer, verifyHandler) {
+	const publicKey = signer.app.key;
+	const params = signature.slice(0, 4);
+	return verifyHandler(publicKey, hex2ab(signature[4]), buildOperationSignatureMessage(params));
+}
+/**
+* Changes the name of the document.
+*
+* @param name - The name to be set in the document.
+* @category Actions
+*/
+const setName = (name) => createAction("SET_NAME", typeof name === "string" ? { name } : name, void 0, SetNameActionInputSchema, "global");
+const setModelName = (input) => createAction("SET_MODEL_NAME", { ...input }, void 0, SetModelNameInputSchema, "global");
+const setModelId = (input) => createAction("SET_MODEL_ID", { ...input }, void 0, SetModelIdInputSchema, "global");
+const setModelExtension = (input) => createAction("SET_MODEL_EXTENSION", { ...input }, void 0, SetModelExtensionInputSchema, "global");
+const setModelDescription = (input) => createAction("SET_MODEL_DESCRIPTION", { ...input }, void 0, SetModelDescriptionInputSchema, "global");
+const setAuthorName = (input) => createAction("SET_AUTHOR_NAME", { ...input }, void 0, SetAuthorNameInputSchema, "global");
+const setAuthorWebsite = (input) => createAction("SET_AUTHOR_WEBSITE", { ...input }, void 0, SetAuthorWebsiteInputSchema, "global");
+const addModule = (input) => createAction("ADD_MODULE", { ...input }, void 0, AddModuleInputSchema, "global");
+const setModuleName = (input) => createAction("SET_MODULE_NAME", { ...input }, void 0, SetModuleNameInputSchema, "global");
+const setModuleDescription = (input) => createAction("SET_MODULE_DESCRIPTION", { ...input }, void 0, SetModuleDescriptionInputSchema, "global");
+const deleteModule = (input) => createAction("DELETE_MODULE", { ...input }, void 0, DeleteModuleInputSchema, "global");
+const reorderModules = (input) => createAction("REORDER_MODULES", { ...input }, void 0, ReorderModulesInputSchema, "global");
+const addOperation = (input) => createAction("ADD_OPERATION", { ...input }, void 0, AddOperationInputSchema, "global");
+const setOperationName = (input) => createAction("SET_OPERATION_NAME", { ...input }, void 0, SetOperationNameInputSchema, "global");
+const setOperationScope = (input) => createAction("SET_OPERATION_SCOPE", { ...input }, void 0, SetOperationScopeInputSchema, "global");
+const setOperationSchema = (input) => createAction("SET_OPERATION_SCHEMA", { ...input }, void 0, SetOperationSchemaInputSchema, "global");
+const setOperationDescription = (input) => createAction("SET_OPERATION_DESCRIPTION", { ...input }, void 0, SetOperationDescriptionInputSchema, "global");
+const setOperationTemplate = (input) => createAction("SET_OPERATION_TEMPLATE", { ...input }, void 0, SetOperationTemplateInputSchema, "global");
+const setOperationReducer = (input) => createAction("SET_OPERATION_REDUCER", { ...input }, void 0, SetOperationReducerInputSchema, "global");
+const moveOperation = (input) => createAction("MOVE_OPERATION", { ...input }, void 0, MoveOperationInputSchema, "global");
+const deleteOperation = (input) => createAction("DELETE_OPERATION", { ...input }, void 0, DeleteOperationInputSchema, "global");
+const reorderModuleOperations = (input) => createAction("REORDER_MODULE_OPERATIONS", { ...input }, void 0, ReorderModuleOperationsInputSchema, "global");
+const addOperationError = (input) => createAction("ADD_OPERATION_ERROR", { ...input }, void 0, AddOperationErrorInputSchema, "global");
+const setOperationErrorCode = (input) => createAction("SET_OPERATION_ERROR_CODE", { ...input }, void 0, SetOperationErrorCodeInputSchema, "global");
+const setOperationErrorName = (input) => createAction("SET_OPERATION_ERROR_NAME", { ...input }, void 0, SetOperationErrorNameInputSchema, "global");
+const setOperationErrorDescription = (input) => createAction("SET_OPERATION_ERROR_DESCRIPTION", { ...input }, void 0, SetOperationErrorDescriptionInputSchema, "global");
+const setOperationErrorTemplate = (input) => createAction("SET_OPERATION_ERROR_TEMPLATE", { ...input }, void 0, SetOperationErrorTemplateInputSchema, "global");
+const deleteOperationError = (input) => createAction("DELETE_OPERATION_ERROR", { ...input }, void 0, DeleteOperationErrorInputSchema, "global");
+const reorderOperationErrors = (input) => createAction("REORDER_OPERATION_ERRORS", { ...input }, void 0, ReorderOperationErrorsInputSchema, "global");
+const addOperationExample = (input) => createAction("ADD_OPERATION_EXAMPLE", { ...input }, void 0, AddOperationExampleInputSchema, "global");
+const updateOperationExample = (input) => createAction("UPDATE_OPERATION_EXAMPLE", { ...input }, void 0, UpdateOperationExampleInputSchema, "global");
+const deleteOperationExample = (input) => createAction("DELETE_OPERATION_EXAMPLE", { ...input }, void 0, DeleteOperationExampleInputSchema, "global");
+const reorderOperationExamples = (input) => createAction("REORDER_OPERATION_EXAMPLES", { ...input }, void 0, ReorderOperationExamplesInputSchema, "global");
+const operationExampleCreators = {
+	addOperationExample,
+	updateOperationExample,
+	deleteOperationExample,
+	reorderOperationExamples
+};
+const setStateSchema = (input) => createAction("SET_STATE_SCHEMA", { ...input }, void 0, SetStateSchemaInputSchema, "global");
+const setInitialState = (input) => createAction("SET_INITIAL_STATE", { ...input }, void 0, SetInitialStateInputSchema, "global");
+const addStateExample = (input) => createAction("ADD_STATE_EXAMPLE", { ...input }, void 0, AddStateExampleInputSchema, "global");
+const updateStateExample = (input) => createAction("UPDATE_STATE_EXAMPLE", { ...input }, void 0, UpdateStateExampleInputSchema, "global");
+const deleteStateExample = (input) => createAction("DELETE_STATE_EXAMPLE", { ...input }, void 0, DeleteStateExampleInputSchema, "global");
+const reorderStateExamples = (input) => createAction("REORDER_STATE_EXAMPLES", { ...input }, void 0, ReorderStateExamplesInputSchema, "global");
+const addChangeLogItem = (input) => createAction("ADD_CHANGE_LOG_ITEM", { ...input }, void 0, AddChangeLogItemInputSchema, "global");
+const updateChangeLogItem = (input) => createAction("UPDATE_CHANGE_LOG_ITEM", { ...input }, void 0, UpdateChangeLogItemInputSchema, "global");
+const deleteChangeLogItem = (input) => createAction("DELETE_CHANGE_LOG_ITEM", { ...input }, void 0, DeleteChangeLogItemInputSchema, "global");
+const reorderChangeLogItems = (input) => createAction("REORDER_CHANGE_LOG_ITEMS", { ...input }, void 0, ReorderChangeLogItemsInputSchema, "global");
+const releaseNewVersion = () => createAction("RELEASE_NEW_VERSION", {}, void 0, void 0, "global");
+const baseActions = {
+	setName,
+	undo,
+	redo,
+	prune,
+	loadState,
+	noop
+};
+const documentModelActions = {
+	setModelName,
+	setModelId,
+	setModelExtension,
+	setModelDescription,
+	setAuthorName,
+	setAuthorWebsite,
+	addModule,
+	setModuleName,
+	setModuleDescription,
+	deleteModule,
+	reorderModules,
+	addOperation,
+	setOperationName,
+	setOperationScope,
+	setOperationSchema,
+	setOperationDescription,
+	setOperationTemplate,
+	setOperationReducer,
+	moveOperation,
+	deleteOperation,
+	reorderModuleOperations,
+	addOperationError,
+	setOperationErrorCode,
+	setOperationErrorName,
+	setOperationErrorDescription,
+	setOperationErrorTemplate,
+	deleteOperationError,
+	reorderOperationErrors,
+	setStateSchema,
+	setInitialState,
+	addStateExample,
+	updateStateExample,
+	deleteStateExample,
+	reorderStateExamples,
+	addChangeLogItem,
+	updateChangeLogItem,
+	deleteChangeLogItem,
+	reorderChangeLogItems,
+	releaseNewVersion
+};
+const actions = {
+	...baseActions,
+	...documentModelActions
+};
+//#endregion
+//#region document-model/constants.ts
+const documentModelFileExtension = "phdm";
+const documentModelInitialLocalState = {};
+const documentModelInitialGlobalState = {
+	id: "",
+	name: "",
+	extension: "",
+	description: "",
+	author: {
+		name: "",
+		website: ""
+	},
+	specifications: [{
+		version: 1,
+		changeLog: [],
+		state: {
+			global: {
+				schema: "",
+				initialValue: "",
+				examples: []
+			},
+			local: {
+				schema: "",
+				initialValue: "",
+				examples: []
+			}
+		},
+		modules: []
+	}]
+};
+const documentModelGlobalState = {
+	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: [],
+		state: {
+			global: {
+				schema: "type CodeExample {\n    id: ID!\n    value: String!\n}\n\ntype OperationError {\n    id: ID!\n    code: String\n    name: String\n    description: String\n    template: String\n}\n\ntype Operation {\n    id: ID!\n    name: String\n    schema: String\n    description: String\n    template: String\n    errors: [OperationError!]!\n    examples: [CodeExample!]!\n    reducer: String\n    scope: String\n}\n\ntype Module {\n    id: ID!\n    name: String!\n    description: String\n    operations: [Operation!]!\n}\n\ntype State {\n    schema: String!\n    initialValue: String!\n    examples: [CodeExample!]!\n}\n\ntype ScopeState {\n    global: State!\n    local: State!\n}\n\ntype Author {\n    name: String!\n    website: String\n}\n\ntype DocumentSpecification {\n    version: Int!\n    state: ScopeState!\n    modules: [Module!]!\n    changeLog: [String!]!\n}\n\ntype DocumentModelGlobalState {\n    name: String!\n    id: String!\n    extension: String!\n    description: String!\n    author: Author!\n    specifications: [DocumentSpecification!]!\n}",
+				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                \"global\": {\n                    \"schema\": \"\",\n                    \"initialValue\": \"\",\n                    \"examples\": []\n                },\n                \"local\": {\n                    \"schema\": \"\",\n                    \"initialValue\": \"\",\n                    \"examples\": []\n                }\n            },\n            \"modules\": []\n        }\n    ]\n}",
+				examples: []
+			},
+			local: {
+				schema: "",
+				initialValue: "",
+				examples: []
+			}
+		},
+		modules: [
+			{
+				name: "header",
+				operations: [
+					{
+						name: "SET_MODEL_NAME",
+						id: "",
+						description: "Sets the name of the document model",
+						schema: "input SetModelNameInput {\n    name: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_MODEL_ID",
+						id: "",
+						description: "Sets the unique identifier for the document model",
+						schema: "input SetModelIdInput {\n    id: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_MODEL_EXTENSION",
+						id: "",
+						description: "Sets the file extension associated with this document model",
+						schema: "input SetModelExtensionInput {\n    extension: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_MODEL_DESCRIPTION",
+						id: "",
+						description: "Sets the description text for the document model",
+						schema: "input SetModelDescriptionInput {\n    description: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_AUTHOR_NAME",
+						id: "",
+						description: "Sets the name of the document model author",
+						schema: "input SetAuthorNameInput {\n    authorName: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_AUTHOR_WEBSITE",
+						id: "",
+						description: "Sets the website URL of the document model author",
+						schema: "input SetAuthorWebsiteInput {\n    authorWebsite: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					}
+				],
+				id: "",
+				description: ""
+			},
+			{
+				name: "versioning",
+				operations: [
+					{
+						name: "ADD_CHANGE_LOG_ITEM",
+						id: "",
+						description: "Adds a new item to the document model changelog",
+						schema: "input AddChangeLogItemInput {\n    id: ID!\n    insertBefore: ID\n    content: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "UPDATE_CHANGE_LOG_ITEM",
+						id: "",
+						description: "Updates an existing changelog item",
+						schema: "input UpdateChangeLogItemInput {\n    id: ID!\n    newContent: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "DELETE_CHANGE_LOG_ITEM",
+						id: "",
+						description: "Removes an item from the document model changelog",
+						schema: "input DeleteChangeLogItemInput {\n    id: ID!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "REORDER_CHANGE_LOG_ITEMS",
+						id: "",
+						description: "Changes the order of changelog items",
+						schema: "input ReorderChangeLogItemsInput {\n    order: [ID!]!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "RELEASE_NEW_VERSION",
+						schema: null,
+						id: "",
+						description: "Creates a new version of the document model specification",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					}
+				],
+				id: "",
+				description: ""
+			},
+			{
+				name: "module",
+				operations: [
+					{
+						name: "ADD_MODULE",
+						id: "",
+						description: "Adds a new module to the document model specification",
+						schema: "input AddModuleInput {\n    id: ID!\n    name: String!\n    description: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_MODULE_NAME",
+						id: "",
+						description: "Sets the name of an existing module",
+						schema: "input SetModuleNameInput {\n    id: ID!\n    name: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_MODULE_DESCRIPTION",
+						id: "",
+						description: "Sets the description of an existing module",
+						schema: "input SetModuleDescriptionInput {\n    id: ID!\n    description: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "DELETE_MODULE",
+						id: "",
+						description: "Removes a module from the document model specification",
+						schema: "input DeleteModuleInput {\n    id: ID!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "REORDER_MODULES",
+						id: "",
+						description: "Changes the order of modules in the document model specification",
+						schema: "input ReorderModulesInput {\n    order: [ID!]!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					}
+				],
+				id: "",
+				description: ""
+			},
+			{
+				name: "operation-error",
+				operations: [
+					{
+						name: "ADD_OPERATION_ERROR",
+						id: "",
+						description: "Adds a new error definition to an operation",
+						schema: "input AddOperationErrorInput {\n    operationId: ID!\n    id: ID!\n    errorCode: String\n    errorName: String\n    errorDescription: String\n    errorTemplate: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_OPERATION_ERROR_CODE",
+						id: "",
+						description: "Sets the error code for an operation error",
+						schema: "input SetOperationErrorCodeInput {\n    id: ID!\n    errorCode: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_OPERATION_ERROR_NAME",
+						id: "",
+						description: "Sets the name of an operation error",
+						schema: "input SetOperationErrorNameInput {\n    id: ID!\n    errorName: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_OPERATION_ERROR_DESCRIPTION",
+						id: "",
+						description: "Sets the description of an operation error",
+						schema: "input SetOperationErrorDescriptionInput {\n    id: ID!\n    errorDescription: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_OPERATION_ERROR_TEMPLATE",
+						id: "",
+						description: "Sets the template for an operation error",
+						schema: "input SetOperationErrorTemplateInput {\n    id: ID!\n    errorTemplate: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "DELETE_OPERATION_ERROR",
+						id: "",
+						description: "Removes an error definition from an operation",
+						schema: "input DeleteOperationErrorInput {\n    id: ID!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "REORDER_OPERATION_ERRORS",
+						id: "",
+						description: "Changes the order of error definitions for an operation",
+						schema: "input ReorderOperationErrorsInput {\n    operationId: ID!\n    order: [ID!]!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					}
+				],
+				id: "",
+				description: ""
+			},
+			{
+				name: "operation-example",
+				operations: [
+					{
+						name: "ADD_OPERATION_EXAMPLE",
+						id: "",
+						description: "Adds a new code example to an operation",
+						schema: "input AddOperationExampleInput {\n    operationId: ID!\n    id: ID!\n    example: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "UPDATE_OPERATION_EXAMPLE",
+						id: "",
+						description: "Updates an existing code example for an operation",
+						schema: "input UpdateOperationExampleInput {\n    id: ID!\n    example: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "DELETE_OPERATION_EXAMPLE",
+						id: "",
+						description: "Removes a code example from an operation",
+						schema: "input DeleteOperationExampleInput {\n    id: ID!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "REORDER_OPERATION_EXAMPLES",
+						id: "",
+						description: "Changes the order of code examples for an operation",
+						schema: "input ReorderOperationExamplesInput {\n    operationId: ID!\n    order: [ID!]!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					}
+				],
+				id: "",
+				description: ""
+			},
+			{
+				name: "operation",
+				operations: [
+					{
+						name: "ADD_OPERATION",
+						id: "",
+						description: "Adds a new operation to a module",
+						schema: "input AddOperationInput {\n    moduleId: ID!\n    id: ID!\n    name: String!\n    schema: String\n    description: String\n    template: String\n    reducer: String\n    scope: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_OPERATION_NAME",
+						id: "",
+						description: "Sets the name of an operation",
+						schema: "input SetOperationNameInput {\n    id: ID!\n    name: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_OPERATION_SCHEMA",
+						id: "",
+						description: "Sets the GraphQL schema definition for an operation's input",
+						schema: "input SetOperationSchemaInput {\n    id: ID!\n    schema: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_OPERATION_DESCRIPTION",
+						id: "",
+						description: "Sets the description of an operation",
+						schema: "input SetOperationDescriptionInput {\n    id: ID!\n    description: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_OPERATION_TEMPLATE",
+						id: "",
+						description: "Sets the template code for an operation",
+						schema: "input SetOperationTemplateInput {\n    id: ID!\n    template: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_OPERATION_REDUCER",
+						id: "",
+						description: "Sets the reducer function code for an operation",
+						schema: "input SetOperationReducerInput {\n    id: ID!\n    reducer: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_OPERATION_SCOPE",
+						id: "",
+						description: "Sets the scope of an operation (global or local)",
+						schema: "input SetOperationScopeInput {\n    id: ID!\n    scope: String\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "MOVE_OPERATION",
+						id: "",
+						description: "Moves an operation from one module to another",
+						schema: "input MoveOperationInput {\n    operationId: ID!\n    newModuleId: ID!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "DELETE_OPERATION",
+						id: "",
+						description: "Removes an operation from a module",
+						schema: "input DeleteOperationInput {\n    id: ID!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "REORDER_MODULE_OPERATIONS",
+						id: "",
+						description: "Changes the order of operations within a module",
+						schema: "input ReorderModuleOperationsInput {\n    moduleId: ID!\n    order: [ID!]!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					}
+				],
+				id: "",
+				description: ""
+			},
+			{
+				name: "state",
+				operations: [
+					{
+						name: "SET_STATE_SCHEMA",
+						id: "",
+						description: "Sets the GraphQL schema definition for document state",
+						schema: "input SetStateSchemaInput {\n    scope: String!\n    schema: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "SET_INITIAL_STATE",
+						id: "",
+						description: "Sets the initial state value for a document scope",
+						schema: "input SetInitialStateInput {\n    scope: String!\n    initialValue: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "ADD_STATE_EXAMPLE",
+						id: "",
+						description: "Adds a new state example to a document scope",
+						schema: "input AddStateExampleInput {\n    scope: String!\n    id: ID!\n    insertBefore: ID\n    example: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "UPDATE_STATE_EXAMPLE",
+						id: "",
+						description: "Updates an existing state example for a document scope",
+						schema: "input UpdateStateExampleInput {\n    scope: String!\n    id: ID!\n    newExample: String!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "DELETE_STATE_EXAMPLE",
+						id: "",
+						description: "Removes a state example from a document scope",
+						schema: "input DeleteStateExampleInput {\n    scope: String!\n    id: ID!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					},
+					{
+						name: "REORDER_STATE_EXAMPLES",
+						id: "",
+						description: "Changes the order of state examples for a document scope",
+						schema: "input ReorderStateExamplesInput {\n    scope: String!\n    order: [ID!]!\n}",
+						template: "",
+						reducer: "",
+						examples: [],
+						errors: [],
+						scope: "global"
+					}
+				],
+				id: "",
+				description: ""
+			}
+		]
+	}]
+};
+const HASH_ALGORITHM_SHA1 = "sha1";
+const HASH_ALGORITHM_SHA256 = "sha256";
+const HASH_ALGORITHM_SHA512 = "sha512";
+const HASH_ENCODING_BASE64 = "base64";
+const HASH_ENCODING_HEX = "hex";
+//#endregion
+//#region document-model/document-type.ts
+const documentModelDocumentType = "powerhouse/document-model";
+//#endregion
+//#region document-model/document-schema.ts
+const BaseDocumentHeaderSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	createdAtUtcIso: z.string(),
+	lastModifiedAtUtcIso: z.string(),
+	documentType: z.string()
+});
+const BaseDocumentStateSchema = z.object({ global: z.unknown() });
+/** Schema for validating the header object of a DocumentModel document */
+const DocumentModelHeaderSchema = BaseDocumentHeaderSchema.extend({ documentType: z.literal(documentModelDocumentType) });
+/** Schema for validating the state object of a DocumentModel document */
+const DocumentModelPHStateSchema = BaseDocumentStateSchema.extend({ global: DocumentModelGlobalStateSchema() });
+const DocumentModelSchema = z.object({
+	header: DocumentModelHeaderSchema,
+	state: DocumentModelPHStateSchema,
+	initialState: DocumentModelPHStateSchema
+});
+/** Simple helper function to check if a state object is a DocumentModel document state object */
+function isDocumentModelState(state) {
+	return DocumentModelPHStateSchema.safeParse(state).success;
+}
+/** Simple helper function to assert that a document state object is a DocumentModel document state object */
+function assertIsDocumentModelState(state) {
+	DocumentModelPHStateSchema.parse(state);
+}
+/** Simple helper function to check if a document is a DocumentModel document */
+function isDocumentModelDocument(document) {
+	return DocumentModelSchema.safeParse(document).success;
+}
+/** Simple helper function to assert that a document is a DocumentModel document */
+function assertIsDocumentModelDocument(document) {
+	DocumentModelSchema.parse(document);
+}
+//#endregion
+//#region document-model/header.ts
+/**
+* Generates a deterministic payload from signing parameters
+*/
+const generateStablePayload = (parameters) => `${parameters.documentType}:${parameters.createdAtUtcIso}:${parameters.nonce}`;
+/**
+* Creates a verification-only signer from a public key.
+* This signer can only verify signatures, not sign data.
+*
+* @param pubKey - The public key to use for verification.
+* @returns An ISigner that can only verify signatures.
+*/
+async function createVerificationSigner(pubKey) {
+	const cryptoKey = await crypto.subtle.importKey("jwk", pubKey, {
+		name: "ECDSA",
+		namedCurve: "P-256"
+	}, true, ["verify"]);
+	return {
+		publicKey: cryptoKey,
+		async sign(_data) {
+			throw new Error("verification-only signer cannot sign data");
+		},
+		async signAction(_action, _abortSignal) {
+			throw new Error("verification-only signer cannot sign actions");
+		},
+		async verify(data, signature) {
+			let isValid;
+			try {
+				isValid = await crypto.subtle.verify({
+					name: "ECDSA",
+					hash: "SHA-256"
+				}, cryptoKey, new Uint8Array(signature), new Uint8Array(data));
+			} catch {
+				throw new Error("invalid signature");
+			}
+			if (!isValid) throw new Error("invalid signature");
+		}
+	};
+}
+/**
+* Creates a verification-only signer from a header.
+*
+* @param header - The header to create a signer from.
+* @returns A signer that can verify the header's signature.
+*/
+const createSignerFromHeader = async (header) => {
+	return createVerificationSigner(header.sig.publicKey);
+};
+/**
+* Signs a header. Generally, this is not called directly, but rather through
+* {@link createSignedHeader}.
+*
+* @param parameters - The parameters used to sign the header.
+* @param signer - The signer of the document.
+*
+* @returns The signature of the header.
+*/
+const sign = async (parameters, signer) => {
+	const payload = generateStablePayload(parameters);
+	const data = new TextEncoder().encode(payload);
+	const signature = await signer.sign(data);
+	const signatureArray = new Uint8Array(signature);
+	return btoa(String.fromCharCode(...signatureArray));
+};
+/**
+* Verifies a header signature. Generally, this is not called directly, but
+* rather through {@link validateHeader}.
+*
+* @param parameters - The parameters used to sign the header.
+* @param signature - The signature to verify.
+* @param signer - The signer of the document.
+*/
+const verify = async (parameters, signature, signer) => {
+	const payload = generateStablePayload(parameters);
+	const data = new TextEncoder().encode(payload);
+	const signatureBytes = Uint8Array.from(atob(signature), (c) => c.charCodeAt(0));
+	await signer.verify(data, signatureBytes);
+};
+/**
+* Validates a header signature.
+*/
+const validateHeader = async (header) => {
+	const signer = await createSignerFromHeader(header);
+	return verify({
+		documentType: header.documentType,
+		createdAtUtcIso: header.createdAtUtcIso,
+		nonce: header.sig.nonce
+	}, header.id, signer);
+};
+/**
+* Creates a header that has yet to be signed. This header is not valid, but
+* can be input into {@link createSignedHeader} to create a signed header.
+*
+* @returns An unsigned header for a document.
+*/
+const createPresignedHeader = (id = generateId(), documentType = "") => {
+	return {
+		id,
+		sig: {
+			publicKey: {},
+			nonce: ""
+		},
+		documentType,
+		createdAtUtcIso: (/* @__PURE__ */ new Date()).toISOString(),
+		slug: "",
+		name: "",
+		branch: "main",
+		revision: { document: 0 },
+		lastModifiedAtUtcIso: (/* @__PURE__ */ new Date()).toISOString(),
+		meta: {}
+	};
+};
+/**
+* Creates a new, signed header for a document. This will replace the id of the
+* document.
+*
+* @param unsignedHeader - The unsigned header to created the signed header from.
+* @param signer - The signer of the document.
+*
+* @returns A new signed header for a document. Some fields are mutable and
+* some are not. See the PHDocumentHeader type for more information.
+*/
+const createSignedHeader = async (unsignedHeader, documentType, signer) => {
+	const parameters = {
+		documentType,
+		createdAtUtcIso: unsignedHeader.createdAtUtcIso,
+		nonce: generateId()
+	};
+	return {
+		id: await sign(parameters, signer),
+		sig: {
+			publicKey: await crypto.subtle.exportKey("jwk", signer.publicKey),
+			nonce: parameters.nonce
+		},
+		documentType,
+		createdAtUtcIso: unsignedHeader.createdAtUtcIso,
+		slug: unsignedHeader.slug,
+		name: unsignedHeader.name,
+		branch: unsignedHeader.branch,
+		revision: unsignedHeader.revision,
+		lastModifiedAtUtcIso: unsignedHeader.lastModifiedAtUtcIso,
+		meta: unsignedHeader.meta
+	};
+};
+/**
+* Creates a signed header for a document. The document header requires a signer
+* as the document id is a cryptographic signature.
+*
+* @param documentType - The type of the document.
+* @param signer - The signer of the document.
+*
+* @returns The signed header for a document. Some fields are mutable and
+* some are not. See the PHDocumentHeader type for more information.
+*/
+const createSignedHeaderForSigner = async (documentType, signer) => {
+	return await createSignedHeader(createPresignedHeader(), documentType, signer);
+};
+//#endregion
+//#region document-model/documents.ts
+function isNoopOperation(op) {
+	return op.type === "NOOP" && op.skip !== void 0 && op.skip > 0 && op.hash !== void 0;
+}
+function isUndoRedo(action) {
+	return ["UNDO", "REDO"].includes(action.type);
+}
+function isUndo(action) {
+	return action.type === "UNDO";
+}
+function isDocumentAction(action) {
+	return [
+		"SET_NAME",
+		"UNDO",
+		"REDO",
+		"PRUNE",
+		"LOAD_STATE"
+	].includes(action.type);
+}
+/**
+* Important note: it is the responsibility of the caller to set the document type
+* on the header.
+*/
+function baseCreateDocument(createState, initialState) {
+	const state = createState(initialState);
+	return {
+		header: createPresignedHeader(),
+		state,
+		initialState: state,
+		operations: {
+			global: [],
+			local: []
+		},
+		clipboard: []
+	};
+}
+function hashDocumentStateForScope(document, scope = "global") {
+	return hashBrowser(stringifyJson(document.state[scope] || ""));
+}
+function readOnly(value) {
+	return Object.freeze(value);
+}
+/**
+* Maps skipped operations in an array of operations.
+* Skipped operations are operations that are ignored during processing.
+* @param operations - The array of operations to map.
+* @param skippedHeadOperations - The number of operations to skip at the head of the array of operations.
+* @returns An array of mapped operations with ignore flag indicating if the operation is skipped.
+* @throws Error if the operation index is invalid and there are missing operations.
+*/
+function mapSkippedOperations(operations, skippedHeadOperations) {
+	const ops = [...operations];
+	let skipped = skippedHeadOperations || 0;
+	let latestOpIndex = ops.length > 0 ? ops[ops.length - 1].index : 0;
+	const scopeOpsWithIgnore = [];
+	for (const operation of ops.reverse()) {
+		if (skipped > 0) {
+			const operationsDiff = latestOpIndex - operation.index;
+			skipped -= operationsDiff;
+		}
+		if (skipped < 0) throw new Error("Invalid operation index, missing operations");
+		const mappedOp = {
+			ignore: skipped > 0,
+			operation
+		};
+		const operationSkip = operation.skip > 0 ? operation.skip + 1 : 0;
+		if (operationSkip > 0 && operationSkip > skipped) {
+			const skipDiff = operationSkip - skipped;
+			skipped = skipped + skipDiff;
+		}
+		latestOpIndex = operation.index;
+		scopeOpsWithIgnore.push(mappedOp);
+	}
+	return scopeOpsWithIgnore.reverse();
+}
+/**
+* V2 version of mapSkippedOperations for protocol version 2+.
+* In V2, all NOOPs have skip=1 and consecutive NOOPs form chains.
+* N consecutive NOOPs at any point skip N preceding content operations.
+*
+* Algorithm: Process from end to start
+* - When hitting a NOOP: increment chain length, mark as ignored
+* - When hitting a non-NOOP:
+*   - If chain > 0: decrement chain, mark as ignored (this op was undone)
+*   - If chain == 0: mark as not ignored (apply this op)
+*/
+function mapSkippedOperationsV2(operations) {
+	const ops = [...operations];
+	const result = [];
+	let noopChainLength = 0;
+	for (let i = ops.length - 1; i >= 0; i--) {
+		const operation = ops[i];
+		if (operation.action.type === "NOOP") {
+			noopChainLength++;
+			result.unshift({
+				ignore: true,
+				operation
+			});
+		} else if (noopChainLength > 0) {
+			noopChainLength--;
+			result.unshift({
+				ignore: true,
+				operation
+			});
+		} else result.unshift({
+			ignore: false,
+			operation
+		});
+	}
+	return result;
+}
+/**
+* V2 garbage collect that returns only operations that should be applied for state.
+* Uses the V2 model where consecutive NOOPs form chains.
+* Unlike V1 garbageCollect, this preserves ALL operations but marks which to apply.
+*/
+function garbageCollectV2(sortedOperations) {
+	const result = [];
+	let noopChainLength = 0;
+	for (let i = sortedOperations.length - 1; i >= 0; i--) {
+		const op = sortedOperations[i];
+		if ("action" in op && op.action.type === "NOOP" && op.skip > 0) {
+			noopChainLength++;
+			result.unshift(op);
+		} else if (noopChainLength > 0) noopChainLength--;
+		else result.unshift(op);
+	}
+	return result;
+}
+function sortMappedOperations(operations) {
+	return Object.values(operations).flatMap((array) => array).sort((a, b) => new Date(a.operation.timestampUtcMs).getTime() - new Date(b.operation.timestampUtcMs).getTime());
+}
+const defaultCreateState = (state) => {
+	return state;
+};
+function replayDocument(initialState, operations, reducer, header, dispatch, skipHeaderOperations = {}, options) {
+	const { checkHashes = true, reuseOperationResultingState, operationResultingStateParser = parseResultingState, skipIndexValidation } = options || {};
+	let documentState = initialState;
+	const operationsToReplay = [];
+	const allScopes = new Set([
+		...Object.keys(operations),
+		"global",
+		"local"
+	]);
+	const initialOperations = {};
+	for (const scope of allScopes) initialOperations[scope] = [];
+	if (reuseOperationResultingState) for (const [scope, scopeOperations] of Object.entries(operations)) {
+		if (!scopeOperations) continue;
+		const index = scopeOperations.findLastIndex((s) => !!s.resultingState);
+		if (index < 0) {
+			operationsToReplay.push(...scopeOperations);
+			continue;
+		}
+		const opWithState = scopeOperations[index];
+		if (!opWithState || !opWithState.resultingState) continue;
+		try {
+			const scopeState = operationResultingStateParser(opWithState.resultingState);
+			documentState = {
+				...documentState,
+				[scope]: scopeState
+			};
+			const scopeInitialOps = initialOperations[scope];
+			if (scopeInitialOps) scopeInitialOps.push(...scopeOperations.slice(0, index + 1));
+			operationsToReplay.push(...scopeOperations.slice(index + 1));
+		} catch {
+			operationsToReplay.push(...scopeOperations);
+		}
+	}
+	else operationsToReplay.push(...Object.values(operations).flatMap((ops) => ops || []));
+	const document = {
+		header,
+		state: defaultCreateState(documentState),
+		initialState,
+		operations: initialOperations,
+		clipboard: []
+	};
+	let result = document;
+	if (operationsToReplay.length) result = operationsToReplay.reduce((document, operation) => {
+		return reducer(document, operation.action, dispatch, {
+			ignoreSkipOperations: true,
+			checkHashes,
+			skipIndexValidation,
+			replayOptions: { operation }
+		});
+	}, document);
+	else for (const scopeOperations of Object.values(initialOperations)) {
+		if (!scopeOperations) continue;
+		const lastOperation = scopeOperations.at(-1);
+		if (lastOperation) result = updateHeaderRevision(result, lastOperation.action.scope, lastOperation.timestampUtcMs);
+	}
+	if (!checkHashes) for (const scope of Object.keys(result.state)) for (let i = operationsToReplay.length - 1; i >= 0; i--) {
+		const operation = operationsToReplay[i];
+		if (operation.action.scope !== scope) continue;
+		if (operation.hash !== hashDocumentStateForScope(result, scope)) throw new HashMismatchError(scope, result, operation);
+		else break;
+	}
+	const allResultScopes = new Set([
+		...Object.keys(result.operations),
+		...Object.keys(operations),
+		"global",
+		"local"
+	]);
+	const initialResultOperations = {};
+	for (const scope of allResultScopes) initialResultOperations[scope] = [];
+	const resultOperations = Array.from(allResultScopes).reduce((acc, scope) => {
+		const scopeOps = result.operations[scope] || [];
+		return {
+			...acc,
+			[scope]: [...scopeOps.map((operation, index) => {
+				return {
+					...operation,
+					timestamp: operations[scope]?.[index]?.timestampUtcMs ?? operation.timestampUtcMs
+				};
+			})]
+		};
+	}, initialResultOperations);
+	const lastModified = header ? header.lastModifiedAtUtcIso : Object.values(resultOperations).reduce((acc, curr) => {
+		if (!curr) return acc;
+		const operation = curr.at(-1);
+		if (operation) {
+			if (operation.timestampUtcMs > acc) return operation.timestampUtcMs;
+		}
+		return acc;
+	}, document.header.lastModifiedAtUtcIso);
+	if (header) result.header = {
+		...header,
+		revision: result.header.revision,
+		lastModifiedAtUtcIso: lastModified
+	};
+	return {
+		...result,
+		operations: resultOperations
+	};
+}
+function parseResultingState(state) {
+	const stateType = typeof state;
+	if (stateType === "string") return JSON.parse(state);
+	else if (stateType === "object") return state;
+	else throw new Error(`Providing resulting state is of type: ${stateType}`);
+}
+let IntegrityIssueType = /* @__PURE__ */ function(IntegrityIssueType) {
+	IntegrityIssueType["UNEXPECTED_INDEX"] = "UNEXPECTED_INDEX";
+	return IntegrityIssueType;
+}({});
+let IntegrityIssueSubType = /* @__PURE__ */ function(IntegrityIssueSubType) {
+	IntegrityIssueSubType["DUPLICATED_INDEX"] = "DUPLICATED_INDEX";
+	IntegrityIssueSubType["MISSING_INDEX"] = "MISSING_INDEX";
+	return IntegrityIssueSubType;
+}({});
+function checkCleanedOperationsIntegrity(sortedOperations) {
+	const result = [];
+	let currentIndex = -1;
+	for (const nextOperation of sortedOperations) {
+		const nextIndex = nextOperation.index - nextOperation.skip;
+		if (nextIndex !== currentIndex + 1) result.push({
+			operation: {
+				index: nextOperation.index,
+				skip: nextOperation.skip
+			},
+			issue: IntegrityIssueType.UNEXPECTED_INDEX,
+			category: nextIndex > currentIndex + 1 ? IntegrityIssueSubType.MISSING_INDEX : IntegrityIssueSubType.DUPLICATED_INDEX,
+			message: `Expected index ${currentIndex + 1} with skip 0 or equivalent, got index ${nextOperation.index} with skip ${nextOperation.skip}`
+		});
+		currentIndex = nextOperation.index;
+	}
+	return result;
+}
+function garbageCollect(sortedOperations) {
+	const result = [];
+	let i = sortedOperations.length - 1;
+	while (i > -1) {
+		result.unshift(sortedOperations[i]);
+		const skipUntil = (sortedOperations[i]?.index || 0) - (sortedOperations[i]?.skip || 0) - 1;
+		let j = i - 1;
+		while (j > -1 && (sortedOperations[j]?.index || 0) > skipUntil) j--;
+		i = j;
+	}
+	return result;
+}
+function addUndo(sortedOperations) {
+	const operationsCopy = [...sortedOperations];
+	const latestOperation = operationsCopy[operationsCopy.length - 1];
+	if (!latestOperation) return operationsCopy;
+	if (latestOperation.action.type === "NOOP") operationsCopy.push({
+		...latestOperation,
+		index: latestOperation.index,
+		skip: nextSkipNumber(sortedOperations),
+		action: {
+			...latestOperation.action,
+			id: generateId(),
+			timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
+			type: "NOOP"
+		}
+	});
+	else operationsCopy.push({
+		id: generateId(),
+		timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
+		index: latestOperation.index + 1,
+		skip: 1,
+		hash: latestOperation.hash,
+		action: {
+			id: generateId(),
+			timestampUtcMs: (/* @__PURE__ */ new Date()).toISOString(),
+			type: "NOOP",
+			input: {},
+			scope: latestOperation.action.scope
+		}
+	});
+	return operationsCopy;
+}
+function sortOperations(operations) {
+	return operations.slice().sort((a, b) => a.skip - b.skip).sort((a, b) => a.index - b.index);
+}
+function reshuffleByTimestamp(startIndex, opsA, opsB) {
+	return [...opsA, ...opsB].sort((a, b) => {
+		const timestampDiff = new Date(a.timestampUtcMs || "").getTime() - new Date(b.timestampUtcMs || "").getTime();
+		if (timestampDiff !== 0) return timestampDiff;
+		return (a.id || "").localeCompare(b.id || "");
+	}).map((op, i) => ({
+		...op,
+		index: startIndex.index + i,
+		skip: i === 0 ? startIndex.skip : 0
+	}));
+}
+function reshuffleByTimestampAndIndex(startIndex, opsA, opsB) {
+	return [...opsA, ...opsB].sort((a, b) => {
+		const indexDiff = a.index - b.index;
+		if (indexDiff !== 0) return indexDiff;
+		const timestampDiff = new Date(a.timestampUtcMs || "").getTime() - new Date(b.timestampUtcMs || "").getTime();
+		if (timestampDiff !== 0) return timestampDiff;
+		return (a.id || "").localeCompare(b.id || "");
+	}).map((op, i) => ({
+		...op,
+		index: startIndex.index + i,
+		skip: i === 0 ? startIndex.skip : 0
+	}));
+}
+function operationsAreEqual(op1, op2) {
+	const a = op1;
+	const b = op2;
+	const aComparable = {
+		index: a.index,
+		skip: a.skip,
+		type: a.type ?? null,
+		scope: a.scope ?? null,
+		input: a.input ?? null
+	};
+	const bComparable = {
+		index: b.index,
+		skip: b.skip,
+		type: b.type ?? null,
+		scope: b.scope ?? null,
+		input: b.input ?? null
+	};
+	return stringify(aComparable) === stringify(bComparable);
+}
+function attachBranch(trunk, newBranch) {
+	const trunkCopy = garbageCollect(sortOperations(trunk.slice()));
+	const newOperations = garbageCollect(sortOperations(newBranch.slice()));
+	if (trunkCopy.length < 1) return [newOperations, []];
+	const result = [];
+	let enteredBranch = false;
+	while (newOperations.length > 0) {
+		const newOperationCandidate = newOperations[0];
+		let nextTrunkOperation = trunkCopy.shift();
+		while (nextTrunkOperation && precedes(nextTrunkOperation, newOperationCandidate)) {
+			result.push(nextTrunkOperation);
+			nextTrunkOperation = trunkCopy.shift();
+		}
+		if (!nextTrunkOperation) enteredBranch = true;
+		else if (!enteredBranch) if (operationsAreEqual(nextTrunkOperation, newOperationCandidate)) {
+			newOperations.shift();
+			result.push(nextTrunkOperation);
+		} else {
+			trunkCopy.unshift(nextTrunkOperation);
+			enteredBranch = true;
+		}
+		if (enteredBranch) {
+			let nextAppend = newOperations.shift();
+			while (nextAppend) {
+				result.push(nextAppend);
+				nextAppend = newOperations.shift();
+			}
+		}
+	}
+	if (!enteredBranch) {
+		let nextAppend = trunkCopy.shift();
+		while (nextAppend) {
+			result.push(nextAppend);
+			nextAppend = trunkCopy.shift();
+		}
+	}
+	return [garbageCollect(result), trunkCopy];
+}
+function precedes(op1, op2) {
+	return op1.index < op2.index || op1.index === op2.index && op1.id === op2.id && op1.skip < op2.skip;
+}
+function split(sortedTargetOperations, sortedMergeOperations) {
+	const commonOperations = [];
+	const targetDiffOperations = [];
+	const mergeDiffOperations = [];
+	const maxLength = Math.max(sortedTargetOperations.length, sortedMergeOperations.length);
+	let splitHappened = false;
+	for (let i = 0; i < maxLength; i++) {
+		const targetOperation = sortedTargetOperations[i];
+		const mergeOperation = sortedMergeOperations[i];
+		if (targetOperation && mergeOperation) if (!splitHappened && operationsAreEqual(targetOperation, mergeOperation)) commonOperations.push(targetOperation);
+		else {
+			splitHappened = true;
+			targetDiffOperations.push(targetOperation);
+			mergeDiffOperations.push(mergeOperation);
+		}
+		else if (targetOperation) targetDiffOperations.push(targetOperation);
+		else if (mergeOperation) mergeDiffOperations.push(mergeOperation);
+	}
+	return [
+		commonOperations,
+		targetDiffOperations,
+		mergeDiffOperations
+	];
+}
+function merge(sortedTargetOperations, sortedMergeOperations, reshuffle) {
+	const [_commonOperations, _targetOperations, _mergeOperations] = split(garbageCollect(sortedTargetOperations), garbageCollect(sortedMergeOperations));
+	const maxCommonIndex = getMaxIndex(_commonOperations);
+	const nextIndex = 1 + Math.max(maxCommonIndex, getMaxIndex(_targetOperations), getMaxIndex(_mergeOperations));
+	const filteredMergeOperations = filterDuplicatedOperations(_mergeOperations, _targetOperations);
+	const newOperationHistory = reshuffle({
+		index: nextIndex,
+		skip: nextIndex - (maxCommonIndex + 1)
+	}, _targetOperations, filteredMergeOperations);
+	return _commonOperations.concat(newOperationHistory);
+}
+function getMaxIndex(sortedOperations) {
+	const lastElement = sortedOperations[sortedOperations.length - 1];
+	if (!lastElement) return -1;
+	return lastElement.index;
+}
+function nextSkipNumber(sortedOperations) {
+	if (sortedOperations.length < 1) return -1;
+	const cleanedOperations = garbageCollect(sortedOperations);
+	let nextSkip = (cleanedOperations[cleanedOperations.length - 1]?.skip || 0) + 1;
+	if (cleanedOperations.length > 1) nextSkip += cleanedOperations[cleanedOperations.length - 2]?.skip || 0;
+	return (cleanedOperations[cleanedOperations.length - 1]?.index || -1) < nextSkip ? -1 : nextSkip;
+}
+function checkOperationsIntegrity(operations) {
+	return checkCleanedOperationsIntegrity(garbageCollect(sortOperations(operations)));
+}
+function groupOperationsByScope(operations) {
+	return operations.reduce((acc, operation) => {
+		if (!acc[operation.action.scope]) acc[operation.action.scope] = [];
+		acc[operation.action.scope]?.push(operation);
+		return acc;
+	}, {});
+}
+function prepareOperations(operationsHistory, newOperations) {
+	const result = {
+		integrityIssues: [],
+		validOperations: [],
+		invalidOperations: [],
+		duplicatedOperations: []
+	};
+	const sortedOperationsHistory = sortOperations(operationsHistory);
+	const sortedOperations = sortOperations(newOperations);
+	const integrityErrors = checkCleanedOperationsIntegrity([...sortedOperationsHistory, ...sortedOperations]);
+	const firstMissingIndexOperation = [...integrityErrors.filter((integrityIssue) => integrityIssue.category === IntegrityIssueSubType.MISSING_INDEX)].sort((a, b) => b.operation.index - a.operation.index).pop()?.operation;
+	for (const newOperation of sortedOperations) {
+		if (firstMissingIndexOperation && newOperation.index >= firstMissingIndexOperation.index) {
+			result.invalidOperations.push(newOperation);
+			continue;
+		}
+		if (integrityErrors.some((integrityError) => {
+			return integrityError.operation.index === newOperation.index && integrityError.operation.skip === newOperation.skip && integrityError.category === IntegrityIssueSubType.DUPLICATED_INDEX;
+		})) {
+			result.duplicatedOperations.push(newOperation);
+			continue;
+		}
+		result.validOperations.push(newOperation);
+	}
+	result.integrityIssues.push(...integrityErrors);
+	return result;
+}
+function removeExistingOperations(newOperations, operationsHistory) {
+	return newOperations.filter((newOperation) => {
+		return !operationsHistory.some((historyOperation) => {
+			return newOperation.action.type === "NOOP" && newOperation.skip === 0 && newOperation.index === historyOperation.index || newOperation.index === historyOperation.index && newOperation.skip === historyOperation.skip && newOperation.action.scope === historyOperation.action.scope && newOperation.hash === historyOperation.hash && newOperation.action.type === historyOperation.action.type;
+		});
+	});
+}
+/**
+* Skips header operations and returns the remaining operations.
+*
+* @param operations - The array of operations.
+* @param skipHeaderOperation - The skip header operation index.
+* @returns The remaining operations after skipping header operations.
+*/
+function skipHeaderOperations(operations, skipHeaderOperation) {
+	const lastIndex = sortOperations(operations).at(-1)?.index ?? -1;
+	const nextIndex = lastIndex + 1;
+	const skipOperationIndex = {
+		...skipHeaderOperation,
+		index: skipHeaderOperation.index ?? nextIndex
+	};
+	if (skipOperationIndex.index < lastIndex) throw new Error(`The skip header operation index must be greater than or equal to ${lastIndex}`);
+	return garbageCollect(sortOperations([...operations, skipOperationIndex])).slice(0, -1);
+}
+function garbageCollectDocumentOperations(documentOperations) {
+	return Object.entries(documentOperations).reduce((acc, entry) => {
+		const [scope, ops] = entry;
+		if (!ops) return acc;
+		return {
+			...acc,
+			[scope]: garbageCollect(sortOperations(ops))
+		};
+	}, {});
+}
+/**
+* Filters out duplicated operations from the target operations array based on their IDs.
+* If an operation has an ID, it is considered duplicated if there is another operation in the source operations array with the same ID.
+* If an operation does not have an ID, it is considered unique and will not be filtered out.
+* @param targetOperations - The array of target operations to filter.
+* @param sourceOperations - The array of source operations to compare against.
+* @returns An array of operations with duplicates filtered out.
+*/
+function filterDuplicatedOperations(targetOperations, sourceOperations) {
+	return targetOperations.filter((op) => {
+		if (op.id) return !sourceOperations.some((targetOp) => targetOp.id === op.id);
+		return true;
+	});
+}
+function filterDocumentOperationsResultingState(documentOperations) {
+	if (!documentOperations) return {};
+	return Object.entries(documentOperations).reduce((acc, [scope, operations]) => {
+		if (!operations) return acc;
+		return {
+			...acc,
+			[scope]: operations.map((op) => {
+				const { resultingState, ...restProps } = op;
+				return restProps;
+			})
+		};
+	}, {});
+}
+/**
+* Calculates the difference between two arrays of operations.
+* Returns an array of operations that are present in `clearedOperationsA` but not in `clearedOperationsB`.
+*
+* @template TOp - The type of the operations.
+* @param {TOp[]} clearedOperationsA - The first array of operations.
+* @param {TOp[]} clearedOperationsB - The second array of operations.
+* @returns {TOp[]} - The difference between the two arrays of operations.
+*/
+function diffOperations(clearedOperationsA, clearedOperationsB) {
+	return clearedOperationsA.filter((operationA) => !clearedOperationsB.some((operationB) => operationA.index === operationB.index));
+}
+function getDocumentLastModified(document) {
+	let latest;
+	for (const ops of Object.values(document.operations)) {
+		if (!ops) continue;
+		for (const op of ops) if (!latest || op.index > latest.index || op.index === latest.index && op.skip > latest.skip) latest = op;
+	}
+	return latest?.timestampUtcMs || document.header.lastModifiedAtUtcIso;
+}
+/**
+* Gets the next revision number based on the provided scope.
+*
+* @param state The current state of the document.
+* @param scope The scope of the operation.
+* @returns The next revision number.
+*/
+function getNextRevision(document, scope) {
+	return (document.operations[scope]?.at(-1)?.index ?? -1) + 1;
+}
+/**
+* Updates the document header with the latest revision number and
+* date of last modification.
+*
+* @param document The current state of the document.
+* @param scope The scope of the operation.
+* @param lastModifiedTimestamp Optional timestamp to use directly, avoiding a scan of all operations.
+* @returns The updated document state.
+*/
+function updateHeaderRevision(document, scope, lastModifiedTimestamp) {
+	const newTimestamp = lastModifiedTimestamp ?? getDocumentLastModified(document);
+	const currentTimestamp = document.header.lastModifiedAtUtcIso;
+	const header = {
+		...document.header,
+		revision: {
+			...document.header.revision,
+			[scope]: getNextRevision(document, scope)
+		},
+		lastModifiedAtUtcIso: !currentTimestamp || newTimestamp > currentTimestamp ? newTimestamp : currentTimestamp
+	};
+	return {
+		...document,
+		header
+	};
+}
+//#endregion
+//#region document-model/operations.ts
+function setNameOperation(document, input) {
+	return {
+		...document,
+		header: {
+			...document.header,
+			name: input.name
+		}
+	};
+}
+function undoOperation(document, action, skip) {
+	const { scope } = action;
+	return create({
+		document,
+		action,
+		skip,
+		reuseLastOperationIndex: false
+	}, (draft) => {
+		const sortedOperations = sortOperations([...document.operations[scope]]);
+		draft.action = noop(scope);
+		const lastOperation = sortedOperations.at(-1);
+		let nextIndex = lastOperation?.index ?? -1;
+		const isNewNoop = lastOperation?.action.type !== "NOOP";
+		if (isNewNoop) nextIndex = nextIndex + 1;
+		else draft.reuseLastOperationIndex = true;
+		draft.skip = nextSkipNumber(isNewNoop ? [...sortedOperations, {
+			index: nextIndex,
+			skip: 0
+		}] : sortedOperations);
+		if (lastOperation && draft.skip > lastOperation.skip + 1) draft.skip = draft.skip + 1;
+		if (draft.skip < 0) throw new Error(`Cannot undo: you can't undo more operations than the ones in the scope history`);
+	});
+}
+/**
+* V2 of undoOperation for protocol version 2+.
+* Key differences from undoOperation:
+* - Never reuses operation index (always increments)
+* - Always sets skip=1 (consecutive NOOPs are handled during rebuild/GC)
+* - No complex skip calculation - simpler model where each UNDO is independent
+*/
+function undoOperationV2(document, action, skip) {
+	const { scope } = action;
+	return create({
+		document,
+		action,
+		skip,
+		reuseLastOperationIndex: false
+	}, (draft) => {
+		const sortedOperations = sortOperations([...document.operations[scope] || []]);
+		const nonNoopOps = sortedOperations.filter((op) => op.action.type !== "NOOP");
+		let noopChainLength = 0;
+		for (let i = sortedOperations.length - 1; i >= 0; i--) if (sortedOperations[i].action.type === "NOOP") noopChainLength++;
+		else break;
+		if (nonNoopOps.length <= noopChainLength) throw new Error(`Cannot undo: no more operations to undo in scope history`);
+		draft.action = noop(scope);
+		draft.skip = 1;
+	});
+}
+function redoOperation(document, action, skip) {
+	const { scope, input } = action;
+	return create({
+		document,
+		action,
+		skip,
+		reuseLastOperationIndex: false
+	}, (draft) => {
+		if (draft.skip > 0) throw new Error(`Cannot redo: skip value from reducer cannot be used with REDO action`);
+		const count = typeof input === "object" && input !== null && "count" in input ? input.count : input;
+		if (typeof count !== "number" || count > 1) throw new Error(`Cannot redo: you can only redo one operation at a time`);
+		if (typeof count !== "number" || count < 1) throw new Error(`Invalid REDO action: invalid redo input value`);
+		if (draft.document.clipboard.length < 1) throw new Error(`Cannot redo: no operations in the clipboard`);
+		const operationIndex = draft.document.clipboard.findLastIndex((op) => op.action.scope === scope);
+		if (operationIndex < 0) throw new Error(`Cannot redo: no operations in clipboard for scope "${scope}"`);
+		const operation = draft.document.clipboard.splice(operationIndex, 1)[0];
+		draft.action = castDraft({
+			type: operation.action.type,
+			scope: operation.action.scope,
+			input: operation.action.input
+		});
+	});
+}
+function loadStateOperation(document, action) {
+	return {
+		...document,
+		header: {
+			...document.header,
+			name: action.state.name
+		},
+		state: action.state.data
+	};
+}
+//#endregion
+//#region document-model/reducer.ts
+function replayOperations(initialState, clearedOperations, stateReducer, header, dispatch, documentReducer = baseReducer, skipHeaderOperations = {}, options) {
+	return replayDocument(initialState, clearedOperations, createReducer(stateReducer, documentReducer), header, dispatch, skipHeaderOperations, options);
+}
+/**
+* Updates the operations history of the document based on the provided action.
+*
+* @param state The current state of the document.
+* @param action The action being applied to the document.
+* @param index The index of the operation to update.
+* @param skip The number of operations to skip before applying the action.
+* @param reuseLastOperationIndex Whether to reuse the last operation index (used when a an UNDO operation is performed after an existing one).
+* @param context The operation context for deterministic ID generation.
+* @returns The updated document state.
+*/
+function updateOperationsForAction(document, action, reuseLastOperationIndex, skip, context) {
+	if ([
+		"UNDO",
+		"REDO",
+		"PRUNE"
+	].includes(action.type)) return document;
+	const scope = action.scope;
+	const existing = document.operations[scope];
+	const lastOperationIndex = existing?.at(-1)?.index ?? -1;
+	const newOperation = operationFromAction(action, reuseLastOperationIndex ? lastOperationIndex : lastOperationIndex + 1, skip, context);
+	const operations = [...existing ?? [], newOperation];
+	return {
+		...document,
+		operations: {
+			...document.operations,
+			[scope]: operations
+		}
+	};
+}
+function updateOperationsForOperation(document, operation, reuseLastOperationIndex, skip, context, skipIndexValidation) {
+	const scope = operation.action.scope;
+	const existing = document.operations[scope];
+	const lastOperationIndex = existing?.at(-1)?.index ?? -1;
+	const nextIndex = reuseLastOperationIndex ? lastOperationIndex : lastOperationIndex + 1;
+	if (!skipIndexValidation && operation.index - skip > nextIndex) throw new Error(`Missing operations: expected ${nextIndex} with skip 0 or equivalent, got index ${operation.index} with skip ${skip}`);
+	const newOperation = operationFromOperation(operation, operation.index, skip, context);
+	const operations = [...existing ?? [], newOperation];
+	return {
+		...document,
+		operations: {
+			...document.operations,
+			[scope]: operations
+		}
+	};
+}
+/**
+* Updates the document state based on the provided action.
+*
+* @param state The current state of the document.
+* @param action The action being applied to the document.
+* @param skip The number of operations to skip before applying the action.
+* @param reuseLastOperationIndex Whether to reuse the last operation index (used when a an UNDO operation is performed after an existing one).
+* @param context The operation context for deterministic ID generation.
+* @returns The updated document state.
+*/
+function updateDocument(document, action, reuseLastOperationIndex, skip, context, operation, skipIndexValidation) {
+	let newDocument;
+	if (operation) newDocument = updateOperationsForOperation(document, operation, reuseLastOperationIndex, skip, context, skipIndexValidation);
+	else newDocument = updateOperationsForAction(document, action, reuseLastOperationIndex, skip, context);
+	newDocument = updateHeaderRevision(newDocument, action.scope, action.timestampUtcMs);
+	return newDocument;
+}
+/**
+* The base document reducer function that wraps a custom reducer function.
+*
+* @param state The current state of the document.
+* @param action The action being applied to the document.
+* @param wrappedReducer The custom reducer function being wrapped by the base reducer.
+* @returns The updated document state.
+*/
+function _baseReducer(document, action, wrappedReducer) {
+	const parsedAction = DocumentActionSchema().parse(action);
+	switch (parsedAction.type) {
+		case "SET_NAME": return setNameOperation(document, parsedAction.input);
+		case "PRUNE": return pruneOperation(document, parsedAction.input, wrappedReducer);
+		case "LOAD_STATE": return loadStateOperation(document, parsedAction.input);
+		default: return document;
+	}
+}
+/**
+* Processes an UNDO or REDO action.
+*
+* @param document The current state of the document.
+* @param action The action being applied to the document.
+* @param skip The number of operations to skip before applying the action.
+* @returns The updated document, calculated skip value and transformed action (if applied).
+*/
+function processUndoRedo(document, action, skip, protocolVersion = 1) {
+	switch (action.type) {
+		case "UNDO":
+			if (protocolVersion >= 2) return undoOperationV2(document, action, skip);
+			return undoOperation(document, action, skip);
+		case "REDO": return redoOperation(document, action, skip);
+		default: return {
+			document,
+			action,
+			skip,
+			reuseLastOperationIndex: false
+		};
+	}
+}
+function processSkipOperation(document, action, customReducer, skipValue, reuseOperationResultingState = false, resultingStateParser = parseResultingState) {
+	const scope = action.scope;
+	const scopeOperations = document.operations[scope];
+	if (!scopeOperations) return document;
+	const latestOperation = scopeOperations.at(-1);
+	if (!latestOperation) return document;
+	const documentOperations = garbageCollectDocumentOperations({
+		...document.operations,
+		[scope]: skipHeaderOperations(scopeOperations, latestOperation)
+	});
+	let scopeState = void 0;
+	const lastRemainingOperation = documentOperations[scope]?.at(-1);
+	if (reuseOperationResultingState && lastRemainingOperation?.resultingState) scopeState = resultingStateParser(lastRemainingOperation.resultingState);
+	else {
+		const { state } = replayOperations(document.initialState, documentOperations, customReducer, document.header, void 0, void 0, void 0, {
+			reuseOperationResultingState,
+			operationResultingStateParser: resultingStateParser,
+			skipIndexValidation: true
+		});
+		scopeState = state[scope];
+	}
+	return {
+		...document,
+		state: {
+			...document.state,
+			[scope]: scopeState
+		},
+		operations: garbageCollectDocumentOperations({ ...document.operations })
+	};
+}
+function processUndoOperation(document, scope, customReducer, reuseOperationResultingState = false, resultingStateParser = parseResultingState) {
+	const scopeOperations = document.operations[scope];
+	if (!scopeOperations) return document;
+	const sortedOperations = sortOperations([...scopeOperations]);
+	sortedOperations.pop();
+	const documentOperations = garbageCollectDocumentOperations({ ...document.operations });
+	const documentScopeOps = documentOperations[scope];
+	if (!documentScopeOps) return document;
+	const clearedOperations = [...documentScopeOps];
+	const diff = diffOperations(garbageCollect(sortedOperations), clearedOperations);
+	const doc = replayOperations(document.initialState, documentOperations, customReducer, document.header, void 0, void 0, void 0, {
+		reuseOperationResultingState,
+		operationResultingStateParser: resultingStateParser
+	});
+	const clipboard = sortOperations([...document.clipboard, ...diff].filter((op) => op.action.type !== "NOOP")).reverse();
+	return {
+		...doc,
+		clipboard
+	};
+}
+/**
+* Base document reducer that wraps a custom document reducer and handles
+* document-level actions such as undo, redo, prune, and set name.
+*
+* @template TGlobalState - The type of the state of the custom reducer.
+* @template TAction - The type of the actions of the custom reducer.
+* @param state - The current state of the document.
+* @param action - The action object to apply to the state.
+* @param customReducer - The custom reducer that implements the application logic
+* specific to the document's state.
+* @returns The new state of the document.
+*/
+function baseReducer(document, action, customReducer, dispatch, options = {}) {
+	const { skip, ignoreSkipOperations = false, reuseOperationResultingState = false, operationResultingStateParser, pruneOnSkip = true, branch = "main" } = options;
+	let _action = actionFromAction(action);
+	let skipValue = skip ?? options.replayOptions?.operation.skip ?? 0;
+	let newDocument = { ...document };
+	let reuseLastOperationIndex = false;
+	const shouldProcessSkipOperation = !ignoreSkipOperations && skipValue > 0;
+	if (isUndoRedo(_action)) {
+		const { skip: calculatedSkip, action: transformedAction, document: processedDocument, reuseLastOperationIndex: reuseIndex } = processUndoRedo(document, _action, skipValue, options.protocolVersion ?? 1);
+		_action = transformedAction;
+		skipValue = calculatedSkip;
+		newDocument = processedDocument;
+		reuseLastOperationIndex = reuseIndex;
+	} else newDocument = {
+		...newDocument,
+		clipboard: []
+	};
+	if (isDocumentAction(_action)) newDocument = _baseReducer(newDocument, _action, customReducer);
+	const operationContext = {
+		documentId: document.header.id,
+		scope: _action.scope,
+		branch
+	};
+	newDocument = updateDocument(newDocument, _action, reuseLastOperationIndex, skipValue, operationContext, options.replayOptions?.operation, options.skipIndexValidation);
+	const protocolVersion = options.protocolVersion ?? 1;
+	if (isUndo(action) && protocolVersion < 2) return processUndoOperation(newDocument, action.scope, customReducer);
+	const isNoopWithSkip = _action.type === "NOOP" && skipValue > 0;
+	if ((isUndo(action) || isNoopWithSkip) && protocolVersion >= 2) {
+		const scope = _action.scope;
+		const opsToReplay = garbageCollectV2(sortOperations([...newDocument.operations[scope] || []])).filter((op) => op.action.type !== "NOOP");
+		const replayOps = {
+			...newDocument.operations,
+			[scope]: opsToReplay
+		};
+		return {
+			...replayOperations(newDocument.initialState, replayOps, customReducer, newDocument.header, dispatch, baseReducer, {}, { skipIndexValidation: true }),
+			operations: newDocument.operations,
+			clipboard: []
+		};
+	}
+	if (shouldProcessSkipOperation) {
+		const processed = processSkipOperation(newDocument, _action, customReducer, skipValue, reuseOperationResultingState, operationResultingStateParser);
+		if (!pruneOnSkip) newDocument = {
+			...processed,
+			operations: newDocument.operations
+		};
+		else newDocument = processed;
+	}
+	newDocument = create(newDocument, (draft) => {
+		try {
+			const newState = customReducer(draft.state, _action, dispatch);
+			if (newState) unsafe(() => {
+				draft.state = castDraft(newState);
+			});
+		} catch (error) {
+			const actionScopeOps = newDocument.operations[_action.scope];
+			if (!actionScopeOps) throw new Error(`No operations found for scope: ${_action.scope}`);
+			const lastOperationIndex = actionScopeOps.length - 1;
+			const draftScopeOps = draft.operations[_action.scope];
+			if (!draftScopeOps) throw new Error(`No operations found in draft for scope: ${_action.scope}`);
+			draftScopeOps[lastOperationIndex].error = error.message;
+			draftScopeOps[lastOperationIndex].skip = 0;
+			if (shouldProcessSkipOperation) {
+				draft.state = castDraft({ ...document.state });
+				const documentScopeOps = document.operations[_action.scope];
+				if (!documentScopeOps) throw new Error(`No operations found for scope: ${_action.scope}`);
+				draft.operations = castDraft({
+					...document.operations,
+					[_action.scope]: [...documentScopeOps, { ...draftScopeOps[lastOperationIndex] }]
+				});
+			}
+		}
+	});
+	if ([
+		"UNDO",
+		"REDO",
+		"PRUNE"
+	].includes(_action.type)) return newDocument;
+	const scope = _action.scope || "global";
+	let hash = hashDocumentStateForScope(newDocument, scope);
+	if (options.replayOptions?.operation.hash && options.replayOptions.operation.hash !== "") hash = options.replayOptions.operation.hash;
+	const lastOperation = newDocument.operations[scope]?.at(-1);
+	if (lastOperation) {
+		lastOperation.hash = hash;
+		if (reuseOperationResultingState) lastOperation.resultingState = JSON.stringify(newDocument.state[scope]);
+	}
+	return newDocument;
+}
+/**
+* Helper function to create a document model reducer.
+*
+* @remarks
+* This function creates a new reducer that wraps the provided `reducer` with
+* `documentReducer`, adding support for document actions:
+*   - `SET_NAME`
+*   - `UNDO`
+*   - `REDO`
+*   - `PRUNE`
+*
+* It also updates the document-related attributes on every operation.
+*
+* @param reducer - The custom reducer to wrap.
+* @param documentReducer - The document reducer to use.
+*
+* @returns The new reducer.
+*/
+function createReducer(stateReducer, documentReducer = baseReducer) {
+	const reducer = (document, action, dispatch, options) => {
+		return documentReducer(document, action, stateReducer, dispatch, options);
+	};
+	return reducer;
+}
+function pruneOperation(document, input, wrappedReducer) {
+	const operations = document.operations.global;
+	if (!operations) throw new Error("No global operations found");
+	let { start, end } = input;
+	start = start || 0;
+	end = end || operations.length;
+	const actionsToPrune = operations.slice(start, end);
+	const actionsToKeepStart = operations.slice(0, start);
+	const actionsToKeepEnd = operations.slice(end);
+	const newDocument = replayOperations(document.initialState, {
+		...document.operations,
+		global: actionsToKeepStart.concat(actionsToPrune)
+	}, wrappedReducer, document.header);
+	const newState = newDocument.state;
+	const name = newDocument.header.name;
+	const loadStateIndex = actionsToKeepStart.length;
+	const loadStateTimestamp = actionsToKeepStart.length ? actionsToKeepStart[actionsToKeepStart.length - 1].timestampUtcMs : actionsToKeepEnd.length ? actionsToKeepEnd[0].timestampUtcMs : (/* @__PURE__ */ new Date()).toISOString();
+	const action = loadState({
+		name,
+		...newState
+	}, actionsToPrune.length);
+	return replayOperations(document.initialState, {
+		...document.operations,
+		global: [
+			...actionsToKeepStart,
+			{
+				skip: 0,
+				...action,
+				action,
+				timestampUtcMs: loadStateTimestamp,
+				index: loadStateIndex,
+				hash: hashDocumentStateForScope({ state: newState }, "global")
+			},
+			...actionsToKeepEnd.map((action, index) => ({
+				...action,
+				index: loadStateIndex + index + 1
+			}))
+		]
+	}, wrappedReducer, document.header);
+}
+//#endregion
+//#region document-model/validation.ts
+/**
+* Reserved operation names from base reducer (core/actions.ts).
+* These names cannot be used for custom operations.
+*/
+const RESERVED_OPERATION_NAMES = [
+	"UNDO",
+	"REDO",
+	"PRUNE",
+	"LOAD_STATE",
+	"SET_NAME",
+	"NOOP"
+];
+/**
+* Check if name conflicts with base reducer actions (case-insensitive).
+*/
+function isReservedOperationName(name) {
+	return RESERVED_OPERATION_NAMES.includes(name.toUpperCase());
+}
+/**
+* Get all operation names from all modules in the latest specification.
+* Returns names in uppercase for case-insensitive comparison.
+*/
+function getAllOperationNames(state, excludeOperationId) {
+	const latestSpec = state.specifications[state.specifications.length - 1];
+	if (!latestSpec) return [];
+	const names = [];
+	for (const module of latestSpec.modules) for (const operation of module.operations) {
+		if (excludeOperationId && operation.id === excludeOperationId) continue;
+		if (operation.name) names.push(operation.name.toUpperCase());
+	}
+	return names;
+}
+/**
+* Validate operation name is not reserved or duplicate. Throws on failure.
+*
+* @param name - The operation name to validate
+* @param state - The document model global state
+* @param excludeOperationId - Optional operation ID to exclude (for rename validation)
+* @throws Error if the name is reserved or a duplicate
+*/
+function validateOperationName(name, state, excludeOperationId) {
+	if (!name) return;
+	const upperName = name.toUpperCase();
+	if (isReservedOperationName(name)) throw new Error(`Operation name "${name}" is reserved. Please use a different name.`);
+	if (getAllOperationNames(state, excludeOperationId).includes(upperName)) throw new Error(`Operation name "${name}" is already used by another operation. Operation names must be unique across all modules.`);
+}
+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 = `${pascalCase(documentName)}${pascalCase(scope)}State`;
+	if (!new RegExp(`\\btype\\s+${expectedTypeName}(?:\\s|\\{|@|$)`).test(schema)) errors.push({
+		message: `Invalid state schema name. Expected type ${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;
+}
+function validateOperations(operations) {
+	const errors = [];
+	const scopes = Object.keys(operations);
+	for (const scope of scopes) {
+		const scopeOperations = operations[scope];
+		if (!scopeOperations) continue;
+		const ops = scopeOperations.sort((a, b) => a.index - b.index);
+		let opIndex = -1;
+		for (let i = 0; i < ops.length; i++) {
+			opIndex = opIndex + 1 + ops[i].skip;
+			if (ops[i].index !== opIndex) errors.push({
+				message: `Invalid operation index ${ops[i].index} at position ${i}`,
+				details: {
+					position: i,
+					operation: ops[i],
+					scope: ops[i].action.scope
+				}
+			});
+		}
+	}
+	return errors;
+}
+//#endregion
+//#region document-model/reducers.ts
+function sorter(order) {
+	const mapping = {};
+	order.forEach((key, index) => mapping[key] = index);
+	return (a, b) => (mapping[b.id] || 999999) - (mapping[a.id] || 999999);
+}
+const documentModelHeaderReducer = {
+	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 documentModelModuleReducer = {
+	addModuleOperation(state, action) {
+		state.specifications[state.specifications.length - 1].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) {
+		state.specifications[state.specifications.length - 1].modules.sort(sorter(action.input.order));
+	}
+};
+const documentModelOperationErrorReducer = {
+	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(sorter(action.input.order));
+	}
+};
+const documentModelOperationExampleReducer = {
+	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(sorter(action.input.order));
+	}
+};
+const documentModelOperationReducer = {
+	addOperationOperation(state, action) {
+		validateOperationName(action.input.name, state);
+		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) {
+		if (action.input.name) validateOperationName(action.input.name, state, action.input.id);
+		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(sorter(action.input.order));
+	}
+};
+const documentModelStateSchemaReducer = {
+	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(sorter(action.input.order));
+		else throw new Error(`Invalid scope: ${action.input.scope}`);
+	}
+};
+const documentModelVersioningReducer = {
+	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) {
+		const latestSpec = state.specifications[state.specifications.length - 1];
+		const copiedModules = latestSpec.modules.map((module) => ({
+			...module,
+			operations: module.operations.map((op) => ({
+				...op,
+				errors: op.errors.map((err) => ({ ...err })),
+				examples: op.examples.map((ex) => ({ ...ex }))
+			}))
+		}));
+		const copiedState = {
+			global: {
+				...latestSpec.state.global,
+				examples: latestSpec.state.global.examples.map((ex) => ({ ...ex }))
+			},
+			local: {
+				...latestSpec.state.local,
+				examples: latestSpec.state.local.examples.map((ex) => ({ ...ex }))
+			}
+		};
+		const newSpec = {
+			version: latestSpec.version + 1,
+			changeLog: [],
+			state: copiedState,
+			modules: copiedModules
+		};
+		state.specifications.push(newSpec);
+	}
+};
+const documentModelStateReducer = (state, action) => {
+	if (isDocumentAction(action)) return state;
+	switch (action.type) {
+		case "SET_MODEL_NAME":
+			SetModelNameInputSchema().parse(action.input);
+			documentModelHeaderReducer.setModelNameOperation(state.global, action);
+			break;
+		case "SET_MODEL_ID":
+			SetModelIdInputSchema().parse(action.input);
+			documentModelHeaderReducer.setModelIdOperation(state.global, action);
+			break;
+		case "SET_MODEL_EXTENSION":
+			SetModelExtensionInputSchema().parse(action.input);
+			documentModelHeaderReducer.setModelExtensionOperation(state.global, action);
+			break;
+		case "SET_MODEL_DESCRIPTION":
+			SetModelDescriptionInputSchema().parse(action.input);
+			documentModelHeaderReducer.setModelDescriptionOperation(state.global, action);
+			break;
+		case "SET_AUTHOR_NAME":
+			SetAuthorNameInputSchema().parse(action.input);
+			documentModelHeaderReducer.setAuthorNameOperation(state.global, action);
+			break;
+		case "SET_AUTHOR_WEBSITE":
+			SetAuthorWebsiteInputSchema().parse(action.input);
+			documentModelHeaderReducer.setAuthorWebsiteOperation(state.global, action);
+			break;
+		case "ADD_CHANGE_LOG_ITEM":
+			AddChangeLogItemInputSchema().parse(action.input);
+			documentModelVersioningReducer.addChangeLogItemOperation(state.global, action);
+			break;
+		case "UPDATE_CHANGE_LOG_ITEM":
+			UpdateChangeLogItemInputSchema().parse(action.input);
+			documentModelVersioningReducer.updateChangeLogItemOperation(state.global, action);
+			break;
+		case "DELETE_CHANGE_LOG_ITEM":
+			DeleteChangeLogItemInputSchema().parse(action.input);
+			documentModelVersioningReducer.deleteChangeLogItemOperation(state.global, action);
+			break;
+		case "REORDER_CHANGE_LOG_ITEMS":
+			ReorderChangeLogItemsInputSchema().parse(action.input);
+			documentModelVersioningReducer.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");
+			documentModelVersioningReducer.releaseNewVersionOperation(state.global, action);
+			break;
+		case "ADD_MODULE":
+			AddModuleInputSchema().parse(action.input);
+			documentModelModuleReducer.addModuleOperation(state.global, action);
+			break;
+		case "SET_MODULE_NAME":
+			SetModuleNameInputSchema().parse(action.input);
+			documentModelModuleReducer.setModuleNameOperation(state.global, action);
+			break;
+		case "SET_MODULE_DESCRIPTION":
+			SetModuleDescriptionInputSchema().parse(action.input);
+			documentModelModuleReducer.setModuleDescriptionOperation(state.global, action);
+			break;
+		case "DELETE_MODULE":
+			DeleteModuleInputSchema().parse(action.input);
+			documentModelModuleReducer.deleteModuleOperation(state.global, action);
+			break;
+		case "REORDER_MODULES":
+			ReorderModulesInputSchema().parse(action.input);
+			documentModelModuleReducer.reorderModulesOperation(state.global, action);
+			break;
+		case "ADD_OPERATION_ERROR":
+			AddOperationErrorInputSchema().parse(action.input);
+			documentModelOperationErrorReducer.addOperationErrorOperation(state.global, action);
+			break;
+		case "SET_OPERATION_ERROR_CODE":
+			SetOperationErrorCodeInputSchema().parse(action.input);
+			documentModelOperationErrorReducer.setOperationErrorCodeOperation(state.global, action);
+			break;
+		case "SET_OPERATION_ERROR_NAME":
+			SetOperationErrorNameInputSchema().parse(action.input);
+			documentModelOperationErrorReducer.setOperationErrorNameOperation(state.global, action);
+			break;
+		case "SET_OPERATION_ERROR_DESCRIPTION":
+			SetOperationErrorDescriptionInputSchema().parse(action.input);
+			documentModelOperationErrorReducer.setOperationErrorDescriptionOperation(state.global, action);
+			break;
+		case "SET_OPERATION_ERROR_TEMPLATE":
+			SetOperationErrorTemplateInputSchema().parse(action.input);
+			documentModelOperationErrorReducer.setOperationErrorTemplateOperation(state.global, action);
+			break;
+		case "DELETE_OPERATION_ERROR":
+			DeleteOperationErrorInputSchema().parse(action.input);
+			documentModelOperationErrorReducer.deleteOperationErrorOperation(state.global, action);
+			break;
+		case "REORDER_OPERATION_ERRORS":
+			ReorderOperationErrorsInputSchema().parse(action.input);
+			documentModelOperationErrorReducer.reorderOperationErrorsOperation(state.global, action);
+			break;
+		case "ADD_OPERATION_EXAMPLE":
+			AddOperationExampleInputSchema().parse(action.input);
+			documentModelOperationExampleReducer.addOperationExampleOperation(state.global, action);
+			break;
+		case "UPDATE_OPERATION_EXAMPLE":
+			UpdateOperationExampleInputSchema().parse(action.input);
+			documentModelOperationExampleReducer.updateOperationExampleOperation(state.global, action);
+			break;
+		case "DELETE_OPERATION_EXAMPLE":
+			DeleteOperationExampleInputSchema().parse(action.input);
+			documentModelOperationExampleReducer.deleteOperationExampleOperation(state.global, action);
+			break;
+		case "REORDER_OPERATION_EXAMPLES":
+			ReorderOperationExamplesInputSchema().parse(action.input);
+			documentModelOperationExampleReducer.reorderOperationExamplesOperation(state.global, action);
+			break;
+		case "ADD_OPERATION":
+			AddOperationInputSchema().parse(action.input);
+			documentModelOperationReducer.addOperationOperation(state.global, action);
+			break;
+		case "SET_OPERATION_NAME":
+			SetOperationNameInputSchema().parse(action.input);
+			documentModelOperationReducer.setOperationNameOperation(state.global, action);
+			break;
+		case "SET_OPERATION_SCOPE":
+			SetOperationScopeInputSchema().parse(action.input);
+			documentModelOperationReducer.setOperationScopeOperation(state.global, action);
+			break;
+		case "SET_OPERATION_SCHEMA":
+			SetOperationSchemaInputSchema().parse(action.input);
+			documentModelOperationReducer.setOperationSchemaOperation(state.global, action);
+			break;
+		case "SET_OPERATION_DESCRIPTION":
+			SetOperationDescriptionInputSchema().parse(action.input);
+			documentModelOperationReducer.setOperationDescriptionOperation(state.global, action);
+			break;
+		case "SET_OPERATION_TEMPLATE":
+			SetOperationTemplateInputSchema().parse(action.input);
+			documentModelOperationReducer.setOperationTemplateOperation(state.global, action);
+			break;
+		case "SET_OPERATION_REDUCER":
+			SetOperationReducerInputSchema().parse(action.input);
+			documentModelOperationReducer.setOperationReducerOperation(state.global, action);
+			break;
+		case "MOVE_OPERATION":
+			MoveOperationInputSchema().parse(action.input);
+			documentModelOperationReducer.moveOperationOperation(state.global, action);
+			break;
+		case "DELETE_OPERATION":
+			DeleteOperationInputSchema().parse(action.input);
+			documentModelOperationReducer.deleteOperationOperation(state.global, action);
+			break;
+		case "REORDER_MODULE_OPERATIONS":
+			ReorderModuleOperationsInputSchema().parse(action.input);
+			documentModelOperationReducer.reorderModuleOperationsOperation(state.global, action);
+			break;
+		case "SET_STATE_SCHEMA":
+			SetStateSchemaInputSchema().parse(action.input);
+			documentModelStateSchemaReducer.setStateSchemaOperation(state.global, action);
+			break;
+		case "SET_INITIAL_STATE":
+			SetInitialStateInputSchema().parse(action.input);
+			documentModelStateSchemaReducer.setInitialStateOperation(state.global, action);
+			break;
+		case "ADD_STATE_EXAMPLE":
+			AddStateExampleInputSchema().parse(action.input);
+			documentModelStateSchemaReducer.addStateExampleOperation(state.global, action);
+			break;
+		case "UPDATE_STATE_EXAMPLE":
+			UpdateStateExampleInputSchema().parse(action.input);
+			documentModelStateSchemaReducer.updateStateExampleOperation(state.global, action);
+			break;
+		case "DELETE_STATE_EXAMPLE":
+			DeleteStateExampleInputSchema().parse(action.input);
+			documentModelStateSchemaReducer.deleteStateExampleOperation(state.global, action);
+			break;
+		case "REORDER_STATE_EXAMPLES":
+			ReorderStateExamplesInputSchema().parse(action.input);
+			documentModelStateSchemaReducer.reorderStateExamplesOperation(state.global, action);
+			break;
+		default: return state;
+	}
+};
+const documentModelReducer = createReducer(documentModelStateReducer);
+//#endregion
+//#region document-model/files.ts
+function createZip(document) {
+	const zip = new JSZip();
+	const header = document.header;
+	zip.file("header.json", JSON.stringify(header, null, 2));
+	zip.file("state.json", JSON.stringify(document.initialState || {}, null, 2));
+	zip.file("current-state.json", JSON.stringify(document.state || {}, null, 2));
+	zip.file("operations.json", JSON.stringify(filterDocumentOperationsResultingState(document.operations), null, 2));
+	return zip;
+}
+/**
+* Creates a minimal ZIP backup from strand data.
+* Used when the full document is not available (e.g., in onOperations handler).
+* Creates a ZIP with minimal header and empty operations.
+*/
+function createMinimalZip(data) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const header = {
+		id: data.documentId,
+		sig: {
+			publicKey: {},
+			nonce: ""
+		},
+		documentType: data.documentType,
+		createdAtUtcIso: now,
+		slug: data.name,
+		name: data.name,
+		branch: data.branch,
+		revision: {},
+		lastModifiedAtUtcIso: now
+	};
+	const zip = new JSZip();
+	zip.file("header.json", JSON.stringify(header, null, 2));
+	zip.file("state.json", JSON.stringify(data.state, null, 2));
+	zip.file("current-state.json", JSON.stringify(data.state, null, 2));
+	zip.file("operations.json", JSON.stringify({}, null, 2));
+	return zip;
+}
+async function baseSaveToFileHandle(document, input) {
+	const blob = await createZip(document).generateAsync({ type: "blob" });
+	const writable = await input.createWritable();
+	await writable.write(blob);
+	await writable.close();
+}
+async function loadFromZip(zip, reducer, options) {
+	const initialStateZip = zip.file("state.json");
+	if (!initialStateZip) throw new Error("Initial state not found");
+	const initialStateStr = await initialStateZip.async("string");
+	const initialState = JSON.parse(initialStateStr);
+	const headerZip = zip.file("header.json");
+	if (!headerZip) throw new Error("Document header not found - file format may be outdated");
+	const header = JSON.parse(await headerZip.async("string"));
+	const operationsZip = zip.file("operations.json");
+	if (!operationsZip) throw new Error("Operations history not found");
+	const clearedOperations = garbageCollectDocumentOperations(JSON.parse(await operationsZip.async("string")));
+	const operationsError = validateOperations(clearedOperations);
+	if (operationsError.length) {
+		const errorMessages = operationsError.map((err) => err.message);
+		throw new Error(errorMessages.join("\n"));
+	}
+	return replayDocument(initialState, clearedOperations, reducer, header, void 0, {}, options);
+}
+async function baseLoadFromInput(input, reducer, options) {
+	const zip = new JSZip();
+	await zip.loadAsync(input);
+	return loadFromZip(zip, reducer, options);
+}
+const documentModelLoadFromInput = (input) => {
+	return baseLoadFromInput(input, documentModelReducer);
+};
+const documentModelSaveToFileHandle = (document, input) => {
+	return baseSaveToFileHandle(document, input);
+};
+function writeFileBrowser(path, name, stream) {
+	throw FileSystemError;
+}
+function readFileBrowser(path) {
+	throw FileSystemError;
+}
+function fetchFileBrowser(url) {
+	throw FileSystemError;
+}
+const getFileBrowser = async (file) => {
+	return readFileBrowser(file);
+};
+//#endregion
+//#region document-model/state.ts
+/**
+* Creates a default PHAuthState
+*/
+function defaultAuthState() {
+	return {};
+}
+/**
+* Creates a default PHDocumentState
+*/
+function defaultDocumentState() {
+	return {
+		version: 0,
+		hash: {
+			algorithm: HASH_ALGORITHM_SHA1,
+			encoding: HASH_ENCODING_BASE64
+		}
+	};
+}
+/**
+* Creates a default PHBaseState with auth and document properties
+*/
+function defaultBaseState() {
+	return {
+		auth: defaultAuthState(),
+		document: defaultDocumentState()
+	};
+}
+/**
+* Creates a PHAuthState with the given properties
+*/
+function createAuthState(auth) {
+	return {
+		...defaultAuthState(),
+		...auth
+	};
+}
+/**
+* Creates a PHDocumentState with the given properties
+*/
+function createDocumentState(document) {
+	return {
+		...defaultDocumentState(),
+		...document
+	};
+}
+/**
+* Creates a PHBaseState with the given auth and document properties
+*/
+function createBaseState(auth, document) {
+	return {
+		auth: createAuthState(auth),
+		document: createDocumentState(document)
+	};
+}
+function defaultGlobalState() {
+	return {
+		...defaultBaseState(),
+		author: {
+			name: "",
+			website: ""
+		},
+		description: "",
+		extension: "",
+		id: "",
+		name: "",
+		specifications: []
+	};
+}
+function defaultLocalState() {
+	return {};
+}
+function defaultPHState() {
+	return {
+		...defaultBaseState(),
+		global: defaultGlobalState(),
+		local: defaultLocalState()
+	};
+}
+function createGlobalState(state) {
+	return {
+		...defaultGlobalState(),
+		...state || {}
+	};
+}
+function createLocalState(state) {
+	return {
+		...defaultLocalState(),
+		...state || {}
+	};
+}
+function createState(baseState, globalState, localState) {
+	return {
+		...createBaseState(baseState?.auth, baseState?.document),
+		global: createGlobalState(globalState),
+		local: createLocalState(localState)
+	};
+}
+//#endregion
+export { AddChangeLogItemInputSchema, AddModuleInputSchema, AddOperationErrorInputSchema, AddOperationExampleInputSchema, AddOperationInputSchema, AddStateExampleInputSchema, AuthorSchema, BaseDocumentHeaderSchema, BaseDocumentStateSchema, CodeExampleSchema, DeleteChangeLogItemInputSchema, DeleteModuleInputSchema, DeleteOperationErrorInputSchema, DeleteOperationExampleInputSchema, DeleteOperationInputSchema, DeleteStateExampleInputSchema, DocumentActionSchema, DocumentFileSchema, DocumentModelGlobalStateSchema, DocumentModelHeaderSchema, DocumentModelInputSchema, DocumentModelPHStateSchema, DocumentModelSchema, DocumentSpecificationSchema, FileSystemError, HASH_ALGORITHM_SHA1, HASH_ALGORITHM_SHA256, HASH_ALGORITHM_SHA512, HASH_ENCODING_BASE64, HASH_ENCODING_HEX, HashMismatchError, IntegrityIssueSubType, IntegrityIssueType, InvalidActionInputError, InvalidActionInputZodError, LoadStateActionInputSchema, LoadStateActionSchema, LoadStateActionStateInputSchema, Load_StateSchema, ModuleSchema, MoveOperationInputSchema, OperationErrorSchema, OperationScopeSchema, OperationSpecificationSchema, PruneActionInputSchema, PruneActionSchema, PruneSchema, RESERVED_OPERATION_NAMES, RedoActionInputSchema, RedoActionSchema, RedoSchema, ReorderChangeLogItemsInputSchema, ReorderModuleOperationsInputSchema, ReorderModulesInputSchema, ReorderOperationErrorsInputSchema, ReorderOperationExamplesInputSchema, ReorderStateExamplesInputSchema, ScopeStateSchema, SetAuthorNameInputSchema, SetAuthorWebsiteInputSchema, SetInitialStateInputSchema, SetModelDescriptionInputSchema, SetModelExtensionInputSchema, SetModelIdInputSchema, SetModelNameInputSchema, SetModuleDescriptionInputSchema, SetModuleNameInputSchema, SetNameActionInputSchema, SetNameActionSchema, SetOperationDescriptionInputSchema, SetOperationErrorCodeInputSchema, SetOperationErrorDescriptionInputSchema, SetOperationErrorNameInputSchema, SetOperationErrorTemplateInputSchema, SetOperationNameInputSchema, SetOperationReducerInputSchema, SetOperationSchemaInputSchema, SetOperationScopeInputSchema, SetOperationTemplateInputSchema, SetStateSchemaInputSchema, Set_NameSchema, StateSchema, UndoActionInputSchema, UndoActionSchema, UndoSchema, UpdateChangeLogItemInputSchema, UpdateOperationExampleInputSchema, UpdateStateExampleInputSchema, ab2hex, actionContext, actionFromAction, actionSigner, actions, addChangeLogItem, addModule, addOperation, addOperationError, addOperationExample, addStateExample, addUndo, assertIsDocumentModelDocument, assertIsDocumentModelState, attachBranch, baseActions, baseCreateDocument, baseLoadFromInput, baseReducer, baseSaveToFileHandle, buildOperationSignature, buildOperationSignatureMessage, buildOperationSignatureParams, buildSignedAction, checkCleanedOperationsIntegrity, checkOperationsIntegrity, createAction, createAuthState, createBaseState, createDocumentState, createGlobalState, createLocalState, createMinimalZip, createPresignedHeader, createReducer, createSignedHeader, createSignedHeaderForSigner, createState, createVerificationSigner, createZip, defaultAuthState, defaultBaseState, defaultDocumentState, defaultGlobalState, defaultLocalState, defaultPHState, definedNonNullAnySchema, deleteChangeLogItem, deleteModule, deleteOperation, deleteOperationError, deleteOperationExample, deleteStateExample, deriveOperationId, diffOperations, documentModelActions, documentModelDocumentType, documentModelFileExtension, documentModelGlobalState, documentModelHeaderReducer, documentModelInitialGlobalState, documentModelInitialLocalState, documentModelLoadFromInput, documentModelModuleReducer, documentModelOperationErrorReducer, documentModelOperationExampleReducer, documentModelOperationReducer, documentModelReducer, documentModelSaveToFileHandle, documentModelStateReducer, documentModelStateSchemaReducer, documentModelVersioningReducer, fetchFileBrowser, filterDocumentOperationsResultingState, filterDuplicatedOperations, garbageCollect, garbageCollectDocumentOperations, garbageCollectV2, generateId, getAllOperationNames, getDocumentLastModified, getFileBrowser, getUnixTimestamp, groupOperationsByScope, hashBrowser, hashDocumentStateForScope, hex2ab, isDefinedNonNullAny, isDocumentAction, isDocumentModelDocument, isDocumentModelState, isNoopOperation, isReservedOperationName, isUndo, isUndoRedo, loadState, loadStateOperation, mapSkippedOperations, mapSkippedOperationsV2, merge, moveOperation, nextSkipNumber, noop, operationExampleCreators, operationFromAction, operationFromOperation, operationWithContext, operationsAreEqual, parseResultingState, precedes, prepareOperations, processUndoRedo, prune, pruneOperation, readFileBrowser, readOnly, redo, redoOperation, releaseNewVersion, removeExistingOperations, reorderChangeLogItems, reorderModuleOperations, reorderModules, reorderOperationErrors, reorderOperationExamples, reorderStateExamples, replayDocument, replayOperations, reshuffleByTimestamp, reshuffleByTimestampAndIndex, setAuthorName, setAuthorWebsite, setInitialState, setModelDescription, setModelExtension, setModelId, setModelName, setModuleDescription, setModuleName, setName, setNameOperation, setOperationDescription, setOperationErrorCode, setOperationErrorDescription, setOperationErrorName, setOperationErrorTemplate, setOperationName, setOperationReducer, setOperationSchema, setOperationScope, setOperationTemplate, setStateSchema, sign, skipHeaderOperations, sortMappedOperations, sortOperations, split, undo, undoOperation, undoOperationV2, updateChangeLogItem, updateDocument, updateHeaderRevision, updateOperationExample, updateStateExample, validateHeader, validateInitialState, validateModule, validateModuleOperation, validateModules, validateOperationName, validateOperations, validateStateSchemaName, verify, verifyOperationSignature, writeFileBrowser };
+
 //# sourceMappingURL=index.js.map