@powerhousedao/codegen 6.0.0-dev.14 → 6.0.0-dev.140

package/dist/templates-DBvz_qPL.mjs

@@ -0,0 +1,4611 @@
+import { getActionInputName, getActionInputTypeNames, getActionType, getActionTypeName } from "./src/name-builders/index.mjs";
+import { camelCase, capitalCase, constantCase, kebabCase, pascalCase } from "change-case";
+import { css, html, js, json, md, ts, tsx, yaml } from "@tmpl/core";
+//#region src/templates/app/components/CreateDocument.ts
+const createDocumentFileTemplate = tsx`
+import type { VetraDocumentModelModule } from "@powerhousedao/reactor-browser";
+import {
+  showCreateDocumentModal,
+  useAllowedDocumentModelModules,
+} from "@powerhousedao/reactor-browser";
+
+/**
+ * Document creation UI component.
+ * Displays available document types as clickable buttons.
+ */
+export function CreateDocument() {
+  const allowedDocumentModelModules = useAllowedDocumentModelModules();
+
+  return (
+    <div>
+      {/* Customize section title here */}
+      <h3 className="mb-3 mt-4 text-sm font-bold text-gray-600">
+        Create document
+      </h3>
+      {/* Customize layout by changing flex-wrap, gap, or grid layout */}
+      <div className="flex w-full flex-wrap gap-4">
+        {allowedDocumentModelModules?.map((documentModelModule) => {
+          return (
+            <CreateDocumentButton
+              key={documentModelModule.documentModel.global.id}
+              documentModelModule={documentModelModule}
+            />
+          );
+        })}
+      </div>
+    </div>
+  );
+}
+
+type Props = {
+  documentModelModule: VetraDocumentModelModule;
+};
+function CreateDocumentButton({ documentModelModule }: Props) {
+  const documentType = documentModelModule.documentModel.global.id;
+  const documentModelName =
+    documentModelModule.documentModel.global.name || documentType;
+  const documentModelDescription =
+    documentModelModule.documentModel.global.description;
+  return (
+    <button
+      className="cursor-pointer rounded-md bg-gray-200 py-2 px-3 hover:bg-gray-300"
+      title={documentModelName}
+      aria-description={documentModelDescription}
+      onClick={() => showCreateDocumentModal(documentType)}
+    >
+      {documentModelName}
+    </button>
+  );
+}
+`.raw;
+//#endregion
+//#region src/templates/app/components/DriveContents.ts
+const appDriveContentsFileTemplate = () => tsx`
+import { CreateDocument } from "./CreateDocument.js";
+import { EmptyState } from "./EmptyState.js";
+import { Files } from "./Files.js";
+import { Folders } from "./Folders.js";
+import { NavigationBreadcrumbs } from "./NavigationBreadcrumbs.js";
+
+/** Shows the documents and folders in the selected drive */
+export function DriveContents() {
+  return (
+    <div className="space-y-6 px-6">
+      <NavigationBreadcrumbs />
+      <Folders />
+      <Files />
+      <EmptyState />
+      <CreateDocument />
+    </div>
+  );
+}
+
+
+`.raw;
+//#endregion
+//#region src/templates/app/components/DriveExplorer.ts
+const driveExplorerFileTemplate = tsx`
+import type { EditorProps } from "document-model";
+import { FolderTree } from "./FolderTree.js";
+import { DriveContents } from "./DriveContents.js";
+
+/**
+ * Main drive explorer component with sidebar navigation and content area.
+ * Layout: Left sidebar (folder tree) + Right content area (files/folders + document editor)
+ */
+export function DriveExplorer({ children }: EditorProps) {
+  // if a document is selected then it's editor will be passed as children
+  const showDocumentEditor = !!children;
+
+  return (
+    <div className="flex h-full">
+      <FolderTree />
+      <div className="flex-1 overflow-y-auto p-4">
+        {/* Conditional rendering: Document editor or folder contents */}
+        {showDocumentEditor ? (
+          /* Document editor view */
+          children
+        ) : (
+          /* Folder contents view */
+          <DriveContents />
+        )}
+      </div>
+    </div>
+  );
+}
+`.raw;
+//#endregion
+//#region src/templates/app/components/EmptyState.ts
+const emptyStateFileTemplate = tsx`
+import { useNodesInSelectedDriveOrFolder } from "@powerhousedao/reactor-browser";
+
+/** Shows a message when the selected drive or folder is empty */
+export function EmptyState() {
+  const nodes = useNodesInSelectedDriveOrFolder();
+  const hasNodes = nodes.length > 0;
+  if (hasNodes) return null;
+
+  return (
+    <div className="py-12 text-center text-gray-500">
+      <p className="text-lg">This folder is empty</p>
+      <p className="mt-2 text-sm">Create your first document or folder below</p>
+    </div>
+  );
+}
+`.raw;
+//#endregion
+//#region src/templates/app/components/Files.ts
+const appFilesFileTemplate = () => tsx`
+import { FileItem } from "@powerhousedao/design-system/connect";
+import {
+  useNodesInSelectedDriveOrFolder,
+  isFileNodeKind,
+} from "@powerhousedao/reactor-browser";
+
+/** Shows the files in the selected drive or folder */
+export function Files() {
+  const nodes = useNodesInSelectedDriveOrFolder();
+  const fileNodes = nodes.filter((n) => isFileNodeKind(n));
+  const hasFiles = fileNodes.length > 0;
+
+  if (!hasFiles) return null;
+
+  return (
+    <div>
+      <h3 className="mb-2 text-sm font-semibold text-gray-600">Documents</h3>
+      <div className="flex flex-wrap gap-4">
+        {fileNodes.map((fileNode) => (
+          <FileItem key={fileNode.id} fileNode={fileNode} />
+        ))}
+      </div>
+    </div>
+  );
+}
+
+`.raw;
+//#endregion
+//#region src/templates/app/components/Folders.ts
+const appFoldersFileTemplate = () => tsx`
+import { FolderItem } from "@powerhousedao/design-system/connect";
+import {
+  useNodesInSelectedDriveOrFolder,
+  isFolderNodeKind,
+} from "@powerhousedao/reactor-browser";
+
+/** Shows the folders in the selected drive or folder */
+export function Folders() {
+  const nodes = useNodesInSelectedDriveOrFolder();
+  const folderNodes = nodes.filter((n) => isFolderNodeKind(n));
+  const hasFolders = folderNodes.length > 0;
+  if (!hasFolders) return null;
+
+  return (
+    <div>
+      <h3 className="mb-2 text-sm font-bold text-gray-600">Folders</h3>
+      <div className="flex flex-wrap gap-4">
+        {folderNodes.map((folderNode) => (
+          <FolderItem key={folderNode.id} folderNode={folderNode} />
+        ))}
+      </div>
+    </div>
+  );
+}
+`.raw;
+//#endregion
+//#region src/templates/app/components/FolderTree.ts
+const folderTreeFileTemplate = tsx`
+  import {
+  Sidebar,
+  SidebarProvider,
+  type SidebarNode,
+} from "@powerhousedao/document-engineering";
+import {
+  setSelectedNode,
+  useNodesInSelectedDrive,
+  useSelectedDrive,
+  useSelectedNode,
+} from "@powerhousedao/reactor-browser";
+import type { Node } from "@powerhousedao/shared/document-drive";
+import { useMemo } from "react";
+
+function buildSidebarNodes(
+  nodes: Node[],
+  parentId: string | null | undefined,
+): SidebarNode[] {
+  return nodes
+    .filter((n) => {
+      if (parentId == null) {
+        return n.parentFolder == null;
+      }
+      return n.parentFolder === parentId;
+    })
+    .map((node): SidebarNode => {
+      if (node.kind === "folder") {
+        return {
+          id: node.id,
+          title: node.name,
+          icon: "FolderClose" as const,
+          expandedIcon: "FolderOpen" as const,
+          children: buildSidebarNodes(nodes, node.id),
+        };
+      }
+      return {
+        id: node.id,
+        title: node.name,
+        icon: "File" as const,
+      };
+    });
+}
+
+function transformNodesToSidebarNodes(
+  nodes: Node[],
+  driveName: string,
+): SidebarNode[] {
+  return [
+    {
+      id: "root",
+      title: driveName,
+      icon: "Drive" as const,
+      children: buildSidebarNodes(nodes, null),
+    },
+  ];
+}
+
+/**
+ * Hierarchical folder tree navigation component using Sidebar from document-engineering.
+ * Displays folders and files in a tree structure with expand/collapse functionality, search, and resize support.
+ */
+export function FolderTree() {
+  const [selectedDrive] = useSelectedDrive();
+  const nodes = useNodesInSelectedDrive();
+  const selectedNode = useSelectedNode();
+  const driveName = selectedDrive.header.name;
+  // Transform Node[] to hierarchical SidebarNode structure
+  const sidebarNodes = useMemo(
+    () => transformNodesToSidebarNodes(nodes || [], driveName),
+    [nodes, driveName],
+  );
+
+  const handleActiveNodeChange = (node: SidebarNode) => {
+    // If root node is selected, pass undefined to match existing behavior
+    if (node.id === "root") {
+      setSelectedNode(undefined);
+    } else {
+      setSelectedNode(node.id);
+    }
+  };
+  // Map selectedNodeId to activeNodeId (use "root" when undefined)
+  const activeNodeId =
+    !selectedNode || selectedNode.id === selectedDrive.header.id
+      ? "root"
+      : selectedNode.id;
+
+  return (
+    <SidebarProvider nodes={sidebarNodes}>
+      <Sidebar
+        className="pt-1"
+        nodes={sidebarNodes}
+        activeNodeId={activeNodeId}
+        onActiveNodeChange={handleActiveNodeChange}
+        sidebarTitle="Drive Explorer"
+        showSearchBar={true}
+        resizable={true}
+        allowPinning={false}
+        showStatusFilter={false}
+        initialWidth={256}
+        defaultLevel={2}
+      />
+    </SidebarProvider>
+  );
+}
+`.raw;
+//#endregion
+//#region src/templates/app/components/NavigationBreadcrumbs.ts
+const driveExplorerNavigationBreadcrumbsFileTemplate = () => tsx`
+import { Breadcrumbs } from "@powerhousedao/design-system/connect";
+
+/** Shows the navigation breadcrumbs for the selected drive or folder */
+export function NavigationBreadcrumbs() {
+  return (
+    <div className="border-b border-gray-200 pb-3 space-y-3">
+      <Breadcrumbs />
+    </div>
+  );
+}
+`.raw;
+//#endregion
+//#region src/templates/app/config.ts
+const appConfigFileTemplate = (v) => ts`
+import type { PHAppConfig } from "@powerhousedao/reactor-browser";
+
+/** Editor config for the <%= pascalCaseAppName %> */
+export const editorConfig: PHAppConfig = {
+  isDragAndDropEnabled: ${v.isDragAndDropEnabledString},
+  allowedDocumentTypes: ${v.allowedDocumentTypesString}
+};
+`.raw;
+//#endregion
+//#region src/templates/app/editor.ts
+const appEditorFileTemplate = () => tsx`
+import { useSetPHAppConfig } from "@powerhousedao/reactor-browser";
+import type { EditorProps } from "document-model";
+import { DriveExplorer } from "./components/DriveExplorer.js";
+import { editorConfig } from "./config.js";
+
+/** Editor component for the app */
+export default function Editor(props: EditorProps) {
+  // set the config for this app
+  // you can update these configs in \`./config.ts\`
+  useSetPHAppConfig(editorConfig);
+  return (
+    <div className="bg-gray-50 p-6">
+      <DriveExplorer {...props} />
+    </div>
+  );
+}
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/AGENTS.md.ts
+const agentsTemplate = md`
+# Powerhouse Document Models Assistant
+
+This project creates document models, editors, processors and subgraphs for the Powerhouse ecosystem. Your role is to help users create these modules based on their needs.
+
+## Core Concepts
+
+- **Document Model**: A template for creating documents. Defines schema and allowed operations for a document type.
+- **Document**: An instance of a document model containing actual data that follows the model's structure and can be modified using operations.
+- **Drive**: A document of type "powerhouse/document-drive" representing a collection of documents and folders. Add documents using "addActions" with "ADD_FILE" action.
+- **Action**: A proposed change to a document (JSON object with action name and input). Dispatch using "addActions" tool.
+- **Operation**: A completed change to a document containing the action plus metadata (index, timestamp, hash, errors). Actions become operations after dispatch.
+
+## Technology Primer
+
+- **Reactor**: The core Powerhouse engine. It is modular and storage-agnostic, loads document models at runtime, and synchronizes documents across nodes via drives.
+- **Reactor Package**: A deployable bundle that extends the Reactor. It contains one or more document models, editors, processors, and subgraphs. A Vetra project generates a Reactor Package.
+- **Connect**: The Powerhouse web application for document management. End users open Connect to browse drives, create documents, and interact with editors.
+- **Switchboard**: The Powerhouse API service. It exposes GraphQL and MCP endpoints so external tools can read/write documents programmatically.
+- **Vetra**: The local development environment for building Reactor Packages. It includes Vetra Studio (a local Connect instance) and Vetra Switchboard (a local Switchboard with reactor-mcp). Start it with \`ph vetra\`.
+
+## CRITICAL: MCP Tool Usage Rules
+
+**MANDATORY**: The \`reactor-mcp\` MUST BE USED when handling documents or document-models for the Powerhouse/Vetra ecosystem.
+If the \`reactor-mcp\` server is unavailable, ask the user to run \`ph vetra\` on a separate terminal to start the server and try to reconnect to the MCP server, DO NOT run it yourself.
+
+### Key Requirements:
+
+- Never set document IDs manually - they're auto-generated by 'createDocument'
+- Minimize "addActions" calls by batching multiple actions together
+- Add new document model documents to "vetra-{hash}" drive unless specified otherwise
+- Always check document model schema before calling addActions
+- Use MCP tools for ALL document and document-model operations
+
+## Document Model Creation Workflow
+
+### 1. Planning Phase
+
+**MANDATORY**: Present your proposal to the user and ask for confirmation before implementing ANY document model.
+
+- **ALWAYS** describe the proposed document model structure (state schema, operations, modules) before creating
+- **NEVER** proceed with implementation without explicit user approval of your proposal
+- When in doubt, ask for clarification
+- Break complex models into logical modules and operations
+
+#### Document Type ID Format
+
+- **Type ID**: \`{organization}/{document-type-name}\` (e.g., \`pizza-plaza/order\`, \`acme/invoice\`)
+- **File extension**: 2-4 characters with leading dot (e.g., \`.ordr\`, \`.inv\`)
+- **Name**: Must match \`/[a-zA-Z][a-zA-Z0-9 ]*/\` — human-readable, capitalized (e.g., \`"Order"\`, \`"Invoice"\`)
+
+### 2. Pre-Implementation Requirements
+
+**MANDATORY**: Check document model schema before making any MCP tool calls.
+
+- **ALWAYS** use \`mcp__reactor-mcp__getDocumentModelSchema\` with \`type: "powerhouse/document-model"\` first
+- Review input schema requirements for operations like \`ADD_MODULE\`, \`ADD_OPERATION\`, etc.
+- Ensure all required parameters (like \`id\` or \`scope\` fields) are included in action inputs
+- This prevents failed tool calls and reduces iteration
+
+### 3. Implementation Requirements
+
+- Document model reducers must be **pure synchronous functions**
+- Reducers receive current state and operation, always returning the same result
+- Values like dates/IDs must come from operation input, not generated in reducer
+- Reducer code goes into SET_OPERATION_REDUCER action (no function header needed)
+- Reducers are wrapped with Mutative - you can mutate the state object directly
+- External imports go at the beginning of the actual reducer file in \`src/\`
+- Ensure that the reducer code of each operation in the document model schema is applied in \`document-models/<document-model-name>/src/reducers/<module-name>.ts\`
+
+### 4. Quality assurance
+
+After doing changes to the code, or after creating a new document model or a new editor, _YOU MUST RUN_ the following commands to check for errors in your implementation:
+
+- **TypeScript Check**: Run \`npm run tsc\` to validate type safety
+- **ESLint Check**: Run \`npm run lint:fix\` to check for errors with ESLint
+
+## Document editor creation flow
+
+**CRITICAL**: Creating a document editor is a **two-phase** process. You must NEVER skip Phase 1 or try to manually create editor files from scratch. The codegen system generates the boilerplate — your job is only to implement the UI inside it.
+
+### Phase 1: Create the editor document via MCP (MANDATORY FIRST STEP)
+
+**NEVER** start by writing editor code, creating component files, or looking at how to scaffold an editor manually. The **only** way to create a new editor is through the MCP tools:
+
+1. Check if the document editor already exists. If it does, ask the user if a new one should be created or if the existing one should be reimplemented
+2. If it's a new editor, get the document editor schema using \`mcp__reactor-mcp__getDocumentModelSchema\` with \`type: "powerhouse/document-editor"\`
+3. Create a new editor document on the \`vetra-{hash}\` drive of type \`powerhouse/document-editor\` using \`mcp__reactor-mcp__addActions\` with the \`ADD_FILE\` action
+4. Configure the editor document with the required actions (set the editor name, target document model, etc.) according to the schema
+
+⚠️ **The editor document MUST be confirmed/published — if it is left as draft state, the codegen will NOT run and no editor files will be generated.** Make sure the document state is not "DRAFT" after creation.
+
+5. Once the editor document is confirmed on the drive, the codegen automatically runs and generates boilerplate files in the \`editors/\` folder, including hooks, type definitions, and the editor component shell
+
+### Phase 2: Implement the editor UI
+
+Only **after** the codegen has produced the boilerplate files, proceed with the UI implementation:
+
+- Inspect the generated files in the \`editors/\` folder — do NOT create new files for the main editor component; edit the generated one
+- Inspect the hooks in \`editors/hooks\` as they should be useful
+- Read the schema of the document model that the editor is for to know how to interact with it
+- Every editor **MUST** include \`<DocumentToolbar />\` imported from \`@powerhousedao/design-system/connect/index\`. Place it at the top of the editor component — do not put anything next to it.
+- Style the editor using tailwind classes or a style tag. If using a style tag, make sure to make the selectors specific to only apply to the editor component.
+- Create modular components for the UI elements and place them on separate files to make it easier to maintain and update
+- Consider using the React Components exported by \`@powerhousedao/design-system\` and \`@powerhousedao/document-engineering\`
+- Separate business logic from presentation logic
+- Use TypeScript for type safety, avoid using any and type casting
+- Always check for type and lint errors after creating or modifying the editor
+- **CRITICAL**: After creating a new editor, verify that \`editors/editors.ts\` includes the new editor module. The codegen should update this file automatically, but if it doesn't, manually add the import and include the editor in the \`editors\` array. Without this registration, Connect won't find an editor for the document type. Example:
+
+  ~~~typescript
+  import type { EditorModule } from "document-model";
+  import { TodoListEditor } from "./todo-list-editor/module.js";
+
+  export const editors: EditorModule[] = [TodoListEditor];
+  ~~~
+
+### Document Editor Implementation Pattern
+
+**CRITICAL**: When implementing document editors, use the modern React hooks pattern from \`@powerhousedao/reactor-browser\`.
+
+The following section is valid for editors that edit a single document type.
+
+#### Required Imports and Setup
+
+Using a "Todo" document model as example:
+
+~~~typescript
+import { generateId } from "document-model";
+import { useSelectedTodoDocument } from "../hooks/useTodoDocument.js";
+import {
+  addTodo,
+} from "../../document-models/todo/gen/creators.js";
+
+export default function Editor() {
+  const [document, dispatch] = useSelectedTodoDocument();
+
+  function handleAddTodo(values: { title: string }) {
+    if (values.title) {
+      dispatch(addTodo({ id: generateId(), title: values.title }));
+    }
+  };
+
+// Note: The \`useSelectedTodoDocument\` hook is auto-generated. Check the \`editors/hooks\` folder for the exact hook name.
+// Action creators like \`addTodo\` are exported from the document model's \`gen/creators.js\` file.
+~~~
+
+The \`useSelectedTodoDocument\` gets generated automatically so you don't need to implement it yourself.
+
+## ⚠️ CRITICAL: Generated Files & Modification Rules
+
+### Generated Files Rule
+
+**NEVER edit files in \`gen/\` folders** - they are auto-generated and will be overwritten.
+
+### Document Model Modification Process
+
+For ANY document model changes, follow this **mandatory** two-step process:
+
+#### Step 1: Update Document Model via MCP
+
+Use \`mcp__reactor-mcp__addActions\` with operations like:
+
+- \`SET_OPERATION_SCHEMA\` - update input/output schemas
+- \`SET_OPERATION_REDUCER\` - update reducer code
+- \`SET_STATE_SCHEMA\` - update state definitions
+
+#### Step 2: Update Existing Source Files
+
+**ALSO manually update existing reducer files in \`src/\` folder** - these are NOT auto-generated.
+Make sure to check if the operation reducer code needs to be updated after changing the state schema.
+
+### ⚠️ Critical Reminder
+
+**ALWAYS do BOTH steps when fixing reducer issues:**
+
+1. ✅ Fix existing reducer files in \`src/\` manually
+2. ✅ Update document model via MCP with same fixes
+
+**Forgetting step 2 means future code generations will still contain the bugs!**
+
+## Reducer Implementation Guidelines
+
+### ❌ Forbidden in Reducers (Non-Deterministic)
+
+- \`crypto.randomUUID()\`, \`Math.random()\`, \`Date.now()\`, \`new Date()\`
+- External API calls or side effects
+- Asynchronous functions
+- Any non-deterministic functions
+
+### ❌ Forbidden Patterns
+
+~~~typescript
+// NEVER use fallback values with non-deterministic functions
+id: action.input.id || crypto.randomUUID(); // ❌ FORBIDDEN
+timestamp: action.input.timestamp || new Date(); // ❌ FORBIDDEN
+~~~
+
+### ✅ Required Pattern
+
+All dynamic values must come from action input:
+
+- **IDs**: Include \`id: OID!\` in input schema, use \`action.input.id\` in reducer
+- **Timestamps**: Include \`timestamp: DateTime!\` in input schema
+- **Computed values**: Calculate before dispatching action
+
+### Example
+
+~~~typescript
+// ❌ BAD - impure reducer
+const newItem = {
+  id: crypto.randomUUID(), // Non-deterministic
+  createdAt: new Date(), // Non-deterministic
+};
+
+// ✅ GOOD - pure reducer
+const newItem = {
+  id: action.input.id, // From action input
+  createdAt: action.input.createdAt, // From action input
+};
+~~~
+
+### Handling Nullable Input Types
+
+**CRITICAL**: Be careful when handling optional input types:
+
+- Optional input types use \`InputMaybe<T>\` allowing \`null | undefined | T\`.
+- Optional state types use \`Maybe<T>\` = \`T | null\`.
+- If there is no applicable default value then use \`|| null\`.
+
+~~~typescript
+// ❌ BAD - Type error with Maybe<string>
+amount: action.input.amount,
+notes: action.input.notes,
+
+// ✅ GOOD - Matches Maybe<T> = T | null
+amount: action.input.amount || null,
+notes: action.input.notes || [],
+~~~
+
+Use truthy checks when conditionally assigning optional values from input to state:
+
+~~~typescript
+// ❌ BAD - Type 'string | null' is not assignable to type 'string'.
+if (action.input.field !== undefined) entry.field = action.input.field;
+
+// ✅ GOOD - use truthy checks
+if (action.input.field) state.field = action.input.field;
+
+// ✅ GOOD - For booleans use explicit null/undefined checks
+if (action.input.field !== undefined && action.input.field !== null)
+  state.field = action.input.field;
+~~~
+
+### Error Handling in Operations
+
+**MANDATORY**: Define specific error types for each operation to handle invalid inputs and edge cases properly.
+Action inputs are validated so they are guaranteed to respect the input schema.
+Errors referenced in the reducer code will be imported automatically.
+
+#### Error Definition Requirements
+
+1. **Add error definitions** to operations using \`ADD_OPERATION_ERROR\`:
+   - \`errorCode\`: Uppercase snake_case (e.g., \`"MISSING_ID"\`, \`"ENTRY_NOT_FOUND"\`)
+   - \`errorName\`: PascalCase ending with "Error" (e.g., \`"MissingIdError"\`, \`"EntryNotFoundError"\`)
+   - \`errorDescription\`: Human-readable description of the error condition
+
+2. **Error names must end with "Error"** for consistency and code generation
+
+3. **Use specific error types** rather than generic validation
+
+4. **Must use unique error names and ids**
+
+#### Error Usage in Reducers
+
+~~~typescript
+// ✅ GOOD - Throw specific errors by name
+if (!action.input.id) {
+  throw new MissingIdError("ID is required for operation");
+}
+
+if (entryIndex === -1) {
+  throw new EntryNotFoundError(\`Entry not found\`);
+}
+
+// ❌ BAD - Generic Error
+throw new Error("Something went wrong");
+
+// ❌ BAD - Nested error access
+throw new errors.ModuleName.MissingIdError("message");
+
+// ❌ BAD - Do not import error classes in the reducer code,
+import { MissingIdError } from "../../gen/module-name/error.js";
+
+// ✅ GOOD - Simply reference the error and it will be imported automatically
+throw new MissingIdError("message");
+~~~
+
+#### Common Error Patterns
+
+- **EntityNotFoundError**: Referenced entity doesn't exist
+- **DuplicateIdError**: ID already exists when creating new entries
+- **InvalidInputError**: Business logic violations
+- **PermissionDeniedError**: Access control violations
+
+#### Testing Reducer Errors
+
+**CRITICAL**: When a reducer throws an error, the operation is **still added** to the document but with an \`.error\` property containing the error message as a string.
+
+**DO NOT** use \`.toThrow()\` or \`expect(() => ...).toThrow()\` patterns when testing reducer errors.
+
+##### How Errors Work in Operations
+
+1. The reducer throws an error (e.g., \`throw new InvalidNameError("message")\`)
+2. The operation is still recorded in \`document.operations.global\` (or \`.local\`)
+3. The error message is stored in \`operation.error\` as a string
+4. **The state is NOT mutated** - it remains unchanged from before the operation
+
+##### Accessing the Correct Operation Index
+
+**CRITICAL**: You must access the correct operation index. The index corresponds to how many operations were dispatched before it.
+
+- If this is the **first** operation dispatched, access \`[0]\`
+- If 3 operations were dispatched **before** the failing one, access \`[3]\`
+
+##### Example
+
+~~~typescript
+it("should return error and not mutate state", () => {
+  const document = utils.createDocument();
+  const initialState = document.state.global.name;
+
+  const updatedDocument = reducer(document, setName({ name: "invalid" }));
+
+  // Access the correct operation index (0 = first operation)
+  expect(updatedDocument.operations.global[0].error).toBe(
+    "Name is not allowed",
+  );
+  // State remains unchanged
+  expect(updatedDocument.state.global.name).toBe(initialState);
+});
+
+// ❌ WRONG - Never use toThrow()
+expect(() => reducer(document, setName({ name: "invalid" }))).toThrow();
+~~~
+
+## Document Model Structure
+
+### Core Components
+
+- **Basic Metadata**: \`id\`, \`name\`, \`extension\`, \`description\`, \`author\` (name + website)
+- **Specifications**: Versioned specs with \`version\`, \`changeLog\`, \`state\` (global/local with schema, initialValue, examples)
+- **Modules**: Operational modules containing their operations
+
+## Available Document Model Operations (37 total)
+
+| Category                         | Operations                                                                                                                                                                                                       | Count |
+| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- |
+| **Header Management**            | \`SET_MODEL_NAME\`, \`SET_MODEL_ID\`, \`SET_MODEL_EXTENSION\`, \`SET_MODEL_DESCRIPTION\`, \`SET_AUTHOR_NAME\`, \`SET_AUTHOR_WEBSITE\`                                                                                        | 6     |
+| **Versioning**                   | ⚠️ **DO NOT USE** - Not implemented                                                                                                                                                                              | 0     |
+| **Module Management**            | \`ADD_MODULE\`, \`SET_MODULE_NAME\`, \`SET_MODULE_DESCRIPTION\`, \`DELETE_MODULE\`, \`REORDER_MODULES\`                                                                                                                    | 5     |
+| **Operation Management**         | \`ADD_OPERATION\`, \`SET_OPERATION_NAME\`, \`SET_OPERATION_SCHEMA\`, \`SET_OPERATION_DESCRIPTION\`, \`SET_OPERATION_TEMPLATE\`, \`SET_OPERATION_REDUCER\`, \`MOVE_OPERATION\`, \`DELETE_OPERATION\`, \`REORDER_MODULE_OPERATIONS\` | 9     |
+| **Operation Error Management**   | \`ADD_OPERATION_ERROR\`, \`SET_OPERATION_ERROR_CODE\`, \`SET_OPERATION_ERROR_NAME\`, \`SET_OPERATION_ERROR_DESCRIPTION\`, \`SET_OPERATION_ERROR_TEMPLATE\`, \`DELETE_OPERATION_ERROR\`, \`REORDER_OPERATION_ERRORS\`           | 7     |
+| **Operation Example Management** | \`ADD_OPERATION_EXAMPLE\`, \`UPDATE_OPERATION_EXAMPLE\`, \`DELETE_OPERATION_EXAMPLE\`, \`REORDER_OPERATION_EXAMPLES\`                                                                                                    | 4     |
+| **State Management**             | \`SET_STATE_SCHEMA\`, \`SET_INITIAL_STATE\`, \`ADD_STATE_EXAMPLE\`, \`UPDATE_STATE_EXAMPLE\`, \`DELETE_STATE_EXAMPLE\`, \`REORDER_STATE_EXAMPLES\`                                                                           | 6     |
+
+## Best Practices & Design Principles
+
+### Scope Selection
+
+- **\`scope: "global"\`**: State shared among all users with document access
+- **\`scope: "local"\`**: State private to each individual user
+
+### Operation Design
+
+- Use descriptive operation names (e.g., \`ADD_LINE_ITEM\`, \`UPDATE_RECIPIENT\`)
+- One operation per user intent (separate concerns)
+- Include comprehensive examples and error definitions
+- Organize related operations into logical modules
+
+## GraphQL Schema Guidelines
+
+### Document State Schema
+
+- **Most fields optional** to support creating empty documents
+- Use required fields \`!\` only when absolutely necessary
+- Defaults handled by operations, not schema
+
+#### Mandatory vs Optional Field Rules
+
+A user must always be able to create an **empty document** without providing any information. This drives the following rules:
+
+- **Root type properties** can only be mandatory (\`!\`) if they have a logical default value (e.g., empty array, enum initial status)
+- **Collections** should always use \`[Type!]!\` — inner \`!\` means no nulls in the array, outer \`!\` means the array itself defaults to empty
+- **Child object fields** can be mandatory only if all their required properties also have logical defaults
+- Use \`enum\` types for workflow statuses (e.g., \`status: OrderStatus!\` where the enum has an initial value like \`DRAFT\`)
+
+### ⚠️ CRITICAL: State Type Naming Convention
+
+**MANDATORY**: The global state type name MUST follow this exact pattern:
+
+~~~graphql
+type <DocumentModelName>State {
+    # your fields here
+}
+~~~
+
+**DO NOT** append "Global" to the state type name, even when defining global state:
+
+~~~graphql
+// ❌ WRONG - Do not use "GlobalState" suffix
+type TodoListGlobalState {
+    todos: [Todo!]!
+}
+
+// ✅ CORRECT - Use only "State" suffix
+type TodoListState {
+    todos: [Todo!]!
+}
+
+// ✅ CORRECT - Use "LocalState" suffix for Local scope
+type TodoListLocalState {
+    localTodos: [Todo!]!
+}
+~~~
+
+**Why this matters:**
+
+- The code generator expects the type to be named \`<DocumentModelName>State\`
+- Using \`GlobalState\` or \`LocalState\` suffix will cause TypeScript compilation errors
+- This applies when using \`SET_STATE_SCHEMA\` with \`scope: "global"\`
+
+**Rule**: For global state, the type should be \`<DocumentModelName>State\`. For local state (if needed), the type name should be \`<DocumentModelName>LocalState\`.
+
+### Available Scalar Types
+
+| Standard  | Custom Identity        | Custom Amounts      | Custom Specialized |
+| --------- | ---------------------- | ------------------- | ------------------ |
+| \`String\`  | \`OID\` (Object ID)      | \`Amount\`            | \`EthereumAddress\`  |
+| \`Int\`     | \`PHID\` (Powerhouse ID) | \`Amount_Tokens\`     | \`EmailAddress\`     |
+| \`Float\`   | \`OLabel\`               | \`Amount_Money\`      | \`Date\`             |
+| \`Boolean\` |                        | \`Amount_Fiat\`       | \`DateTime\`         |
+|           |                        | \`Amount_Currency\`   | \`URL\`              |
+|           |                        | \`Amount_Crypto\`     | \`Currency\`         |
+|           |                        | \`Amount_Percentage\` |                    |
+
+### Arrays and Objects
+
+- **Arrays**: Must be mandatory \`[ObjectType!]!\`
+- **Objects in arrays**: Must include \`OID!\` field for unique identification
+- Include \`OLabel\` for metadata when relevant
+
+#### OID vs PHID Usage
+
+- \`OID\` is used as **primary key** (\`id: OID!\`) and **foreign key** (\`otherObjectId: OID!\`) within a document
+- \`PHID\` is **only** for referencing **external documents** (other documents in the drive), typically alongside cached properties (like a link preview — title/snippet may become stale)
+- **NEVER** use the \`ID\` type — it is a common GraphQL convention but is not used in Powerhouse document models
+
+#### Collection Sorting & Trees
+
+- **No need for \`position\` or \`weight\` properties** — maintain order via array index; operations like \`MOVE_X\` reorder the array directly
+- **Trees**: Always define as a flat list with \`parentId: OID\` (root nodes have \`parentId = null\`); do NOT use recursive/nested types
+
+### Input Types
+
+- Reflect user intent with descriptive names
+- Simple, specific fields over complex nested types
+- System auto-generates \`OID\` for new objects (users don't provide manually)
+
+#### Input Type Naming Convention
+
+- Root input type **MUST** be named \`<OperationName>Input\` (PascalCase of the operation name)
+- Example: operation \`SET_CATEGORY_LABEL\` → input type \`SetCategoryLabelInput\`
+- **Failing to follow this convention breaks the code generator**
+
+#### Input Types Cannot Reference State Types
+
+- In operation input schemas, **ONLY** \`enum\` types and scalar types from the state schema can be referenced directly
+- All other state types must be **mirrored** with unique input types (e.g., state type \`MenuItem\` → input type \`NewMenuItemInput\` for the ADD operation)
+- State \`enum\` types **MUST NOT** be redefined in input schemas — reference them directly
+- Each operation should have its **own** input types; do not share mirror types across operations
+
+#### Empty Input Workaround
+
+- Input types with **zero fields** are not supported by the code generator
+- Workaround: add \`_: Boolean\` as a dummy optional parameter
+
+~~~graphql
+# ❌ BAD - empty input type breaks codegen
+input ClearAllInput {}
+
+# ✅ GOOD - dummy field workaround
+input ClearAllInput {
+    _: Boolean
+}
+~~~
+
+## Working with Drives
+
+**MANDATORY**: Check the document-drive schema before performing drive operations.
+
+### Drive Types
+
+There might be two drives available with a special use case:
+
+1. **Vetra Drive** (\`vetra-{hash}\`):
+   - Contains **source documents**: document models and document editors
+   - Used for development
+   - Add document model and editor definitions here
+
+2. **Preview Drive** (\`preview-{hash}\`, named "Vetra Preview"):
+   - Contains **demo and preview documents** (document instances)
+   - Used for showcasing and testing document models
+   - Add actual document instances here
+
+### Drive Operations
+
+When working with drives (adding/removing documents, creating folders, etc.):
+
+1. **Always get the drive schema first**:
+
+   ~~~typescript
+   mcp__reactor -
+     mcp__getDocumentModelSchema({ type: "powerhouse/document-drive" });
+   ~~~
+
+2. **Review available operations** in the schema, such as:
+   - \`ADD_FILE\` - Add a document to the drive
+   - \`ADD_FOLDER\` - Create a new folder
+   - \`DELETE_NODE\` - Remove a file or folder (use this, NOT "DELETE_FILE")
+   - \`UPDATE_NODE\` - Update node properties
+   - \`MOVE_NODE\` - Move a node to different location
+
+3. **Check input schemas** for each operation to ensure you're passing correct parameters
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/claude/settings.local.json.ts
+const claudeSettingsLocalTemplate = json`
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "permissions": {
+    "allow": ["Bash(npm run tsc:*)", "Bash(npm run lint:*)"],
+    "deny": [
+      "Write(./document-models/*/gen/**)",
+      "Write(./.ph/**)",
+      "Edit(./document-models/*/gen/**)",
+      "Edit(./.ph/**)"
+    ]
+  },
+  "enableAllProjectMcpServers": true,
+  "enabledMcpjsonServers": ["reactor-mcp"]
+}
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/cursor/mcp.json.ts
+const cursorMcpTemplate = json`
+{
+  "mcpServers": {
+    "reactor-mcp": {
+      "type": "http",
+      "url": "http://localhost:4001/mcp"
+    }
+  }
+}
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/docker/connect-entrypoint.sh.ts
+const connectEntrypointTemplate = `#!/bin/sh
+set -e
+
+# Substitute environment variables in nginx configuration
+envsubst '\${PORT},\${PH_CONNECT_BASE_PATH}' < /etc/nginx/nginx.conf.template > /etc/nginx/nginx.conf
+
+echo "Testing nginx configuration..."
+nginx -t
+
+if [ $? -eq 0 ]; then
+    echo "Connect available at: http://localhost:\${PORT}\${PH_CONNECT_BASE_PATH}"
+    exec nginx -g "daemon off;"
+else
+    echo "Nginx configuration test failed"
+    exit 1
+fi
+`;
+//#endregion
+//#region src/templates/boilerplate/docker/Dockerfile.ts
+const dockerfileTemplate = `# =============================================================================
+# Multi-stage Dockerfile for Powerhouse Document Model Packages
+# Produces two images: connect (frontend) and switchboard (backend)
+#
+# Build commands:
+#   docker build --target connect -t <registry>/<project>/connect:<tag> .
+#   docker build --target switchboard -t <registry>/<project>/switchboard:<tag> .
+# =============================================================================
+
+# -----------------------------------------------------------------------------
+# Base stage: Common setup for building
+# -----------------------------------------------------------------------------
+FROM node:24-alpine AS base
+
+WORKDIR /app
+
+# Install build dependencies
+RUN apk add --no-cache python3 make g++ git bash \\
+    && ln -sf /usr/bin/python3 /usr/bin/python
+
+# Setup pnpm
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+RUN corepack enable && corepack prepare pnpm@latest --activate
+
+# Configure JSR registry
+RUN pnpm config set @jsr:registry https://npm.jsr.io
+
+# Build arguments
+ARG TAG=latest
+ARG PH_CONNECT_BASE_PATH="/"
+
+# Install ph-cmd, prisma, and prettier globally
+RUN pnpm add -g ph-cmd@$TAG prisma@5.17.0 prettier
+
+# Initialize project based on tag (dev/staging/latest)
+RUN case "$TAG" in \\
+        *dev*) ph init project --dev --package-manager pnpm ;; \\
+        *staging*) ph init project --staging --package-manager pnpm ;; \\
+        *) ph init project --package-manager pnpm ;; \\
+    esac
+
+WORKDIR /app/project
+
+# Copy package files for the current package
+COPY package.json pnpm-lock.yaml ./
+
+# Install the current package (this package)
+ARG PACKAGE_NAME
+RUN if [ -n "$PACKAGE_NAME" ]; then \\
+        echo "Installing package: $PACKAGE_NAME"; \\
+        ph install "$PACKAGE_NAME"; \\
+    else \\
+        echo "Warning: PACKAGE_NAME not provided, using local build"; \\
+        pnpm install; \\
+    fi
+
+# Regenerate Prisma client for Alpine Linux
+RUN prisma generate --schema node_modules/document-drive/dist/prisma/schema.prisma || true
+
+# -----------------------------------------------------------------------------
+# Connect build stage
+# -----------------------------------------------------------------------------
+FROM base AS connect-builder
+
+ARG PH_CONNECT_BASE_PATH="/"
+
+# Build connect
+RUN ph connect build --base \${PH_CONNECT_BASE_PATH}
+
+# -----------------------------------------------------------------------------
+# Connect final stage - nginx
+# -----------------------------------------------------------------------------
+FROM nginx:alpine AS connect
+
+# Install envsubst for config templating
+RUN apk add --no-cache gettext
+
+# Copy nginx config template
+COPY docker/nginx.conf /etc/nginx/nginx.conf.template
+
+# Copy built static files from build stage
+COPY --from=connect-builder /app/project/.ph/connect-build/dist /var/www/html/project
+
+# Environment variables for nginx config
+ENV PORT=3001
+ENV PH_CONNECT_BASE_PATH="/"
+
+# Copy and setup entrypoint
+COPY docker/connect-entrypoint.sh /docker-entrypoint.sh
+RUN chmod +x /docker-entrypoint.sh
+
+EXPOSE \${PORT}
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \\
+    CMD wget -q --spider http://localhost:\${PORT}/health || exit 1
+
+ENTRYPOINT ["/docker-entrypoint.sh"]
+
+# -----------------------------------------------------------------------------
+# Switchboard final stage - node runtime
+# -----------------------------------------------------------------------------
+FROM node:24-alpine AS switchboard
+
+WORKDIR /app
+
+# Install runtime dependencies
+RUN apk add --no-cache curl openssl
+
+# Setup pnpm
+ENV PNPM_HOME="/pnpm"
+ENV PATH="$PNPM_HOME:$PATH"
+RUN corepack enable && corepack prepare pnpm@latest --activate
+
+# Configure JSR registry
+RUN pnpm config set @jsr:registry https://npm.jsr.io
+
+# Install ph-cmd and prisma globally (needed at runtime)
+ARG TAG=latest
+RUN pnpm add -g ph-cmd@$TAG prisma@5.17.0
+
+# Copy built project from build stage
+COPY --from=base /app/project /app/project
+
+WORKDIR /app/project
+
+# Copy entrypoint
+COPY docker/switchboard-entrypoint.sh /app/entrypoint.sh
+RUN chmod +x /app/entrypoint.sh
+
+# Environment variables
+ENV NODE_ENV=production
+ENV PORT=3000
+ENV DATABASE_URL=""
+ENV SKIP_DB_MIGRATIONS="false"
+
+EXPOSE \${PORT}
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=30s --retries=3 \\
+    CMD curl -f http://localhost:\${PORT}/health || exit 1
+
+ENTRYPOINT ["/app/entrypoint.sh"]
+`;
+//#endregion
+//#region src/templates/boilerplate/docker/nginx.conf.ts
+const nginxConfTemplate = `user nginx;
+worker_processes auto;
+error_log /var/log/nginx/error.log warn;
+pid /var/run/nginx.pid;
+
+events {
+    worker_connections 1024;
+}
+
+http {
+    include /etc/nginx/mime.types;
+    default_type application/octet-stream;
+
+    # Gzip compression
+    gzip on;
+    gzip_vary on;
+    gzip_proxied any;
+    gzip_comp_level 6;
+    gzip_buffers 16 8k;
+    gzip_http_version 1.1;
+    gzip_types text/plain text/css application/javascript application/json image/svg+xml application/xml+rss image/avif;
+
+    server {
+        listen 0.0.0.0:\${PORT};
+        server_name _;
+        root /var/www/html/project;
+
+        # Health check endpoint
+        location /health {
+            access_log off;
+            add_header Content-Type text/plain;
+            return 200 'OK';
+        }
+
+        location \${PH_CONNECT_BASE_PATH}/assets/ {
+            alias /var/www/html/project/assets/;
+            access_log off;
+            log_not_found off;
+            etag off;
+            expires max;
+            add_header Cache-Control "public, max-age=31536000, immutable";
+        }
+
+        location \${PH_CONNECT_BASE_PATH}/fonts/ {
+            alias /var/www/html/project/fonts/;
+            access_log off;
+            log_not_found off;
+            expires max;
+            add_header Cache-Control "public, max-age=31536000, immutable";
+        }
+
+        location = \${PH_CONNECT_BASE_PATH}/service-worker.js {
+            alias /var/www/html/project/service-worker.js;
+
+            access_log off;
+            log_not_found off;
+            etag off;
+
+            add_header Cache-Control "no-cache, no-store, must-revalidate";
+            add_header Pragma "no-cache";
+            add_header Expires "0";
+        }
+
+        # match any file in the root folder, except index.html
+        location ~ \${PH_CONNECT_BASE_PATH}/(?!index\\.html$)([^/]+\\.[a-zA-Z0-9]+)$ {
+            alias /var/www/html/project/$1;
+            access_log off;
+            log_not_found off;
+            etag on;
+            add_header Cache-Control "public, must-revalidate";
+        }
+
+        location \${PH_CONNECT_BASE_PATH} {
+            try_files $uri $uri/ /index.html;
+        }
+    }
+}
+`;
+//#endregion
+//#region src/templates/boilerplate/docker/switchboard-entrypoint.sh.ts
+const switchboardEntrypointTemplate = `#!/bin/sh
+set -e
+
+# Regenerate Prisma client for current platform (fixes darwin-arm64 vs linux-musl-openssl mismatch)
+echo "[entrypoint] Regenerating Prisma client for current platform..."
+prisma generate --schema node_modules/document-drive/dist/prisma/schema.prisma
+
+# Run migrations if DATABASE_URL is postgres and migrations not skipped
+if [ -n "$DATABASE_URL" ] && echo "$DATABASE_URL" | grep -q "^postgres" && [ "$SKIP_DB_MIGRATIONS" != "true" ]; then
+    echo "[entrypoint] Running Prisma db push..."
+    prisma db push --schema node_modules/document-drive/dist/prisma/schema.prisma --skip-generate
+    echo "[entrypoint] Running migrations..."
+    ph switchboard --migrate
+fi
+
+echo "[entrypoint] Starting switchboard on port \${PORT:-3000}..."
+exec ph switchboard --port \${PORT:-3000}
+`;
+//#endregion
+//#region src/templates/boilerplate/document-models/document-models.ts
+const documentModelsTemplate = ts`
+import type { DocumentModelModule } from "document-model";
+
+export const documentModels: DocumentModelModule[] = [];
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/document-models/index.ts
+const documentModelsIndexTemplate = "";
+//#endregion
+//#region src/templates/boilerplate/editors/editors.ts
+const editorsTemplate = ts`
+import type { EditorModule } from "document-model";
+
+export const editors: EditorModule[] = [];
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/editors/index.ts
+const editorsIndexTemplate = "";
+//#endregion
+//#region src/templates/boilerplate/eslint.config.js.ts
+const eslintConfigTemplate = js`
+// @ts-check
+import { default as eslint } from "@eslint/js";
+import eslintPluginPrettierRecommended from "eslint-plugin-prettier/recommended";
+import reactPlugin from "eslint-plugin-react";
+import reactHooksPlugin from "eslint-plugin-react-hooks";
+import { defineConfig, globalIgnores } from "eslint/config";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+/** These files are typically ignored by eslint by default, so there is no need to investigate why they are ignored. */
+const ignoredFiles = [
+  "**/node_modules/",
+  "**/dist/",
+  "**/.ph/",
+  "**/storybook-static/",
+  "**/.vite/",
+];
+
+/** Global configs for eslint ignores */
+const ignored = globalIgnores(ignoredFiles);
+
+/** Typescript (\`.ts\`) files */
+const typescriptFiles = ["**/*.ts"];
+
+/** Typescript React (\`.tsx\`) files */
+const typescriptReactFiles = ["**/*.tsx"];
+
+/** Javascript (\`.js\`, \`.cjs\`, \`.mjs\`) files */
+const javascriptFiles = ["**/*.js", "**/*.cjs", "**/*.mjs"];
+
+/** Typescript rules that we have chosen to opt out of in general */
+/** @type {import("eslint").Linter.RulesRecord} */
+const typescriptRules = {
+  "@typescript-eslint/consistent-type-imports": [
+    "error",
+    {
+      prefer: "type-imports",
+      disallowTypeAnnotations: true,
+      fixStyle: "separate-type-imports",
+    },
+  ],
+  "@typescript-eslint/no-explicit-any": "off",
+  "@typescript-eslint/no-unused-vars": [
+    "warn",
+    {
+      argsIgnorePattern: "^_",
+      varsIgnorePattern: "^_",
+      caughtErrorsIgnorePattern: "^_",
+    },
+  ],
+  "@typescript-eslint/no-unnecessary-condition": "warn",
+  "@typescript-eslint/require-await": "warn",
+  "@typescript-eslint/no-misused-promises": "warn",
+  "@typescript-eslint/no-floating-promises": "warn",
+  "@typescript-eslint/no-empty-object-type": "warn",
+  "@typescript-eslint/no-duplicate-type-constituents": "warn",
+  "@typescript-eslint/restrict-template-expressions": [
+    "warn",
+    {
+      allowNumber: true,
+    },
+  ],
+};
+
+/** Language options for typescript files 
+@type {import("eslint").Linter.LanguageOptions} */
+const typescriptLanguageOptions = {
+  sourceType: "module",
+  ecmaVersion: "latest",
+  globals: {
+    ...globals.browser,
+    ...globals.node,
+  },
+  parserOptions: {
+    projectService: {
+      allowDefaultProject: ["eslint.config.js", "vitest.config.ts"],
+    },
+    tsconfigRootDir: import.meta.dirname,
+    ecmaFeatures: {
+      jsx: true,
+    },
+  },
+};
+
+/** React plugins */
+const reactPlugins = {
+  react: reactPlugin,
+  "react-hooks": reactHooksPlugin,
+};
+
+/** React settings */
+const reactSettings = {
+  react: {
+    version: "detect",
+  },
+};
+
+/** Typescript config for both \`.ts\` and \`.tsx\` files */
+const typescriptConfig = {
+  files: [...typescriptFiles, ...typescriptReactFiles],
+  languageOptions: typescriptLanguageOptions,
+  rules: typescriptRules,
+};
+
+/** React config for \`.tsx\` files */
+const reactConfig = {
+  files: typescriptReactFiles,
+  settings: reactSettings,
+  plugins: reactPlugins,
+};
+
+/** Config for javascript files */
+const javascriptConfig = {
+  // disable type aware linting for js files
+  files: javascriptFiles,
+  extends: [tseslint.configs.disableTypeChecked],
+};
+
+/** Recommended config from eslint */
+const eslintRecommendedConfig = eslint.configs.recommended;
+
+/** Recommended config from typescript-eslint */
+const typescriptEsLintRecommendedConfig = [
+  ...tseslint.configs.recommendedTypeChecked,
+];
+
+/** Main config */
+export default defineConfig(
+  ignored,
+  eslintRecommendedConfig,
+  typescriptEsLintRecommendedConfig,
+  typescriptConfig,
+  reactConfig,
+  javascriptConfig,
+  eslintPluginPrettierRecommended,
+);
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/gemini/settings.json.ts
+const geminiSettingsTemplate = json`
+{
+  "mcpServers": {
+    "reactor-mcp": {
+      "type": "http",
+      "url": "http://localhost:4001/mcp"
+    }
+  }
+}
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/github/sync-and-publish.yml.ts
+const syncAndPublishWorkflowTemplate = yaml`
+name: Sync and Publish
+
+on:
+  # Triggered by powerhouse monorepo after release
+  repository_dispatch:
+    types: [powerhouse-release]
+
+  # Manual trigger
+  workflow_dispatch:
+    inputs:
+      channel:
+        description: 'Release channel'
+        required: true
+        type: choice
+        options:
+          - dev
+          - staging
+          - latest
+        default: 'staging'
+      version:
+        description: 'Powerhouse version (e.g., 5.3.0-staging.6)'
+        required: false
+        type: string
+      dry-run:
+        description: 'Dry run (skip publishing)'
+        required: false
+        type: boolean
+        default: false
+      skip-docker:
+        description: 'Skip Docker build and push'
+        required: false
+        type: boolean
+        default: false
+
+env:
+  NODE_VERSION: '24'
+  PNPM_VERSION: '10'
+  DOCKER_REGISTRY: cr.vetra.io
+  GHCR_REGISTRY: ghcr.io
+
+jobs:
+  # ==========================================================================
+  # Determine release parameters
+  # ==========================================================================
+  prepare:
+    name: Prepare Release
+    runs-on: ubuntu-latest
+    outputs:
+      channel: \${{ steps.params.outputs.channel }}
+      version: \${{ steps.params.outputs.version }}
+      branch: \${{ steps.params.outputs.branch }}
+      project_name: \${{ steps.params.outputs.project_name }}
+      dry_run: \${{ steps.params.outputs.dry_run }}
+      skip_docker: \${{ steps.params.outputs.skip_docker }}
+    steps:
+      - name: Determine parameters
+        id: params
+        run: |
+          # Get channel from dispatch payload or input
+          if [ "\${{ github.event_name }}" = "repository_dispatch" ]; then
+            CHANNEL="\${{ github.event.client_payload.channel }}"
+            VERSION="\${{ github.event.client_payload.version }}"
+            DRY_RUN="false"
+            SKIP_DOCKER="false"
+          else
+            CHANNEL="\${{ inputs.channel }}"
+            VERSION="\${{ inputs.version }}"
+            DRY_RUN="\${{ inputs.dry-run }}"
+            SKIP_DOCKER="\${{ inputs.skip-docker }}"
+          fi
+
+          # Default channel to staging if not set
+          CHANNEL="\${CHANNEL:-staging}"
+
+          # Determine branch from channel
+          case "\$CHANNEL" in
+            dev) BRANCH="dev" ;;
+            staging) BRANCH="staging" ;;
+            latest|main) BRANCH="main" ;;
+            *) BRANCH="staging" ;;
+          esac
+
+          # Use DOCKER_PROJECT secret if set, otherwise extract from repository name
+          if [ -n "\${{ secrets.DOCKER_PROJECT }}" ]; then
+            PROJECT_NAME="\${{ secrets.DOCKER_PROJECT }}"
+          else
+            PROJECT_NAME="\${GITHUB_REPOSITORY#*/}"
+          fi
+
+          echo "channel=\$CHANNEL" >> \$GITHUB_OUTPUT
+          echo "version=\$VERSION" >> \$GITHUB_OUTPUT
+          echo "branch=\$BRANCH" >> \$GITHUB_OUTPUT
+          echo "project_name=\$PROJECT_NAME" >> \$GITHUB_OUTPUT
+          echo "dry_run=\$DRY_RUN" >> \$GITHUB_OUTPUT
+          echo "skip_docker=\$SKIP_DOCKER" >> \$GITHUB_OUTPUT
+
+          echo "Channel: \$CHANNEL"
+          echo "Version: \$VERSION"
+          echo "Branch: \$BRANCH"
+          echo "Project: \$PROJECT_NAME"
+          echo "Dry Run: \$DRY_RUN"
+          echo "Skip Docker: \$SKIP_DOCKER"
+
+  # ==========================================================================
+  # Update dependencies and publish to npm
+  # ==========================================================================
+  update-and-publish:
+    name: Update & Publish NPM
+    needs: prepare
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    outputs:
+      new_version: \${{ steps.version.outputs.new_version }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          ref: \${{ needs.prepare.outputs.branch }}
+          fetch-depth: 0
+          token: \${{ secrets.GITHUB_TOKEN }}
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: \${{ env.PNPM_VERSION }}
+
+      - name: Install Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: \${{ env.NODE_VERSION }}
+          cache: 'pnpm'
+
+      - name: Configure git
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Install ph-cli
+        run: |
+          CHANNEL="\${{ needs.prepare.outputs.channel }}"
+          case "\$CHANNEL" in
+            dev) pnpm add -g @powerhousedao/ph-cli@dev ;;
+            staging) pnpm add -g @powerhousedao/ph-cli@staging ;;
+            *) pnpm add -g @powerhousedao/ph-cli@latest ;;
+          esac
+
+      - name: Update Powerhouse dependencies
+        run: ph update
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Build package
+        run: pnpm build
+
+      - name: Run tests
+        run: pnpm test || true
+        continue-on-error: true
+
+      - name: Bump version
+        id: version
+        run: |
+          CHANNEL="\${{ needs.prepare.outputs.channel }}"
+          CURRENT_VERSION=\$(node -p "require('./package.json').version")
+
+          # Determine new version
+          if [ "\$CHANNEL" = "latest" ] || [ "\$CHANNEL" = "main" ]; then
+            # For production, use patch bump
+            npm version patch --no-git-tag-version
+          else
+            # For dev/staging, use prerelease
+            npm version prerelease --preid=\$CHANNEL --no-git-tag-version
+          fi
+
+          NEW_VERSION=\$(node -p "require('./package.json').version")
+          echo "new_version=\$NEW_VERSION" >> \$GITHUB_OUTPUT
+          echo "Bumped version: \$CURRENT_VERSION -> \$NEW_VERSION"
+
+      - name: Commit changes
+        run: |
+          git add package.json pnpm-lock.yaml
+          git commit -m "chore: sync powerhouse dependencies to \${{ needs.prepare.outputs.version }}
+
+          - Updated to powerhouse \${{ needs.prepare.outputs.version }}
+          - Bumped version to \${{ steps.version.outputs.new_version }}" || echo "No changes to commit"
+
+      - name: Push changes
+        if: needs.prepare.outputs.dry_run != 'true'
+        run: git push
+
+      - name: Setup npm for publishing
+        if: needs.prepare.outputs.dry_run != 'true' && secrets.NPM_ACCESS_TOKEN != ''
+        uses: actions/setup-node@v4
+        with:
+          node-version: \${{ env.NODE_VERSION }}
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Publish to npm with provenance
+        if: needs.prepare.outputs.dry_run != 'true' && secrets.NPM_ACCESS_TOKEN != ''
+        env:
+          NODE_AUTH_TOKEN: \${{ secrets.NPM_ACCESS_TOKEN }}
+          NPM_CONFIG_PROVENANCE: true
+        run: |
+          CHANNEL="\${{ needs.prepare.outputs.channel }}"
+          if [ "\$CHANNEL" = "latest" ] || [ "\$CHANNEL" = "main" ]; then
+            pnpm publish --access public --tag latest --no-git-checks
+          else
+            pnpm publish --access public --tag \$CHANNEL --no-git-checks
+          fi
+
+      - name: Create git tag
+        if: needs.prepare.outputs.dry_run != 'true'
+        run: |
+          git tag "v\${{ steps.version.outputs.new_version }}"
+          git push origin "v\${{ steps.version.outputs.new_version }}"
+
+  # ==========================================================================
+  # Build and push Docker images
+  # ==========================================================================
+  build-docker:
+    name: Build Docker Images
+    needs: [prepare, update-and-publish]
+    if: |
+      needs.prepare.outputs.skip_docker != 'true' &&
+      needs.prepare.outputs.dry_run != 'true' &&
+      secrets.DOCKER_USERNAME != '' &&
+      secrets.DOCKER_PASSWORD != ''
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      matrix:
+        target: [connect, switchboard]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          ref: \${{ needs.prepare.outputs.branch }}
+
+      - name: Pull latest changes
+        run: git pull origin \${{ needs.prepare.outputs.branch }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Ensure Docker project exists
+        run: |
+          PROJECT_NAME="\${{ needs.prepare.outputs.project_name }}"
+
+          # Check if project exists, create if not
+          STATUS=\$(curl -s -o /dev/null -w "%{http_code}" \\
+            -u "\${{ secrets.DOCKER_USERNAME }}:\${{ secrets.DOCKER_PASSWORD }}" \\
+            "https://\${{ env.DOCKER_REGISTRY }}/api/v2.0/projects?name=\${PROJECT_NAME}")
+
+          if [ "\$STATUS" = "200" ]; then
+            # Check if the project is in the response
+            EXISTS=\$(curl -s \\
+              -u "\${{ secrets.DOCKER_USERNAME }}:\${{ secrets.DOCKER_PASSWORD }}" \\
+              "https://\${{ env.DOCKER_REGISTRY }}/api/v2.0/projects?name=\${PROJECT_NAME}" | \\
+              jq -r ".[] | select(.name==\\"\${PROJECT_NAME}\\") | .name")
+
+            if [ "\$EXISTS" = "\$PROJECT_NAME" ]; then
+              echo "Project \${PROJECT_NAME} already exists"
+            else
+              echo "Creating project \${PROJECT_NAME}..."
+              curl -X POST \\
+                -u "\${{ secrets.DOCKER_USERNAME }}:\${{ secrets.DOCKER_PASSWORD }}" \\
+                -H "Content-Type: application/json" \\
+                -d "{\\"project_name\\": \\"\${PROJECT_NAME}\\", \\"public\\": false}" \\
+                "https://\${{ env.DOCKER_REGISTRY }}/api/v2.0/projects"
+            fi
+          else
+            echo "Creating project \${PROJECT_NAME}..."
+            curl -X POST \\
+              -u "\${{ secrets.DOCKER_USERNAME }}:\${{ secrets.DOCKER_PASSWORD }}" \\
+              -H "Content-Type: application/json" \\
+              -d "{\\"project_name\\": \\"\${PROJECT_NAME}\\", \\"public\\": false}" \\
+              "https://\${{ env.DOCKER_REGISTRY }}/api/v2.0/projects"
+          fi
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: \${{ env.GHCR_REGISTRY }}
+          username: \${{ github.actor }}
+          password: \${{ secrets.GITHUB_TOKEN }}
+
+      - name: Login to Docker Registry
+        uses: docker/login-action@v3
+        with:
+          registry: \${{ env.DOCKER_REGISTRY }}
+          username: \${{ secrets.DOCKER_USERNAME }}
+          password: \${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Extract package name
+        id: package
+        run: |
+          PACKAGE_NAME=\$(node -p "require('./package.json').name")
+          echo "name=\$PACKAGE_NAME" >> \$GITHUB_OUTPUT
+
+      - name: Determine image tags
+        id: tags
+        run: |
+          VERSION="\${{ needs.update-and-publish.outputs.new_version }}"
+          CHANNEL="\${{ needs.prepare.outputs.channel }}"
+          PROJECT="\${{ needs.prepare.outputs.project_name }}"
+          TARGET="\${{ matrix.target }}"
+
+          # GHCR tags
+          GHCR_BASE="\${{ env.GHCR_REGISTRY }}/\${{ github.repository_owner }}/\${PROJECT}/\${TARGET}"
+
+          # Docker registry tags
+          DOCKER_BASE="\${{ env.DOCKER_REGISTRY }}/\${PROJECT}/\${TARGET}"
+
+          # Build tag list
+          TAGS="\${GHCR_BASE}:v\${VERSION}"
+          TAGS="\${TAGS},\${DOCKER_BASE}:v\${VERSION}"
+
+          # Add channel tag
+          if [ "\$CHANNEL" = "latest" ] || [ "\$CHANNEL" = "main" ]; then
+            TAGS="\${TAGS},\${GHCR_BASE}:latest"
+            TAGS="\${TAGS},\${DOCKER_BASE}:latest"
+          else
+            TAGS="\${TAGS},\${GHCR_BASE}:\${CHANNEL}"
+            TAGS="\${TAGS},\${DOCKER_BASE}:\${CHANNEL}"
+          fi
+
+          echo "tags=\$TAGS" >> \$GITHUB_OUTPUT
+          echo "Image tags: \$TAGS"
+
+      - name: Build and push \${{ matrix.target }}
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          target: \${{ matrix.target }}
+          push: true
+          tags: \${{ steps.tags.outputs.tags }}
+          build-args: |
+            TAG=\${{ needs.prepare.outputs.channel == 'latest' && 'latest' || needs.prepare.outputs.version }}
+            PACKAGE_NAME=\${{ steps.package.outputs.name }}
+            PH_CONNECT_BASE_PATH=/
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  # ==========================================================================
+  # Summary
+  # ==========================================================================
+  summary:
+    name: Release Summary
+    needs: [prepare, update-and-publish, build-docker]
+    if: always()
+    runs-on: ubuntu-latest
+    steps:
+      - name: Summary
+        run: |
+          echo "## Release Summary" >> \$GITHUB_STEP_SUMMARY
+          echo "" >> \$GITHUB_STEP_SUMMARY
+          echo "| Parameter | Value |" >> \$GITHUB_STEP_SUMMARY
+          echo "|-----------|-------|" >> \$GITHUB_STEP_SUMMARY
+          echo "| Channel | \${{ needs.prepare.outputs.channel }} |" >> \$GITHUB_STEP_SUMMARY
+          echo "| Branch | \${{ needs.prepare.outputs.branch }} |" >> \$GITHUB_STEP_SUMMARY
+          echo "| Powerhouse Version | \${{ needs.prepare.outputs.version }} |" >> \$GITHUB_STEP_SUMMARY
+          echo "| Package Version | \${{ needs.update-and-publish.outputs.new_version }} |" >> \$GITHUB_STEP_SUMMARY
+          echo "| Dry Run | \${{ needs.prepare.outputs.dry_run }} |" >> \$GITHUB_STEP_SUMMARY
+          echo "" >> \$GITHUB_STEP_SUMMARY
+          echo "### Docker Images" >> \$GITHUB_STEP_SUMMARY
+          echo "- \\\`\${{ env.DOCKER_REGISTRY }}/\${{ needs.prepare.outputs.project_name }}/connect:v\${{ needs.update-and-publish.outputs.new_version }}\\\`" >> \$GITHUB_STEP_SUMMARY
+          echo "- \\\`\${{ env.DOCKER_REGISTRY }}/\${{ needs.prepare.outputs.project_name }}/switchboard:v\${{ needs.update-and-publish.outputs.new_version }}\\\`" >> \$GITHUB_STEP_SUMMARY
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/gitignore.ts
+const gitIgnoreTemplate = `
+dist
+coverage
+node_modules
+.eslintcache
+.env.local
+
+.ph
+projects-import.js
+`;
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/taggedTemplateLiteral.js
+function _taggedTemplateLiteral(e, t) {
+	return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(t) } }));
+}
+//#endregion
+//#region src/templates/boilerplate/index.html.ts
+var _templateObject$1;
+const indexHtmlTemplate = html(_templateObject$1 || (_templateObject$1 = _taggedTemplateLiteral(["<!DOCTYPE html>\n  <html lang=\"en\">\n    <head>\n      <meta charset=\"UTF-8\" />\n      <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n      <meta\n        name=\"description\"\n        content=\"Connect is a hub for your most important documents and processes, translated into software. Easily capture data in a structured way with dedicated business process packages. Collaborate on shared documents with ease while using your preferred storage solution (decentralized, centralized, or local).\"\n      />\n      <title>Powerhouse Connect</title>\n      <link rel=\"icon\" href=\"/icon.ico\" />\n      <link rel=\"preconnect\" href=\"https://fonts.googleapis.com\" />\n      <link rel=\"preconnect\" href=\"https://fonts.gstatic.com\" crossorigin />\n      <link\n        href=\"https://fonts.googleapis.com/css2?family=Inter:ital,opsz,wght@0,14..32,100..900;1,14..32,100..900&display=swap\"\n        rel=\"stylesheet\"\n      />\n    </head>\n    <body>\n      <div id=\"root\"></div>\n      <link href=\"/style.css\" rel=\"stylesheet\" />\n      <script type=\"module\" src=\"/main.tsx\"><\/script>\n    </body>\n  </html> "]))).raw;
+//#endregion
+//#region src/templates/boilerplate/index.html.legacy.ts
+var _templateObject;
+const legacyIndexHtmlTemplate = html(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  <!DOCTYPE html>\n  <html lang=\"en\">\n    <head>\n      <meta charset=\"UTF-8\" />\n      <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n      <meta\n        name=\"description\"\n        content=\"Connect is a hub for your most important documents and processes, translated into software. Easily capture data in a structured way with dedicated business process packages. Collaborate on shared documents with ease while using your preferred storage solution (decentralized, centralized, or local).\"\n      />\n      <title>Powerhouse Connect</title>\n      <link rel=\"icon\" href=\"/icon.ico\" />\n      <link rel=\"preconnect\" href=\"https://fonts.googleapis.com\" />\n      <link rel=\"preconnect\" href=\"https://fonts.gstatic.com\" crossorigin />\n      <link\n        href=\"https://fonts.googleapis.com/css2?family=Inter:ital,opsz,wght@0,14..32,100..900;1,14..32,100..900&display=swap\"\n        rel=\"stylesheet\"\n      />\n      <style>\n        @import \"tailwindcss\";\n        @import \"@powerhousedao/design-system/style.css\";\n        @import \"@powerhousedao/document-engineering/style.css\";\n        @source \"./node_modules/@powerhousedao/connect\";\n      </style>\n    </head>\n    <body>\n      <div id=\"root\"></div>\n      <script type=\"module\">\n        // initializes Connect on '<div id=\"root\"></div>'\n        import \"@powerhousedao/connect/main.js\";\n      <\/script>\n    </body>\n  </html>\n"]))).raw;
+//#endregion
+//#region src/templates/boilerplate/index.ts
+const indexTsTemplate = ts`
+import type { Manifest } from "document-model";
+import manifestJson from "./powerhouse.manifest.json" with { type: "json" };
+export { documentModels } from "./document-models/document-models.js";
+export { upgradeManifests } from "./document-models/upgrade-manifests.js";
+export { editors } from "./editors/editors.js";
+export { processorFactory } from "./processors/factory.js";
+export const manifest: Manifest = manifestJson;
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/LICENSE.ts
+const licenseTemplate = `
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.
+`;
+//#endregion
+//#region src/templates/boilerplate/main.tsx.ts
+const mainTsxTemplate = tsx`
+import { startConnect } from "@powerhousedao/connect";
+import * as localPackage from "./index.js";
+
+startConnect(localPackage);
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/mcp.json.ts
+const mcpTemplate = json`
+{
+  "mcpServers": {
+    "reactor-mcp": {
+      "type": "http",
+      "url": "http://localhost:4001/mcp"
+    }
+  }
+}
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/npmrc.ts
+const npmrcTemplate = `@jsr:registry=https://npm.jsr.io`;
+//#endregion
+//#region src/templates/boilerplate/package.json.ts
+const exportsTemplate = json`
+  ".": {
+    "types": "./dist/index.d.ts",
+    "browser": "./dist/browser/index.js",
+    "node": "./dist/node/index.mjs"
+  },
+  "./document-models": {
+    "types": "./dist/document-models/index.d.ts",
+    "browser": "./dist/browser/document-models/index.js",
+    "node": "./dist/node/document-models/index.mjs"
+  },
+  "./document-models/*": {
+    "types": "./dist/document-models/*/index.d.ts",
+    "browser": "./dist/browser/document-models/*/index.js",
+    "node": "./dist/node/document-models/*/index.mjs"
+  },
+  "./editors": {
+    "types": "./dist/editors/index.d.ts",
+    "browser": "./dist/browser/editors/index.js",
+    "node": "./dist/node/editors/index.mjs"
+  },
+  "./editors/*": {
+    "types": "./dist/editors/*/index.d.ts",
+    "browser": "./dist/browser/editors/*/index.js",
+    "node": "./dist/node/editors/*/index.mjs"
+  },
+  "./subgraphs": {
+    "types": "./dist/subgraphs/index.d.ts",
+    "browser": "./dist/browser/subgraphs/index.js",
+    "node": "./dist/node/subgraphs/index.mjs"
+  },
+  "./processors": {
+    "types": "./dist/processors/index.d.ts",
+    "browser": "./dist/browser/processors/index.js",
+    "node": "./dist/node/processors/index.mjs"
+  },
+  "./manifest": "./dist/powerhouse.manifest.json",
+  "./style.css": "./dist/style.css"
+`.raw;
+const scriptsTemplate = json`
+  "test": "vitest run",
+  "test:watch": "vitest",
+  "lint": "eslint --config eslint.config.js --cache --cache-strategy content",
+  "lint:fix": "npm run lint -- --fix",
+  "tsc": "tsc",
+  "tsc:watch": "tsc --watch",
+  "check-circular-imports": "npx dpdm -T ./index.ts",
+  "generate": "ph-cli generate",
+  "connect": "ph-cli connect",
+  "build": "ph-cli build",
+  "reactor": "ph-cli reactor",
+  "service": "ph-cli service",
+  "vetra": "ph-cli vetra",
+  "service-startup": "bash ./node_modules/@powerhousedao/ph-cli/dist/scripts/service-startup.sh",
+  "service-unstartup": "bash ./node_modules/@powerhousedao/ph-cli/dist/scripts/service-unstartup.sh"
+`.raw;
+const dependenciesTemplate = (versionedDependencies) => json`
+  ${versionedDependencies.join(",\n")},
+  "@powerhousedao/document-engineering": "1.40.1",
+  "graphql": "^16.10.0",
+  "graphql-tag": "^2.12.6",
+  "zod": "^4.3.5",
+  "react": "^19.2.3",
+  "react-dom": "^19.2.3"
+`.raw;
+const devDependenciesTemplate = (versionedDevDependencies) => json`
+  ${versionedDevDependencies.join(",\n")},
+  "@eslint/js": "^9.38.0",
+  "@tailwindcss/cli": "^4.1.18",
+  "@types/node": "^24.9.2",
+  "@types/react": "^19.2.3",
+  "eslint": "^9.38.0",
+  "eslint-plugin-react": "^7.37.5",
+  "eslint-plugin-react-hooks": "^7.0.1",
+  "eslint-config-prettier": "^10.1.8",
+  "eslint-plugin-prettier": "^5.5.4",
+  "globals": "^16.4.0",
+  "tailwindcss": "^4.1.16",
+  "typescript": "^5.9.3",
+  "typescript-eslint": "^8.46.2",
+  "vitest": "4.1.1",
+  "@vitejs/plugin-react": "6.0.1",
+  "vite-tsconfig-paths": "6.1.1"
+`.raw;
+const packageJsonTemplate = (projectName, versionedDependencies, versionedDevDependencies) => json`
+{
+  "name": "${projectName}",
+  "version": "1.0.0",
+  "license": "AGPL-3.0-only",
+  "type": "module",
+  "files": [
+    "/dist"
+  ],
+  "exports": {
+    ${exportsTemplate}
+  },
+  "scripts": {
+    ${scriptsTemplate}
+  },
+  "dependencies": {
+    ${dependenciesTemplate(versionedDependencies)}
+  },
+  "devDependencies": {
+    ${devDependenciesTemplate(versionedDevDependencies)}
+  }
+}
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/package.json.legacy.ts
+const packageJsonScriptsTemplate = {
+	build: "npm run tsc && npm run tailwind",
+	test: "vitest run",
+	"test:watch": "vitest",
+	lint: "eslint --config eslint.config.js --cache --cache-strategy content",
+	"lint:fix": "npm run lint -- --fix",
+	tsc: "tsc",
+	"tsc:watch": "tsc --watch",
+	tailwind: "pnpm exec tailwindcss -i ./style.css -o ./dist/style.css",
+	prepublishOnly: "npm run build",
+	"check-circular-imports": "npx dpdm -T ./index.ts",
+	generate: "ph-cli generate",
+	connect: "ph-cli connect",
+	reactor: "ph-cli reactor",
+	service: "ph-cli service",
+	vetra: "ph-cli vetra",
+	migrate: "ph-cli migrate",
+	"service-startup": "bash ./node_modules/@powerhousedao/ph-cli/dist/scripts/service-startup.sh",
+	"service-unstartup": "bash ./node_modules/@powerhousedao/ph-cli/dist/scripts/service-unstartup.sh"
+};
+const packageJsonExportsTemplate = {
+	".": {
+		types: "./dist/index.d.ts",
+		default: "./dist/index.js"
+	},
+	"./document-models": {
+		types: "./dist/document-models/index.d.ts",
+		default: "./dist/document-models/index.js"
+	},
+	"./editors": {
+		types: "./dist/editors/index.d.ts",
+		default: "./dist/editors/index.js"
+	},
+	"./document-models/*": {
+		types: "./dist/document-models/*/index.d.ts",
+		default: "./dist/document-models/*/index.js"
+	},
+	"./editors/*": {
+		types: "./dist/editors/*/index.d.ts",
+		default: "./dist/editors/*/index.js"
+	},
+	"./subgraphs": {
+		types: "./dist/subgraphs/index.d.ts",
+		default: "./dist/subgraphs/index.js"
+	},
+	"./processors": {
+		types: "./dist/processors/index.d.ts",
+		default: "./dist/processors/index.js"
+	},
+	"./manifest": { default: "./dist/powerhouse.manifest.json" },
+	"./style.css": "./dist/style.css"
+};
+//#endregion
+//#region src/templates/boilerplate/powerhouse.config.json.ts
+function makeVetraConfigField(vetraDriveUrl) {
+	if (!vetraDriveUrl) return "";
+	return json`
+  ,
+  "vetra": {
+    "driveId": "${vetraDriveUrl.split("/").pop() ?? ""}",
+    "driveUrl": "${vetraDriveUrl}"
+  }
+`.raw;
+}
+async function buildPowerhouseConfigTemplate(args) {
+	return json`
+  {
+  "documentModelsDir": "./document-models",
+  "editorsDir": "./editors",
+  "processorsDir": "./processors",
+  "subgraphsDir": "./subgraphs",
+  "studio": {
+    "port": 3000
+  },
+  "reactor": {
+    "port": 4001
+  },
+  "packages": [
+  ]${makeVetraConfigField(args.remoteDrive)}
+}
+`.raw;
+}
+//#endregion
+//#region src/templates/boilerplate/powerhouse.manifest.json.ts
+const powerhouseManifestTemplate = (projectName) => json`
+{
+    "name": "${projectName}",
+    "description": "",
+    "category": "",
+    "publisher": {
+        "name": "",
+        "url": ""
+    },
+    "documentModels": [],
+    "editors": [],
+    "apps": [],
+    "subgraphs": [],
+    "importScripts": []
+}
+
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/README.md.ts
+const readmeTemplate = md`
+# Document Model Boilerplate
+
+This Document Model Boilerplate provides code generation for scaffolding editors and models.
+It ensures compatibility with host applications like Connect and the Reactors for seamless document model and editor integration.
+
+## Standard Document Model Workflow with help of the boilerplate.
+
+This tutorial will guide you through the process of creating a new document model using the Document Model Editor in the Connect app.
+
+<details>
+<summary>Available NPM commands</summary>
+
+- \`generate\`: Updates the generated code according to the JSON spec and GraphQL schema of your document model, made in Connect.
+- \`lint\`: Checks for errors with ESLint and TypeScript checking.
+- \`format\`: Formats the code using Prettier.
+- \`build\`: Builds the library project using Vite.
+- \`storybook\`: Starts Storybook in development mode.
+- \`build-storybook\`: Builds Storybook.
+- \`test\`: Runs Jest for testing.
+
+</details>
+
+### 1. Defining Your Document Model GraphQL Schema
+
+Start by creating your own 'Powerhouse Project' (Document model + editor).
+
+Step 1: Run the following command to set up your project inside this directory:
+
+~~~bash
+npm create document-model-lib
+~~~
+
+Step 2: Use the Document Model Editor in the Connect app
+
+The following command gives you access to all the powerhouse CLI tools available, install it globally if you are a poweruser.
+
+~~~bash
+npm install ph-cmd
+~~~
+
+Now you are able to launch Connect in Studio Mode (Locally):
+
+~~~bash
+npm run connect
+~~~
+
+Open the 'Document Model' creator at the bottom of connect to define your document mode with it's GraphQL Schema Definition.
+This schema will define the structure and fields for your document model using GraphQL.
+Follow one of our tutorials on Academy to get familiar with the process.
+
+### 2. Defining Document Model Operations
+
+Using the Document Model Operations Editor, define the operations for your document model and their GraphQL counterparts.
+These operations will handle state changes within your document model.
+
+**Best Practices:**
+
+- Clearly define CRUD operations (Create, Read, Update, Delete).
+- Use GraphQL input types to specify the parameters for each operation.
+- Ensure that operations align with user intent to maintain a clean and understandable API.
+
+### 3. Generating Scaffolding Code
+
+Export your document model as a .zip file from Connect.
+Import the .zip file into your project directory created in Step 1.
+Run the following command to generate the scaffolding code:
+
+~~~bash
+npm run generate YourModelName.phdm.zip
+~~~
+
+This will create a new directory under /document-models containing:
+
+JSON file with the document model specification.
+GraphQL file with state and operation schemas.
+A gen/ folder with autogenerated code.
+A src/ folder for your custom code implementation.
+
+### 4. Implementing Reducer Code and Unit Tests
+
+Navigate to the reducer directory:
+
+~~~bash
+cd document-models/"YourModelName"/src/reducers
+~~~
+
+Implement the reducer functions for each document model operation. These functions will handle state transitions.
+
+Add utility functions in:
+
+~~~bash
+document-models/"YourModelName"/src/utils.ts
+~~~
+
+Write unit tests to ensure the correctness of your reducers:
+
+Test files should be located in:
+
+~~~bash
+document-models/"YourModelName"/src/reducers/tests
+~~~
+
+Run the tests:
+
+~~~bash
+npm test
+~~~
+
+Test the editor functionality:
+
+~~~bash
+npm run connect
+~~~
+
+### 5. Implementing Document Editors
+
+Generate the editor template for your document model:
+
+~~~bash
+npm run generate -- --editor YourModelName --document-types powerhouse/YourModelName
+~~~
+
+The --editor flag specifies the name of your document model.
+The --document-types flag links the editor to your document model type.
+After generation:
+
+Open the editor template:
+
+~~~bash
+editors/YourModelName/editor.tsx
+~~~
+
+Customize the editor interface to suit your document model.
+
+### 6. Testing the Document Editor
+
+Run the Connect app to test your document editor:
+
+~~~bash
+npm run connect
+~~~
+
+Verify that the editor functions as expected.
+Perform end-to-end testing to ensure smooth integration between the document model and its editor.
+
+### 7. Adding a Manifest File
+
+Create a manifest file to describe your document model and editor. This enables proper integration with the host application.
+
+**Example manifest.json:**
+
+~~~json
+{
+  "name": "your-model-name",
+  "description": "A brief description of your document model.",
+  "category": "your-category", // e.g., "Finance", "People Ops", "Legal"
+  "publisher": {
+    "name": "your-publisher-name",
+    "url": "your-publisher-url"
+  },
+  "documentModels": [
+    {
+      "id": "your-model-id",
+      "name": "your-model-name"
+    }
+  ],
+  "editors": [
+    {
+      "id": "your-editor-id",
+      "name": "your-editor-name",
+      "documentTypes": ["your-model-id"]
+    }
+  ]
+}
+~~~
+
+### Steps to finalize:
+
+Place the manifest file at your project root.
+Update your index.js to export your modules and include the new document model and editor.
+
+### Final Thoughts
+
+You've now successfully created a Document Model and its corresponding Editor using the Connect app!
+
+Next Steps:
+
+- Expand functionality: Add more operations or complex logic to your document model.
+- Improve UX: Enhance the document editor for a smoother user experience.
+- Integrate with other systems: Use APIs or GraphQL to connect your document model with external services.
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/style.css.ts
+const styleTemplate = css`
+  @import "tailwindcss";
+  @import "@powerhousedao/design-system/theme.css";
+  @import "@powerhousedao/connect/style.css";
+
+  @theme {
+    /* You can customize the theme by overriding the theme variables here */
+    /* See https://tailwindcss.com/docs/theme#using-a-custom-theme for details */
+
+    /* If you would prefer to use plain css, add your styles below this @theme tag as you normally would */
+
+    /* A sensible CSS reset is applied by default. If you would prefer to use a different reset or none at all, uncomment the following line */
+
+    /* --*: initial; */
+  }
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/subgraphs/index.ts
+const subgraphsIndexTemplate = "";
+//#endregion
+//#region src/templates/boilerplate/tsconfig.json.ts
+const tsconfigPathsTemplate = json`
+"document-models": [
+  "./document-models/index.ts"
+],
+"document-models/*": [
+  "./document-models/*/index.ts"
+],
+"editors": [
+  "./editors/index.ts"
+],
+"editors/*": [
+  "./editors/*/index.ts"
+],
+"processors/*": [
+  "./processors/*/index.ts"
+],
+"subgraphs": [
+  "./subgraphs/index.ts"
+],
+"subgraphs/*": [
+  "./subgraphs/*/index.ts"
+]`.raw;
+const tsConfigTemplate = json`
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": ".",
+    // paths for easy access to project modules
+    "paths": {
+      ${tsconfigPathsTemplate}
+    },
+    "module": "nodenext",
+    "moduleDetection": "force",
+    "target": "esnext",
+    "jsx": "react-jsx",
+    "types": ["node", "vitest/globals"],
+    "lib": ["ESNext", "dom", "dom.iterable"],
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "strict": true,
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "skipLibCheck": true
+  },
+  "include": ["**/*", "./powerhouse.manifest.json"],
+  "exclude": ["dist", "node_modules", ".ph"]
+}
+`.raw;
+//#endregion
+//#region src/templates/boilerplate/vite.config.ts.ts
+const viteConfigTemplate = ts`
+import { getConnectBaseViteConfig } from "@powerhousedao/builder-tools";
+import { defineConfig, mergeConfig, type UserConfig } from "vite";
+
+export default defineConfig(({ mode }) => {
+  const baseConnectViteConfig = getConnectBaseViteConfig({
+    mode,
+    dirname: import.meta.dirname,
+  });
+
+  const additionalViteConfig: UserConfig = {
+    // add your own vite config here
+  };
+
+  const config = mergeConfig(baseConnectViteConfig, additionalViteConfig);
+
+  return config;
+});
+`;
+//#endregion
+//#region src/templates/boilerplate/vitest.config.ts.ts
+const vitestConfigTemplate = ts`
+import { defineConfig } from "vitest/config";
+import react from "@vitejs/plugin-react";
+import tsconfigPaths from "vite-tsconfig-paths";
+
+export default defineConfig({
+  test: {
+    globals: true,
+  },
+  plugins: [tsconfigPaths(), react()],
+});
+
+`;
+//#endregion
+//#region src/templates/cli-docs/docs-from-cli-help.ts
+function groupHelpTopicsByCategory(helpTopics) {
+	const helpTopicsByCategory = {};
+	for (const helpTopic of helpTopics) if (!helpTopicsByCategory[helpTopic.category]) helpTopicsByCategory[helpTopic.category] = [helpTopic];
+	else helpTopicsByCategory[helpTopic.category]?.push(helpTopic);
+	return helpTopicsByCategory;
+}
+function makeTableOfContents(commandsHelpInfo) {
+	const commandNames = commandsHelpInfo.map(({ name }) => name);
+	const tableOfContentsEntries = [];
+	for (const name of commandNames) tableOfContentsEntries.push(`- [${capitalCase(name)}](#${kebabCase(name)})\n`);
+	return tableOfContentsEntries.join("");
+}
+function makeDefaultsDescriptors(defaults) {
+	return defaults.filter((d) => d !== "optional" && d !== "[...optional]").map((d) => {
+		const [label, ...rest] = d.split(":").map((s) => s.trim());
+		return `**${label}**: \`${rest.join("")}\``;
+	});
+}
+function makeRequiredDescriptor(defaults) {
+	if (defaults.includes("optional") || defaults.includes("[...optional]") || defaults.some((d) => d.includes("default"))) return "";
+	return "*[required]*";
+}
+function makeHeadingFromUsage(usage) {
+	if (usage.includes("--")) return `#### ${capitalCase(usage.split(" ")[0].replace("--", ""))}`;
+	return `#### ${capitalCase(usage.replace("[", "").replace("]", ""))}`;
+}
+function makeCommandHelpTopicDocs(helpTopic) {
+	const { defaults, description, usage } = helpTopic;
+	return `${makeHeadingFromUsage(usage)} ${makeRequiredDescriptor(defaults)}<br>
+${description}<br><br>
+**usage:** \`${usage}\`<br>
+${makeDefaultsDescriptors(defaults).join("<br>")}
+`;
+}
+function makeCommandHelpTopicsDocs(helpTopics) {
+	return helpTopics.map(makeCommandHelpTopicDocs).join("");
+}
+function makeCommandHelpTopicsDocsForCategories(helpTopics) {
+	const helpTopicsByCategory = groupHelpTopicsByCategory(helpTopics);
+	const helpTopicsDocs = [];
+	for (const [category, helpTopics] of Object.entries(helpTopicsByCategory)) {
+		const helpTopicDocs = makeCommandHelpTopicsDocs(helpTopics ?? []);
+		helpTopicsDocs.push(`### ${category}
+${helpTopicDocs}
+`);
+	}
+	return helpTopicsDocs.join("");
+}
+function makeCommandDoc(commandHelpInfo) {
+	const { name, description, helpTopics } = commandHelpInfo;
+	return `## ${capitalCase(name)}
+${description}
+${makeCommandHelpTopicsDocsForCategories(helpTopics)}`;
+}
+function makeCommandDocs(commandsHelpInfo) {
+	return commandsHelpInfo.map(makeCommandDoc).join("");
+}
+const docsFromCliHelpTemplate = (v) => `# ${v.docsTitle}<br>
+${v.docsIntroduction}<br><br>
+${v.cliDescription}<br>
+## Table of Contents
+${makeTableOfContents(v.commandsHelpInfo)}<br>
+${makeCommandDocs(v.commandsHelpInfo)}
+`;
+//#endregion
+//#region src/templates/document-editor/editor.ts
+const documentEditorEditorFileTemplate = (v) => tsx`
+import { DocumentStateViewer, DocumentToolbar } from "@powerhousedao/design-system/connect";
+import { ${v.useSelectedDocumentHookName}, actions } from "${v.documentModelImportPath}";
+
+export default function Editor() {
+  const [document, dispatch] = ${v.useSelectedDocumentHookName}();
+
+  const handleSetName = (name: string) => {
+    // 'actions' contains all available actions for this document type
+    dispatch(actions.setName(name));
+  };
+
+  return (
+    <div className="mx-auto max-w-4xl bg-gray-50 p-6">
+      <DocumentToolbar />
+
+      {/* "ph-default-styles" sets default styles for basic UI elements */}
+      <div className="ph-default-styles">
+        {/* Edit document name */}
+        <label className="my-6">
+          <h3>Document Name</h3>
+          <input
+            type="text"
+            defaultValue={document.header.name}
+            placeholder="Enter document name..."
+            title="Edit document name and click outside to save."
+            autoFocus
+            onBlur={(e) => handleSetName(e.target.value.trim())}
+            onKeyDown={(e) => {
+              if (e.key === "Enter") {
+                e.currentTarget.blur();
+              }
+            }}
+            className="font-semibold"
+          />
+        </label>
+        <hr />
+
+        {/* Document header info */}
+        <div className="mb-6 grid grid-cols-2 gap-x-8">
+          <label>
+            <h3 className="text-base">ID</h3>
+            <input
+              type="text"
+              value={document.header.id}
+              readOnly
+              className="font-mono"
+            />
+          </label>
+          <label>
+            <h3 className="text-base">Created</h3>
+            <input
+              type="text"
+              value={new Date(document.header.createdAtUtcIso).toLocaleString()}
+              readOnly
+            />
+          </label>
+          <label>
+            <h3 className="text-base">Type</h3>
+            <input type="text" value={document.header.documentType} readOnly />
+          </label>
+          <label>
+            <h3 className="text-base">Last Modified</h3>
+            <input
+              type="text"
+              value={new Date(
+                document.header.lastModifiedAtUtcIso,
+              ).toLocaleString()}
+              readOnly
+            />
+          </label>
+        </div>
+
+        {/* Document state */}
+        <div className="mt-6">
+          <h3 className="text-base">Document State</h3>
+          <DocumentStateViewer state={document.state} />
+        </div>
+      </div>
+    </div>
+  );
+}
+`.raw;
+//#endregion
+//#region src/templates/document-editor/module.ts
+const documentEditorModuleFileTemplate = (v) => tsx`
+import type { EditorModule } from "document-model";
+import { lazy } from "react";
+
+/** Document editor module for the "${v.documentTypes}" document type */
+export const ${v.pascalCaseEditorName}: EditorModule = {
+    Component: lazy(() => import("./editor.js")),
+    documentTypes: ${v.documentTypes},
+    config: {
+        id: "${v.editorId}",
+        name: "${v.editorName}",
+    },
+};
+`.raw;
+//#endregion
+//#region src/templates/document-model/actions.ts
+function buildModuleActionsName(module, camelCaseDocumentType) {
+	const camelCaseModuleName = camelCase(module.name);
+	return `${camelCaseDocumentType}${camelCaseModuleName.charAt(0).toUpperCase()}${camelCaseModuleName.slice(1)}Actions`;
+}
+function buildModuleActionsNames(modules, camelCaseDocumentType) {
+	return modules.map((m) => buildModuleActionsName(m, camelCaseDocumentType));
+}
+function buildModuleActionsImports(modules, camelCaseDocumentType) {
+	return `import { ${buildModuleActionsNames(modules, camelCaseDocumentType).join(",\n")} } from "./gen/creators.js";`;
+}
+function buildModuleActionsSpreadExport(modules, camelCaseDocumentType) {
+	return `
+export const actions = { ...baseActions, ${buildModuleActionsNames(modules, camelCaseDocumentType).map((n) => `...${n}`).join(",\n")} }`;
+}
+const documentModelRootActionsFileTemplate = (v) => ts`
+import { baseActions } from "document-model";
+${buildModuleActionsImports(v.modules, v.camelCaseDocumentType)}
+
+/** Actions for the ${v.pascalCaseDocumentType} document model */
+${buildModuleActionsSpreadExport(v.modules, v.camelCaseDocumentType)}
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/actions.ts
+function makeModuleActionsTypeImport(module, pascalCaseDocumentType) {
+	return `import type { ${pascalCaseDocumentType}${pascalCase(module.name)}Action } from "./${kebabCase(module.name)}/actions.js";`;
+}
+function makeModuleActionsTypeImports(modules, pascalCaseDocumentType) {
+	return modules.map((module) => makeModuleActionsTypeImport(module, pascalCaseDocumentType)).join("\n");
+}
+function makeModuleActionsTypeExport(module) {
+	return `export * from "./${kebabCase(module.name)}/actions.js";`;
+}
+function makeModuleActionsTypeExports(modules) {
+	return modules.map(makeModuleActionsTypeExport).join("\n");
+}
+function makeModuleActionTypeName(module, pascalCaseDocumentType) {
+	return `${pascalCaseDocumentType}${pascalCase(module.name)}Action`;
+}
+function makeModuleActionTypesUnion(modules, pascalCaseDocumentType) {
+	return modules.map((module) => makeModuleActionTypeName(module, pascalCaseDocumentType)).join("|\n");
+}
+function makeDocumentActionType(modules, pascalCaseDocumentType) {
+	return `export type ${pascalCaseDocumentType}Action = ${makeModuleActionTypesUnion(modules, pascalCaseDocumentType)};`;
+}
+const documentModelGenActionsFileTemplate = (v) => ts`
+${makeModuleActionsTypeImports(v.modules, v.pascalCaseDocumentType)}
+
+${makeModuleActionsTypeExports(v.modules)}
+
+${makeDocumentActionType(v.modules, v.pascalCaseDocumentType)}
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/controller.ts
+const documentModelGenControllerFileTemplate = (v) => ts`
+import { PHDocumentController } from "document-model";
+import { ${v.pascalCaseDocumentType} } from "../module.js";
+import type { ${v.actionTypeName}, ${v.phStateName} } from "./types.js";
+
+export const ${v.pascalCaseDocumentType}Controller = PHDocumentController.forDocumentModel<
+  ${v.phStateName},
+  ${v.actionTypeName}
+>(${v.pascalCaseDocumentType});
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/creators.ts
+function buildModuleCreatorsExport(module, camelCaseDocumentType) {
+	const kebabCaseModuleName = kebabCase(module.name);
+	const camelCaseModuleName = camelCase(module.name);
+	const namespaceName = `${camelCaseDocumentType}${camelCaseModuleName.charAt(0).toUpperCase()}${camelCaseModuleName.slice(1)}Actions`;
+	return [`export * from "./${kebabCaseModuleName}/creators.js";`, `export * as ${namespaceName} from "./${kebabCaseModuleName}/creators.js";`];
+}
+function buildCreatorsExports(modules, camelCaseDocumentType) {
+	return modules.flatMap((module) => buildModuleCreatorsExport(module, camelCaseDocumentType)).join("\n");
+}
+const documentModelGenCreatorsFileTemplate = (v) => ts`
+${buildCreatorsExports(v.modules, v.camelCaseDocumentType)}
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/document-schema.ts
+const documentModelDocumentSchemaFileTemplate = (v) => ts`
+import {
+  BaseDocumentHeaderSchema,
+  BaseDocumentStateSchema,
+} from "document-model";
+import { z } from "zod";
+import { ${v.documentTypeVariableName} } from "./document-type.js";
+import { ${v.stateSchemaName} } from "./schema/zod.js";
+import type { ${v.phDocumentTypeName}, ${v.phStateName} } from "./types.js";
+
+/** Schema for validating the header object of a ${v.pascalCaseDocumentType} document */
+export const ${v.phDocumentTypeName}HeaderSchema = BaseDocumentHeaderSchema.extend({
+  documentType: z.literal(${v.documentTypeVariableName}),
+});
+
+/** Schema for validating the state object of a ${v.pascalCaseDocumentType} document */
+export const ${v.phStateName}Schema = BaseDocumentStateSchema.extend({
+  global: ${v.stateSchemaName}(),
+});
+
+export const ${v.phDocumentSchemaName} = z.object({
+  header: ${v.phDocumentTypeName}HeaderSchema,
+  state: ${v.phStateName}Schema,
+  initialState: ${v.phStateName}Schema,
+});
+
+/** Simple helper function to check if a state object is a ${v.pascalCaseDocumentType} document state object */
+export function ${v.isPhStateOfTypeFunctionName}(
+  state: unknown,
+): state is ${v.phStateName} {
+  return ${v.phStateName}Schema.safeParse(state).success;
+}
+
+/** Simple helper function to assert that a document state object is a ${v.pascalCaseDocumentType} document state object */
+export function ${v.assertIsPhStateOfTypeFunctionName}(
+  state: unknown,
+): asserts state is ${v.phStateName} {
+  ${v.phStateName}Schema.parse(state);
+}
+
+/** Simple helper function to check if a document is a ${v.pascalCaseDocumentType} document */
+export function ${v.isPhDocumentOfTypeFunctionName}(
+  document: unknown,
+): document is ${v.phDocumentTypeName} {
+  return ${v.phDocumentSchemaName}.safeParse(document).success;
+}
+
+/** Simple helper function to assert that a document is a ${v.pascalCaseDocumentType} document */
+export function ${v.assertIsPhDocumentOfTypeFunctionName}(
+  document: unknown,
+): asserts document is ${v.phDocumentTypeName} {
+  ${v.phDocumentSchemaName}.parse(document);
+}
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/document-type.ts
+const documentModelDocumentTypeTemplate = (v) => ts`
+export const ${v.documentTypeVariableName} = "${v.documentTypeId}";
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/index.ts
+function buildModuleOperationsExports(module) {
+	return `export * from "./${kebabCase(module.name)}/operations.js";`;
+}
+function buildModulesOperationsExports(modules) {
+	return modules.map(buildModuleOperationsExports).join("\n");
+}
+const documentModelGenIndexFileTemplate = (v) => ts`
+export * from './actions.js';
+export * from './document-model.js';
+export * from './types.js';
+export * from './creators.js';
+export {
+  create${v.phDocumentTypeName},
+  createState,
+  defaultPHState,
+  defaultGlobalState,
+  defaultLocalState,
+} from './ph-factories.js';
+export * from "./utils.js";
+export * from "./reducer.js";
+export * from "./controller.js";
+export * from "./schema/index.js";
+export * from "./document-type.js";
+export * from "./document-schema.js";
+${buildModulesOperationsExports(v.modules)}
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/modules/actions.ts
+function getActionTypeExport(action) {
+	const baseActionTypeName = action.hasAttachment ? "ActionWithAttachment" : "Action";
+	const actionTypeName = getActionTypeName(action);
+	const actionInputName = getActionInputName(action) ?? `"{}"`;
+	return ts`export type ${actionTypeName} = ${baseActionTypeName} & { type: "${getActionType(action)}"; input: ${actionInputName} };`.raw;
+}
+function getActionTypeExports(actions) {
+	return actions.map(getActionTypeExport).join("\n");
+}
+function getModuleExportType(actions, pascalCaseDocumentName, pascalCaseModuleName) {
+	return ts`export type ${pascalCaseDocumentName}${pascalCaseModuleName}Action = ${actions.map(getActionTypeName).join(" |\n")};`.raw;
+}
+function getDocumentModelActionTypeImportNames(actions) {
+	const actionTypeImports = ["Action"];
+	if (actions.some((a) => a.hasAttachment)) actionTypeImports.push("ActionWithAttachment");
+	return actionTypeImports.join(",\n");
+}
+const documentModelOperationModuleActionsFileTemplate = (v) => ts`
+import type { ${getDocumentModelActionTypeImportNames(v.actions)} } from 'document-model';
+import type {
+  ${getActionInputTypeNames(v.actions)}
+} from '../types.js';
+
+${getActionTypeExports(v.actions)}
+
+${getModuleExportType(v.actions, v.pascalCaseDocumentType, v.pascalCaseModuleName)}
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/modules/creators.ts
+function makeDocumentModelTypeImports(actions) {
+	const actionTypeImports = ["createAction"];
+	if (actions.some((a) => a.hasAttachment)) actionTypeImports.push("AttachmentInput");
+	return actionTypeImports.join(",\n");
+}
+function makeActionInputSchemaName(action) {
+	if (!action.hasInput) return;
+	return `${pascalCase(action.name)}InputSchema`;
+}
+function makeActionInputTypeName(action) {
+	if (!action.hasInput) return;
+	return `${pascalCase(action.name)}Input`;
+}
+function makeActionTypeName(action) {
+	return `${pascalCase(action.name)}Action`;
+}
+function makeActionInputSchemaImports(actions) {
+	return actions.map(makeActionInputSchemaName).filter(Boolean).join(",\n");
+}
+function makeActionInputTypeImports(actions) {
+	return actions.map(makeActionInputTypeName).filter(Boolean).join(",\n");
+}
+function makeActionTypeImports(actions) {
+	return actions.map(makeActionTypeName).join(",\n");
+}
+function makeActionCreatorWithInput(actionWithInput) {
+	if (!actionWithInput.hasInput) return;
+	const camelCaseActionName = camelCase(actionWithInput.name);
+	const constantCaseActionName = constantCase(actionWithInput.name);
+	const actionTypeName = makeActionTypeName(actionWithInput);
+	const inputSchemaName = makeActionInputSchemaName(actionWithInput);
+	const inputTypeName = makeActionInputTypeName(actionWithInput);
+	const argsArray = [actionWithInput.isEmptyInput ? `input: ${inputTypeName} = {}` : `input: ${inputTypeName}`];
+	if (actionWithInput.hasAttachment) argsArray.push(`attachments: AttachmentInput[]`);
+	return ts`
+  export const ${camelCaseActionName} = (${argsArray.join(", ")}) =>
+    createAction<${actionTypeName}>(
+      "${constantCaseActionName}",
+      {...input},
+      ${actionWithInput.hasAttachment ? "attachments" : "undefined"},
+      ${inputSchemaName},
+      "${actionWithInput.scope}"
+    );`.raw;
+}
+function makeActionCreatorWithoutInput(actionWithoutInput) {
+	if (actionWithoutInput.hasInput) return;
+	const camelCaseActionName = camelCase(actionWithoutInput.name);
+	const constantCaseActionName = constantCase(actionWithoutInput.name);
+	return ts`
+   export const ${camelCaseActionName} = () =>
+    createAction<${makeActionTypeName(actionWithoutInput)}>("${constantCaseActionName}");`.raw;
+}
+function makeCreatorsForActionsWithInput(actions) {
+	return actions.filter((a) => a.hasInput).map(makeActionCreatorWithInput).join("\n\n");
+}
+function makeActionCreatorsWithoutInput(actions) {
+	return actions.filter((a) => !a.hasInput).map(makeActionCreatorWithoutInput).join("\n\n");
+}
+const documentModelOperationsModuleCreatorsFileTemplate = (v) => ts`
+
+import { ${makeDocumentModelTypeImports(v.actions)} } from "document-model";
+import {
+${makeActionInputSchemaImports(v.actions)}
+} from '../schema/zod.js';
+import type {
+${makeActionInputTypeImports(v.actions)}
+} from '../types.js';
+import type {
+${makeActionTypeImports(v.actions)}
+} from './actions.js';
+
+${makeCreatorsForActionsWithInput(v.actions)}
+
+${makeActionCreatorsWithoutInput(v.actions)}
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/modules/error.ts
+function getErrorName(error) {
+	if (!error.name) return;
+	return pascalCase(error.name);
+}
+function getErrorNames(errors) {
+	return errors.map(getErrorName).filter((name) => name !== void 0);
+}
+function getErrorCodeType(errors) {
+	return ts`export type ErrorCode = ${getErrorNames(errors).map((name) => `"${name}"`).join(" |\n")};`.raw;
+}
+function errorClassTemplate(error) {
+	const errorName = getErrorName(error);
+	if (!errorName) return;
+	return ts`
+    export class ${errorName} extends Error implements ReducerError {
+      errorCode = "${errorName}" as ErrorCode;
+      constructor(message = "${errorName}") {
+        super(message);
+      }
+    }
+  `.raw;
+}
+function getErrorClassImplementations(errors) {
+	return errors.map((error) => errorClassTemplate(error)).filter(Boolean).join("\n\n");
+}
+function getErrorsImplementations(errors) {
+	if (!errors.length) return "";
+	const deduplicatedErrors = errors.reduce((acc, error) => {
+		if (!acc.some((e) => getErrorName(e) === getErrorName(error))) acc.push(error);
+		return acc;
+	}, new Array());
+	return ts`
+    ${getErrorCodeType(deduplicatedErrors)}
+
+    export interface ReducerError {
+      errorCode: ErrorCode;
+    }
+
+    ${getErrorClassImplementations(deduplicatedErrors)}
+  `.raw;
+}
+function getActionErrorsExport(action) {
+	const errors = action.errors;
+	if (errors.length === 0) return;
+	return ts`
+    ${pascalCase(action.name)}: { ${getErrorNames(errors).filter(Boolean).join(",\n")} }
+  `.raw;
+}
+function getErrorsExport(actions) {
+	return ts`
+  export const errors = { ${actions.map(getActionErrorsExport).filter(Boolean).join(",\n")} };
+  `.raw;
+}
+const documentModelOperationsModuleErrorFileTemplate = (v) => ts`
+  ${getErrorsImplementations(v.errors)}
+  ${getErrorsExport(v.actions)}
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/modules/operations.ts
+function getActionTypeNames(actions) {
+	return actions.map(getActionTypeName);
+}
+function getActionTypeImports(actions) {
+	return getActionTypeNames(actions).join(",\n");
+}
+function getOperationsInterfaceName(pascalCaseDocumentType, module) {
+	return `${pascalCaseDocumentType}${pascalCase(module.name)}Operations`;
+}
+function getActionOperationFieldName(action) {
+	return `${camelCase(action.name)}Operation`;
+}
+function getActionOperationStateTypeName(action, pascalCaseDocumentType) {
+	if (!action.state) return `${pascalCaseDocumentType}State`;
+	return `${pascalCaseDocumentType}_${pascalCase(action.state)}_State`;
+}
+function getActionOperationStateTypeImports(actions, pascalCaseDocumentType) {
+	const stateTypeNames = actions.map((action) => getActionOperationStateTypeName(action, pascalCaseDocumentType));
+	return Array.from(new Set(stateTypeNames)).join(",\n");
+}
+function getActionOperationFunction(action, pascalCaseDocumentType) {
+	return ts`
+  (state: ${getActionOperationStateTypeName(action, pascalCaseDocumentType)}, action: ${getActionTypeName(action)}, dispatch?: SignalDispatch) => void
+`.raw;
+}
+function getOperationsInterfaceField(action, pascalCaseDocumentType) {
+	return ts`
+    ${getActionOperationFieldName(action)}: ${getActionOperationFunction(action, pascalCaseDocumentType)}
+  `.raw;
+}
+function getOperationsInterfaceFields(actions, pascalCaseDocumentType) {
+	return actions.map((action) => getOperationsInterfaceField(action, pascalCaseDocumentType)).join(",");
+}
+const documentModelOperationsModuleOperationsFileTemplate = (v) => ts`
+import { type SignalDispatch } from 'document-model';
+import type {
+  ${getActionTypeImports(v.actions)}
+} from './actions.js';
+import type {
+  ${getActionOperationStateTypeImports(v.actions, v.pascalCaseDocumentType)}
+} from "../types.js";
+
+export interface ${getOperationsInterfaceName(v.pascalCaseDocumentType, v.module)} {
+    ${getOperationsInterfaceFields(v.actions, v.pascalCaseDocumentType)}
+  }
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/ph-factories.ts
+const documentModelPhFactoriesFileTemplate = (v) => ts`
+/**
+ * Factory methods for creating ${v.phDocumentTypeName} instances
+ */
+import type {
+  PHAuthState,
+  PHDocumentState,
+  PHBaseState,
+} from "document-model";
+import {
+  createBaseState,
+  defaultBaseState,
+} from "document-model";
+import type {
+  ${v.phDocumentTypeName},
+  ${v.globalStateName},
+  ${v.localStateName},
+  ${v.phStateName},
+} from "./types.js";
+import { utils } from "./utils.js";
+
+export function defaultGlobalState(): ${v.globalStateName} {
+  return ${v.initialGlobalState};
+}
+
+export function defaultLocalState(): ${v.localStateName} {
+  return ${v.initialLocalState};
+}
+
+export function defaultPHState(): ${v.phStateName} {
+  return {
+    ...defaultBaseState(),
+    global: defaultGlobalState(),
+    local: defaultLocalState(),
+  };
+}
+
+export function createGlobalState(
+  state?: Partial<${v.globalStateName}>,
+): ${v.globalStateName} {
+  return {
+    ...defaultGlobalState(),
+    ...(state || {}),
+  } as ${v.globalStateName};
+}
+
+export function createLocalState(
+  state?: Partial<${v.localStateName}>,
+): ${v.localStateName} {
+  return {
+    ...defaultLocalState(),
+    ...(state || {}),
+  } as ${v.localStateName};
+}
+
+export function createState(
+  baseState?: Partial<PHBaseState>,
+  globalState?: Partial<${v.globalStateName}>,
+  localState?: Partial<${v.localStateName}>,
+): ${v.phStateName} {
+  return {
+    ...createBaseState(baseState?.auth, baseState?.document),
+    global: createGlobalState(globalState),
+    local: createLocalState(localState),
+  };
+}
+
+/**
+ * Creates a ${v.phDocumentTypeName} with custom global and local state
+ * This properly handles the PHBaseState requirements while allowing
+ * document-specific state to be set.
+ */
+export function create${v.phDocumentTypeName}(
+  state?: Partial<{
+    auth?: Partial<PHAuthState>;
+    document?: Partial<PHDocumentState>;
+    global?: Partial<${v.globalStateName}>;
+    local?: Partial<${v.localStateName}>;
+  }>,
+): ${v.phDocumentTypeName} {
+  const document = utils.createDocument(
+    state ? createState(
+      createBaseState(state.auth, state.document),
+      state.global,
+      state.local,
+    ) : undefined
+  );
+
+  return document;
+}
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/reducer.ts
+function makePascalCaseOperationName(operation) {
+	if (!operation.name) throw new Error("Operation is missing name");
+	return pascalCase(operation.name);
+}
+function makeCamelCaseOperationName(operation) {
+	if (!operation.name) throw new Error("Operation is missing name");
+	return camelCase(operation.name);
+}
+function makeConstantCaseOperationName(operation) {
+	if (!operation.name) throw new Error("Operation is missing name");
+	return constantCase(operation.name);
+}
+function makeOperationInputSchema(operation) {
+	return `${makePascalCaseOperationName(operation)}InputSchema`;
+}
+function makeOperationInputSchemaImports(modules) {
+	return `import { ${modules.flatMap((module) => module.operations.map(makeOperationInputSchema)).join(",\n")} } from "./schema/zod.js";`;
+}
+function makeModuleOperationsImport(module, camelCaseDocumentType) {
+	return `import { ${camelCaseDocumentType}${pascalCase(module.name)}Operations } from "../src/reducers/${kebabCase(module.name)}.js";`;
+}
+function makeModulesOperationsImports(modules, camelCaseDocumentType) {
+	return modules.map((module) => makeModuleOperationsImport(module, camelCaseDocumentType)).join("\n");
+}
+function makeOperationInputSchemaInvocation(operation) {
+	const operationInputSchema = makeOperationInputSchema(operation);
+	const constantCaseOperationName = makeConstantCaseOperationName(operation);
+	if (operation.schema === null) return ts`
+  if (Object.keys(action.input).length > 0) throw new Error("Expected empty input for action ${constantCaseOperationName}");
+`.raw;
+	return ts`${operationInputSchema}().parse(action.input);`.raw;
+}
+function makeOperationsObjectName(module, camelCaseDocumentType) {
+	return `${camelCaseDocumentType}${pascalCase(module.name)}Operations`;
+}
+function makeOperationName(operation) {
+	return `${makeCamelCaseOperationName(operation)}Operation`;
+}
+function makeOperationInvocation(module, operation, camelCaseDocumentType) {
+	return ts`
+  ${makeOperationsObjectName(module, camelCaseDocumentType)}.${makeOperationName(operation)}((state as any)[action.scope], action as any, dispatch);
+  `.raw;
+}
+function makeModuleOperationCaseStatement(module, camelCaseDocumentType) {
+	return module.operations.map((operation) => ts`
+      case "${makeConstantCaseOperationName(operation)}": {
+        ${makeOperationInputSchemaInvocation(operation)}
+        ${makeOperationInvocation(module, operation, camelCaseDocumentType)}
+        break;
+      }
+      `.raw);
+}
+function makeModuleOperationsCaseStatements(modules, camelCaseDocumentType) {
+	return modules.map((module) => makeModuleOperationCaseStatement(module, camelCaseDocumentType).join("\n")).join("\n");
+}
+const documentModelGenReducerFileTemplate = (v) => ts`
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import type { Reducer, StateReducer } from "document-model";
+import { isDocumentAction, createReducer } from "document-model";
+import type { ${v.phStateName} } from "${v.versionedDocumentModelPackageImportPath}";
+
+${makeModulesOperationsImports(v.modules, v.camelCaseDocumentType)}
+
+${makeOperationInputSchemaImports(v.modules)}
+
+const stateReducer: StateReducer<${v.phStateName}> =
+    (state, action, dispatch) => {
+        if (isDocumentAction(action)) {
+            return state;
+        }
+        switch (action.type) {
+       ${makeModuleOperationsCaseStatements(v.modules, v.camelCaseDocumentType)}
+            default:
+                return state;
+        }
+    }
+
+export const reducer: Reducer<${v.phStateName}> = createReducer(stateReducer);
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/schema/index.ts
+const documentModelSchemaIndexTemplate = ts`
+export * from "./types.js";
+export * from "./zod.js";
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/types.ts
+function buildEmptyLocalStateType(hasLocalSchema, localStateName) {
+	if (hasLocalSchema) return "";
+	return `type ${localStateName} = Record<PropertyKey, never>;`;
+}
+function buildLocalStateTypeImport(hasLocalSchema, localStateName) {
+	if (!hasLocalSchema) return "";
+	return localStateName;
+}
+const documentModelGenTypesTemplate = (v) => ts`
+import type { PHDocument, PHBaseState } from 'document-model';
+import type { ${v.actionTypeName} } from './actions.js';
+import type {
+  ${v.stateName} as ${v.globalStateName},
+  ${buildLocalStateTypeImport(v.hasLocalSchema, v.localStateName)}
+} from './schema/types.js';
+
+${buildEmptyLocalStateType(v.hasLocalSchema, v.localStateName)}
+
+type ${v.phStateName} = PHBaseState & {
+  global: ${v.globalStateName};
+  local: ${v.localStateName};
+};
+type ${v.phDocumentTypeName} = PHDocument<${v.phStateName}>;
+
+export * from './schema/types.js';
+
+export type { 
+  ${v.globalStateName}, 
+  ${v.localStateName},
+  ${v.phStateName}, 
+  ${v.actionTypeName},
+  ${v.phDocumentTypeName},
+};
+`.raw;
+//#endregion
+//#region src/templates/document-model/gen/utils.ts
+const documentModelGenUtilsTemplate = (v) => ts`
+import type {
+    DocumentModelUtils,
+} from "document-model";
+import { 
+    baseCreateDocument,
+    baseSaveToFileHandle,
+    baseLoadFromInput,
+    defaultBaseState,
+    generateId,
+ } from "document-model";
+import { reducer } from './reducer.js';
+import { ${v.documentTypeVariableName} } from "./document-type.js";
+import {
+  ${v.assertIsPhDocumentOfTypeFunctionName},
+  ${v.assertIsPhStateOfTypeFunctionName},
+  ${v.isPhDocumentOfTypeFunctionName},
+  ${v.isPhStateOfTypeFunctionName},
+} from "./document-schema.js";
+import type { ${v.globalStateName}, ${v.localStateName}, ${v.phStateName} } from './types.js';
+
+export const initialGlobalState: ${v.globalStateName} = ${v.initialGlobalState};
+export const initialLocalState: ${v.localStateName} = ${v.initialLocalState};
+
+export const utils: DocumentModelUtils<${v.phStateName}> = {
+    fileExtension: "${v.fileExtension}",
+    createState(state) {
+        return { ...defaultBaseState(), global: { ...initialGlobalState, ...state?.global }, local: { ...initialLocalState, ...state?.local } };
+    },
+    createDocument(state) {
+        const document = baseCreateDocument(
+            utils.createState,
+            state
+        );
+
+        document.header.documentType = ${v.documentTypeVariableName};
+
+        // for backwards compatibility, but this is NOT a valid signed document id
+        document.header.id = generateId();
+
+        return document;
+    },
+    saveToFileHandle(document, input) {
+        return baseSaveToFileHandle(document, input);
+    },
+    loadFromInput(input) {
+        return baseLoadFromInput(input, reducer);
+    },
+    isStateOfType(state) {
+        return ${v.isPhStateOfTypeFunctionName}(state);
+    },
+    assertIsStateOfType(state) {
+        return ${v.assertIsPhStateOfTypeFunctionName}(state);
+    },
+    isDocumentOfType(document) {
+        return ${v.isPhDocumentOfTypeFunctionName}(document);
+    },
+    assertIsDocumentOfType(document) {
+        return ${v.assertIsPhDocumentOfTypeFunctionName}(document);
+    },
+};
+`.raw;
+//#endregion
+//#region src/templates/document-model/hooks.ts
+const documentModelHooksFileTemplate = (v) => ts`
+
+import type { DocumentDispatch } from "@powerhousedao/reactor-browser";
+import {
+  useDocumentById,
+  useDocumentsInSelectedDrive,
+  useDocumentsInSelectedFolder,
+  useSelectedDocument,
+} from "@powerhousedao/reactor-browser";
+import type {
+  ${v.actionTypeName},
+  ${v.phDocumentTypeName},
+} from "${v.versionedDocumentModelPackageImportPath}";
+import { 
+  ${v.assertIsPhDocumentOfTypeFunctionName},
+  ${v.isPhDocumentOfTypeFunctionName} 
+} from "./gen/document-schema.js";
+
+/** Hook to get a ${v.pascalCaseDocumentType} document by its id */
+export function ${v.useByIdHookName}(
+  documentId: string | null | undefined,
+):
+  | [${v.phDocumentTypeName}, DocumentDispatch<${v.actionTypeName}>]
+  | [undefined, undefined] {
+  const [document, dispatch] = useDocumentById(documentId);
+  if (!${v.isPhDocumentOfTypeFunctionName}(document)) return [undefined, undefined];
+  return [document, dispatch];
+}
+
+/** Hook to get the selected ${v.pascalCaseDocumentType} document */
+export function ${v.useSelectedHookName}():
+  | [${v.phDocumentTypeName}, DocumentDispatch<${v.actionTypeName}>] {
+  const [document, dispatch] = useSelectedDocument();
+
+  ${v.assertIsPhDocumentOfTypeFunctionName}(document);
+  return [document, dispatch] as const;
+}
+
+/** Hook to get all ${v.pascalCaseDocumentType} documents in the selected drive */
+export function ${v.useInSelectedDriveHookName}() {
+  const documentsInSelectedDrive = useDocumentsInSelectedDrive();
+  return documentsInSelectedDrive?.filter(${v.isPhDocumentOfTypeFunctionName});
+}
+
+/** Hook to get all ${v.pascalCaseDocumentType} documents in the selected folder */
+export function ${v.useInSelectedFolderHookName}() {
+  const documentsInSelectedFolder = useDocumentsInSelectedFolder();
+  return documentsInSelectedFolder?.filter(${v.isPhDocumentOfTypeFunctionName});
+}
+`.raw;
+//#endregion
+//#region src/templates/document-model/index.ts
+const documentModelIndexTemplate = ts`
+export * from "./gen/index.js";
+export * from "./src/index.js";
+export * from "./hooks.js";
+export { actions } from "./actions.js";
+export { utils } from "./utils.js";
+`.raw;
+//#endregion
+//#region src/templates/document-model/module.ts
+function documentModelModuleFileTemplate({ phStateName, pascalCaseDocumentType, version }) {
+	return ts`
+  import type { DocumentModelModule } from "document-model";
+  import { createState, defaultBaseState } from "document-model";
+  import type { ${phStateName} } from "./gen/types.js";
+  import { documentModel } from "./gen/document-model.js";
+  import { reducer } from "./gen/reducer.js";
+  import { actions } from "./actions.js";
+  import { utils } from "./utils.js";
+
+  /** Document model module for the ${pascalCaseDocumentType} document type */
+  export const ${pascalCaseDocumentType}: DocumentModelModule<${phStateName}> = {
+    version: ${version},
+    reducer,
+    actions,
+    utils,
+    documentModel: createState(defaultBaseState(), documentModel),
+  };
+`.raw;
+}
+//#endregion
+//#region src/templates/document-model/src/index.ts
+const documentModelSrcIndexFileTemplate = ts`
+export * from "./utils.js";
+`.raw;
+//#endregion
+//#region src/templates/document-model/src/utils.ts
+const documentModelSrcUtilsTemplate = ts`
+export {};
+`.raw;
+//#endregion
+//#region src/templates/document-model/tests/document-model.test.ts
+const documentModelTestFileTemplate = (v) => ts`
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  utils,
+  initialGlobalState,
+  initialLocalState,
+  ${v.documentTypeVariableName},
+  ${v.isPhDocumentOfTypeFunctionName},
+  ${v.assertIsPhDocumentOfTypeFunctionName},
+  ${v.isPhStateOfTypeFunctionName},
+  ${v.assertIsPhStateOfTypeFunctionName},
+} from "${v.versionedDocumentModelPackageImportPath}";
+import { ZodError } from "zod";
+
+describe("${v.pascalCaseDocumentType} Document Model", () => {
+  it("should create a new ${v.pascalCaseDocumentType} document", () => {
+    const document = utils.createDocument();
+
+    expect(document).toBeDefined();
+    expect(document.header.documentType).toBe(${v.documentTypeVariableName});
+  });
+
+  it("should create a new ${v.pascalCaseDocumentType} document with a valid initial state", () => {
+    const document = utils.createDocument();
+    expect(document.state.global).toStrictEqual(initialGlobalState);
+    expect(document.state.local).toStrictEqual(initialLocalState);
+    expect(${v.isPhDocumentOfTypeFunctionName}(document)).toBe(true);
+    expect(${v.isPhStateOfTypeFunctionName}(document.state)).toBe(true);
+  });
+  it("should reject a document that is not a ${v.pascalCaseDocumentType} document", () => {
+    const wrongDocumentType = utils.createDocument();
+    wrongDocumentType.header.documentType = "the-wrong-thing-1234";
+    try {
+      expect(${v.assertIsPhDocumentOfTypeFunctionName}(wrongDocumentType)).toThrow();
+      expect(${v.isPhDocumentOfTypeFunctionName}(wrongDocumentType)).toBe(false);
+    } catch (error) {
+      expect(error).toBeInstanceOf(ZodError);
+    }
+  });
+  const wrongState = utils.createDocument();
+  // @ts-expect-error - we are testing the error case
+  wrongState.state.global = {
+    ...{ notWhat: "you want" },
+  };
+  try {
+    expect(${v.isPhStateOfTypeFunctionName}(wrongState.state)).toBe(false);
+    expect(${v.assertIsPhStateOfTypeFunctionName}(wrongState.state)).toThrow();
+    expect(${v.isPhDocumentOfTypeFunctionName}(wrongState)).toBe(false);
+    expect(${v.assertIsPhDocumentOfTypeFunctionName}(wrongState)).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
+
+  const wrongInitialState = utils.createDocument();
+  // @ts-expect-error - we are testing the error case
+  wrongInitialState.initialState.global = {
+    ...{ notWhat: "you want" },
+  };
+  try {
+    expect(${v.isPhStateOfTypeFunctionName}(wrongInitialState.state)).toBe(false);
+    expect(${v.assertIsPhStateOfTypeFunctionName}(wrongInitialState.state)).toThrow();
+    expect(${v.isPhDocumentOfTypeFunctionName}(wrongInitialState)).toBe(false);
+    expect(${v.assertIsPhDocumentOfTypeFunctionName}(wrongInitialState)).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
+
+  const missingIdInHeader = utils.createDocument();
+  // @ts-expect-error - we are testing the error case
+  delete missingIdInHeader.header.id;
+  try {
+    expect(${v.isPhDocumentOfTypeFunctionName}(missingIdInHeader)).toBe(false);
+    expect(${v.assertIsPhDocumentOfTypeFunctionName}(missingIdInHeader)).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
+
+  const missingNameInHeader = utils.createDocument();
+  // @ts-expect-error - we are testing the error case
+  delete missingNameInHeader.header.name;
+  try {
+    expect(${v.isPhDocumentOfTypeFunctionName}(missingNameInHeader)).toBe(false);
+    expect(${v.assertIsPhDocumentOfTypeFunctionName}(missingNameInHeader)).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
+
+  const missingCreatedAtUtcIsoInHeader = utils.createDocument();
+  // @ts-expect-error - we are testing the error case
+  delete missingCreatedAtUtcIsoInHeader.header.createdAtUtcIso;
+  try {
+    expect(${v.isPhDocumentOfTypeFunctionName}(missingCreatedAtUtcIsoInHeader)).toBe(false);
+    expect(${v.assertIsPhDocumentOfTypeFunctionName}(missingCreatedAtUtcIsoInHeader)).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
+
+  const missingLastModifiedAtUtcIsoInHeader = utils.createDocument();
+  // @ts-expect-error - we are testing the error case
+  delete missingLastModifiedAtUtcIsoInHeader.header.lastModifiedAtUtcIso;
+  try {
+    expect(${v.isPhDocumentOfTypeFunctionName}(missingLastModifiedAtUtcIsoInHeader)).toBe(false);
+    expect(
+      ${v.assertIsPhDocumentOfTypeFunctionName}(missingLastModifiedAtUtcIsoInHeader),
+    ).toThrow();
+  } catch (error) {
+    expect(error).toBeInstanceOf(ZodError);
+  }
+});
+`.raw;
+//#endregion
+//#region src/templates/document-model/tests/module.test.ts
+function makeModuleOperationsTypeName(module) {
+	return `${pascalCase(module.name)}Operations`;
+}
+function makeCamelCaseActionNamesForImport(actions) {
+	return actions.map((a) => camelCase(a.name));
+}
+function makeActionInputSchemasForImport(actions) {
+	return actions.map((a) => `${pascalCase(a.name)}InputSchema`);
+}
+function makeTestCaseForAction(action, isPhDocumentOfTypeFunctionName) {
+	const camelCaseActionName = camelCase(action.name);
+	const pascalCaseActionName = pascalCase(action.name);
+	const constantCaseActionName = constantCase(action.name);
+	const actionInputSchemaName = `${pascalCaseActionName}InputSchema`;
+	const scope = action.scope;
+	return ts`
+  it('should handle ${camelCaseActionName} operation', () => {
+        const document = utils.createDocument();
+        const input = generateMock(
+            ${actionInputSchemaName}(),
+        );
+
+        const updatedDocument = reducer(
+            document,
+            ${camelCaseActionName}(input),
+        );
+
+        expect(${isPhDocumentOfTypeFunctionName}(updatedDocument)).toBe(true);
+        expect(updatedDocument.operations.${scope}).toHaveLength(1);
+        expect(updatedDocument.operations.${scope}[0].action.type).toBe(
+            "${constantCaseActionName}",
+        );
+        expect(updatedDocument.operations.${scope}[0].action.input).toStrictEqual(input);
+        expect(updatedDocument.operations.${scope}[0].index).toEqual(0);
+    });
+  `.raw;
+}
+function makeActionImportNames(v) {
+	const actionNames = makeCamelCaseActionNamesForImport(v.actions);
+	const inputSchemaNames = makeActionInputSchemasForImport(v.actions);
+	return [
+		"reducer",
+		"utils",
+		v.isPhDocumentOfTypeFunctionName,
+		...actionNames,
+		...inputSchemaNames
+	];
+}
+function makeActionsImports(v) {
+	return ts`
+  import {
+    ${makeActionImportNames(v).join("\n")}
+  } from "${v.versionedDocumentModelPackageImportPath}";
+  `.raw;
+}
+function makeTestCasesForActions(actions, isPhDocumentOfTypeFunctionName) {
+	return actions.map((action) => makeTestCaseForAction(action, isPhDocumentOfTypeFunctionName)).join("\n\n");
+}
+const documentModelOperationsModuleTestFileTemplate = (v) => ts`
+/**
+ * This is a scaffold file meant for customization:
+ * - change it by adding new tests or modifying the existing ones
+ */
+
+import { describe, it, expect } from 'vitest';
+import { generateMock } from '@powerhousedao/common';
+import {
+  reducer,
+  utils,
+  ${v.isPhDocumentOfTypeFunctionName},
+  ${makeCamelCaseActionNamesForImport(v.actions)},
+  ${makeActionInputSchemasForImport(v.actions)},
+} from "${v.versionedDocumentModelPackageImportPath}";
+
+describe("${makeModuleOperationsTypeName(v.module)}", () => {
+  ${makeTestCasesForActions(v.actions, v.isPhDocumentOfTypeFunctionName)}
+});
+
+`.raw;
+//#endregion
+//#region src/templates/document-model/upgrades/upgrade-manifest.ts
+const upgradeManifestTemplate = (v) => ts`
+  import type { UpgradeManifest } from "document-model";
+  import { latestVersion, supportedVersions } from "./versions.js";
+
+  export const ${v.upgradeManifestName}: UpgradeManifest<typeof supportedVersions> = {
+    documentType: "${v.documentModelId}",
+    latestVersion,
+    supportedVersions,
+    upgrades: {},
+  };
+  `.raw;
+//#endregion
+//#region src/templates/document-model/upgrades/upgrade-transition.ts
+const upgradeTransitionTemplate = (v) => ts`
+import type { Action, PHDocument, UpgradeTransition } from "document-model";
+import type { ${v.phStateName} as StateV${v.previousVersion} } from "${v.documentModelPackageImportPath}/v${v.previousVersion}";
+import type { ${v.phStateName} as StateV${v.version} } from "${v.documentModelPackageImportPath}/v${v.version}";
+
+function upgradeReducer(
+  document: PHDocument<StateV${v.previousVersion}>,
+  action: Action,
+): PHDocument<StateV${v.version}> {
+  return {
+    ...document,
+  };
+}
+
+export const v${v.version}: UpgradeTransition = {
+  toVersion: ${v.version},
+  upgradeReducer,
+  description: "",
+};
+`.raw;
+//#endregion
+//#region src/templates/document-model/utils.ts
+const documentModelUtilsTemplate = ({ phStateName, pascalCaseDocumentType }) => ts`
+import type { DocumentModelUtils } from "document-model";
+import type { ${phStateName} } from "./gen/types.js";
+import { utils as genUtils } from "./gen/utils.js";
+import * as customUtils from "./src/utils.js";
+
+/** Utils for the ${pascalCaseDocumentType} document model */
+export const utils: DocumentModelUtils<${phStateName}> = { ...genUtils, ...customUtils };
+`.raw;
+//#endregion
+//#region src/templates/processors/utils.ts
+function getDocumentType(documentTypes) {
+	if (!documentTypes.length) return `"*"`;
+	return documentTypes.map((type) => `"${type}"`).join(", ");
+}
+//#endregion
+//#region src/templates/processors/analytics/factory.ts
+const analyticsFactoryTemplate = (v) => ts`
+import type { 
+  ProcessorApp,
+  ProcessorFactoryBuilder,
+  ProcessorRecord, 
+  IProcessorHostModule,
+} from "@powerhousedao/reactor-browser";
+import { type PHDocumentHeader } from "document-model";
+import { ${v.pascalCaseName} } from "./processor.js";
+
+export const ${v.camelCaseName}FactoryBuilder: ProcessorFactoryBuilder = (module: IProcessorHostModule) => async (driveHeader: PHDocumentHeader, processorApp?: ProcessorApp) => {
+  return [
+    {
+      processor: new ${v.pascalCaseName}(module.analyticsStore),
+      filter: {
+        branch: ["main"],
+        documentId: ["*"],
+        scope: ["*"],
+        documentType: [${getDocumentType(v.documentTypes)}],
+      },
+    },
+  ];
+}
+`.raw;
+//#endregion
+//#region src/templates/processors/analytics/index.ts
+const analyticsIndexTemplate = ts`
+export * from "./factory.js";
+export * from "./processor.js";
+`.raw;
+//#endregion
+//#region src/templates/processors/analytics/processor.ts
+const analyticsProcessorTemplate = (v) => ts`
+import type { AnalyticsSeriesInput, AnalyticsPath, IAnalyticsStore } from "@powerhousedao/analytics-engine-core";
+import type { OperationWithContext, IProcessor } from "@powerhousedao/reactor-browser";
+
+export class ${v.pascalCaseName} implements IProcessor {
+  private readonly NAMESPACE = "${v.pascalCaseName}";
+
+  private readonly inputs: AnalyticsSeriesInput[] = [];
+
+  constructor(private readonly analyticsStore: IAnalyticsStore) {
+    //
+  }
+
+  onOperations(operations: OperationWithContext[]): Promise<void> {
+    return Promise.resolve();
+  }
+
+  onDisconnect(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  private async clearSource(source: AnalyticsPath) {
+    try {
+      await this.analyticsStore.clearSeriesBySource(source, true);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+`.raw;
+//#endregion
+//#region src/templates/processors/factory-builders.ts
+const factoryBuildersTemplate = ts`
+import type { ProcessorFactoryBuilder } from "@powerhousedao/reactor";
+
+export const processorFactoryBuilders: ProcessorFactoryBuilder[] = [];
+`.raw;
+//#endregion
+//#region src/templates/processors/factory.ts
+const processorsFactoryTemplate = ts`
+/**
+ * This file aggregates all processor factories
+ * Auto-generated by codegen - DO NOT EDIT MANUALLY
+ */
+
+import type {
+  IProcessorHostModule,
+  ProcessorRecord,
+} from "@powerhousedao/reactor-browser";
+import type { PHDocumentHeader } from "document-model";
+
+export const processorFactory = async (module: IProcessorHostModule) => {
+  const { processorFactoryBuilders } =
+    module.processorApp === "connect"
+      ? await import("./connect.js")
+      : await import("./switchboard.js");
+
+  const factories = await Promise.all(
+    processorFactoryBuilders.map(
+      async (buildFactory) => await buildFactory(module),
+    ),
+  );
+
+  // Return the inner function that will be called for each drive
+  return async (driveHeader: PHDocumentHeader): Promise<ProcessorRecord[]> => {
+    const processors: ProcessorRecord[] = [];
+
+    // Call each cached factory with the driveHeader
+    for (const factory of factories) {
+      const factoryProcessors = await factory(driveHeader, module.processorApp);
+      processors.push(...factoryProcessors);
+    }
+
+    return processors;
+  };
+};
+`.raw;
+//#endregion
+//#region src/templates/processors/index.ts
+const processorsIndexTemplate = ts`
+/**
+ * Processor exports
+ * This file is auto-generated and updated by codegen
+ */
+
+export { processorFactory } from "./factory.js";
+`.raw;
+//#endregion
+//#region src/templates/processors/relational-db/factory.ts
+const relationalDbFactoryTemplate = (v) => ts`
+import type { 
+  IProcessorHostModule,
+  ProcessorApp,
+  ProcessorFactoryBuilder,
+  ProcessorFilter,
+  ProcessorRecord,
+ } from "@powerhousedao/reactor-browser"
+import type { PHDocumentHeader } from "document-model";
+import { ${v.pascalCaseName} } from "./processor.js";
+
+export const ${v.camelCaseName}FactoryBuilder: ProcessorFactoryBuilder = (module: IProcessorHostModule) => async (driveHeader: PHDocumentHeader, processorApp?: ProcessorApp) => {
+  // Create a namespace for the processor and the provided drive id
+  const namespace = ${v.pascalCaseName}.getNamespace(driveHeader.id);
+
+  // Create a namespaced db for the processor
+  const store = await module.relationalDb.createNamespace<${v.pascalCaseName}>(
+    namespace,
+  );
+
+  // Create a filter for the processor
+  const filter: ProcessorFilter = {
+    branch: ["main"],
+    documentId: ["*"],
+    documentType: [${getDocumentType(v.documentTypes)}],
+    scope: ["global"],
+  };
+
+  // Create the processor
+  const processor = new ${v.pascalCaseName}(namespace, filter, store);
+  return [
+    {
+      processor,
+      filter,
+    },
+  ];
+}
+`.raw;
+//#endregion
+//#region src/templates/processors/relational-db/index.ts
+const relationalDbIndexTemplate = ts`
+export * from "./factory.js";
+export * from "./processor.js";
+`.raw;
+//#endregion
+//#region src/templates/processors/relational-db/migrations.ts
+const relationalDbMigrationsTemplate = () => ts`
+import type { IRelationalDb } from "@powerhousedao/reactor-browser"
+
+export async function up(db: IRelationalDb<any>): Promise<void> {
+  // Create table 
+  await db.schema
+    .createTable("todo")
+    .addColumn("task", "varchar(255)")
+    .addColumn("status", "boolean")
+    .addPrimaryKeyConstraint("todo_pkey", [
+      "task"
+    ])
+    .ifNotExists()
+    .execute();
+}
+
+export async function down(db: IRelationalDb<any>): Promise<void> {
+  // drop table
+  await db.schema.dropTable("todo").execute();
+}
+`.raw;
+//#endregion
+//#region src/templates/processors/relational-db/processor.ts
+const defaultNamespaceComment = "// Default namespace: `${this.name}_${driveId.replaceAll(\"-\", \"_\")}`";
+const relationalDbProcessorTemplate = (v) => ts`
+import { RelationalDbProcessor } from "@powerhousedao/reactor-browser";
+import type { OperationWithContext } from "document-model";
+import { up } from "./migrations.js";
+import type { DB } from "./schema.js";
+
+export class ${v.pascalCaseName} extends RelationalDbProcessor<DB> {
+  onOperations(operations: OperationWithContext[]): Promise<void> {
+    return Promise.resolve();
+  }
+
+  onDisconnect(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  static override getNamespace(driveId: string): string {
+    ${defaultNamespaceComment}
+    return super.getNamespace(driveId);
+  }
+
+  override async initAndUpgrade(): Promise<void> {
+    await up(this.relationalDb);
+  }
+}
+`.raw;
+//#endregion
+//#region src/templates/processors/relational-db/schema.ts
+const relationalDbSchemaTemplate = () => ts`
+export interface Todo {
+  status: boolean | null;
+  task: string;
+}
+
+export interface DB {
+  todo: Todo;
+}
+`.raw;
+//#endregion
+//#region src/templates/subgraphs/index-file.ts
+const subgraphIndexFileTemplate = (v) => ts`
+import { BaseSubgraph } from "@powerhousedao/reactor-api";
+import type { DocumentNode } from "graphql";
+import { schema } from "./schema.js";
+import { getResolvers } from "./resolvers.js";
+
+export class ${v.pascalCaseName}Subgraph extends BaseSubgraph {
+  name = "${v.kebabCaseName}";
+  typeDefs: DocumentNode = schema;
+  resolvers = getResolvers(this);
+  additionalContextFields = {};
+  async onSetup() {}
+  async onDisconnect() {}
+}
+`.raw;
+//#endregion
+//#region src/templates/subgraphs/lib-file.ts
+const subgraphLibFileTemplate = () => ts`
+/**
+ * This is a scaffold file meant for customization.
+ * Delete the file and run the code generator again to have it reset
+ */
+`.raw;
+//#endregion
+//#region src/templates/subgraphs/custom-schema.ts
+const customSubgraphSchemaTemplate = (v) => ts`
+import { gql } from "graphql-tag";
+import type { DocumentNode } from "graphql";
+
+export const schema: DocumentNode = gql\`
+"""
+${v.pascalCaseName} Queries
+"""
+type ${v.pascalCaseName}Queries {
+    example(driveId: String!): String
+}
+
+type Query {
+    ${v.camelCaseName}: ${v.pascalCaseName}Queries!
+}
+
+\`
+`.raw;
+//#endregion
+//#region src/templates/subgraphs/custom-resolvers.ts
+const customSubgraphResolversTemplate = (v) => ts`
+import { type ISubgraph } from "@powerhousedao/reactor-api";
+
+export const getResolvers = (subgraph: ISubgraph): Record<string, unknown> => {
+  const reactor = subgraph.reactorClient;
+
+  return ({
+    Query: {
+      ${v.camelCaseName}: () => ({}), // namespace resolver for nested queries
+    },
+    ${v.pascalCaseName}Queries: {
+      example: async (parent: unknown, args: { driveId: string }) => {
+        return "example";
+      },
+    },
+  });
+};
+`.raw;
+//#endregion
+//#region src/templates/subgraphs/document-model-schema.ts
+const documentModelSubgraphSchemaTemplate = (v) => {
+	const mutationFields = v.modules.flatMap((module) => module.operations.map((op) => `    ${v.pascalCaseDocumentType}_${camel$1(op.name)}(driveId:String, docId:PHID, input:${v.pascalCaseDocumentType}_${pascal$1(op.name)}Input): Int`)).join("\n");
+	const moduleSchemas = v.modules.map((module) => {
+		return `${`\n"""\nModule: ${pascal$1(module.name)}\n"""`}\n${module.operations.map((op) => op.schema).join("\n")}`;
+	}).join("\n");
+	return `import { gql } from "graphql-tag";
+import type { DocumentNode } from "graphql";
+
+export const schema: DocumentNode = gql\`
+"""
+Queries: ${v.pascalCaseDocumentType} Document
+"""
+
+type ${v.pascalCaseDocumentType}Queries {
+    getDocument(docId: PHID!, driveId: PHID): ${v.pascalCaseDocumentType}
+    getDocuments(driveId: String): [${v.pascalCaseDocumentType}!]
+}
+
+type Query {
+    ${v.pascalCaseDocumentType}: ${v.pascalCaseDocumentType}Queries
+}
+
+"""
+Mutations: ${v.pascalCaseDocumentType}
+"""
+type Mutation {
+
+    ${v.pascalCaseDocumentType}_createDocument(name:String!, driveId:String): String
+
+${mutationFields}
+}
+
+${moduleSchemas}
+\`
+`;
+};
+function pascal$1(name) {
+	return name.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function camel$1(name) {
+	const p = pascal$1(name);
+	return p.charAt(0).toLowerCase() + p.slice(1);
+}
+//#endregion
+//#region src/templates/subgraphs/document-model-resolvers.ts
+const documentModelSubgraphResolversTemplate = (v) => {
+	const inputTypeImports = v.modules.flatMap((m) => m.operations.map((o) => `${pascal(o.name)}Input`)).join(",\n  ");
+	const operationMutations = v.modules.flatMap((module) => module.operations.map((op) => `        ${v.pascalCaseDocumentType}_${camel(op.name)}: async (_: unknown, args: { docId: string, input: ${pascal(op.name)}Input}) => {
+            const { docId, input } = args;
+            const doc = await reactorClient.get<${v.pascalCaseDocumentType}Document>(docId);
+            if(!doc) {
+              throw new Error("Document not found");
+            }
+
+            await reactorClient.execute(
+                docId,
+                "main",
+                [actions.${camel(op.name)}(input)]
+            );
+
+            return true;
+        },
+`)).join("\n");
+	return `import type { BaseSubgraph } from "@powerhousedao/reactor-api";
+import { addFile } from "@powerhousedao/shared/document-drive";
+import { setName } from "document-model";
+import {
+  actions,
+  ${v.documentTypeVariableName},
+} from "${v.documentModelDir}";
+import type {
+  ${v.phDocumentTypeName},
+  ${inputTypeImports}
+} from "${v.documentModelDir}";
+
+export const getResolvers = (subgraph: BaseSubgraph): Record<string, unknown> => {
+  const reactorClient = subgraph.reactorClient;
+
+  return ({
+    Query: {
+      ${v.pascalCaseDocumentType}: async () => {
+        return {
+          getDocument: async (args: { docId: string, driveId: string }) => {
+            const { docId, driveId } = args;
+
+            if(!docId) {
+              throw new Error("Document id is required");
+            }
+
+            if(driveId) {
+              const children = await reactorClient.getChildren(driveId);
+              const childIds = children.results.map(d => d.header.id);
+              if(!childIds.includes(docId)) {
+                throw new Error(\`Document with id \${docId} is not part of \${driveId}\`);
+              }
+            }
+
+            const doc = await reactorClient.get<${v.phDocumentTypeName}>(docId);
+            return {
+              driveId: driveId,
+              ...doc,
+              ...doc.header,
+              created: doc.header.createdAtUtcIso,
+              lastModified: doc.header.lastModifiedAtUtcIso,
+              state: doc.state.global,
+              stateJSON: doc.state.global,
+              revision: doc.header?.revision?.global ?? 0,
+            };
+          },
+          getDocuments: async (args: { driveId?: string }) => {
+            const { driveId } = args;
+            const result = await reactorClient.find({ type: ${v.documentTypeVariableName}, ...(driveId ? { parentId: driveId } : {}) });
+            return result.results.map((_doc) => {
+              const doc = _doc as ${v.phDocumentTypeName};
+              return {
+                driveId: driveId,
+                ...doc,
+                ...doc.header,
+                created: doc.header.createdAtUtcIso,
+                lastModified: doc.header.lastModifiedAtUtcIso,
+                state: doc.state.global,
+                stateJSON: doc.state.global,
+                revision: doc.header?.revision?.global ?? 0,
+              };
+            });
+          },
+        };
+      },
+    },
+    Mutation: {
+      ${v.pascalCaseDocumentType}_createDocument: async (_: unknown, args: { name: string, driveId?: string }) => {
+        const { driveId, name } = args;
+        const document = await reactorClient.createEmpty(${v.documentTypeVariableName});
+
+        if(driveId) {
+          await reactorClient.execute(
+            driveId,
+            "main",
+            [addFile({
+              name,
+              id: document.header.id,
+              documentType: ${v.documentTypeVariableName},
+            })],
+          );
+        }
+
+        if(name) {
+          await reactorClient.execute(
+            document.header.id,
+            "main",
+            [setName(name)],
+          );
+        }
+
+        return document.header.id;
+      },
+
+${operationMutations}
+    },
+  });
+};
+`;
+};
+function pascal(name) {
+	return name.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function camel(name) {
+	const p = pascal(name);
+	return p.charAt(0).toLowerCase() + p.slice(1);
+}
+//#endregion
+export { tsConfigTemplate as $, documentModelHooksFileTemplate as A, claudeSettingsLocalTemplate as At, getModuleExportType as B, appDriveContentsFileTemplate as Bt, makeActionsImports as C, documentModelsIndexTemplate as Ct, documentModelSrcIndexFileTemplate as D, dockerfileTemplate as Dt, documentModelSrcUtilsTemplate as E, nginxConfTemplate as Et, documentModelPhFactoriesFileTemplate as F, folderTreeFileTemplate as Ft, documentModelGenControllerFileTemplate as G, documentModelDocumentTypeTemplate as H, documentModelOperationsModuleOperationsFileTemplate as I, appFoldersFileTemplate as It, documentEditorModuleFileTemplate as J, documentModelGenActionsFileTemplate as K, documentModelOperationsModuleErrorFileTemplate as L, appFilesFileTemplate as Lt, documentModelGenTypesTemplate as M, appEditorFileTemplate as Mt, documentModelSchemaIndexTemplate as N, appConfigFileTemplate as Nt, documentModelModuleFileTemplate as O, connectEntrypointTemplate as Ot, documentModelGenReducerFileTemplate as P, driveExplorerNavigationBreadcrumbsFileTemplate as Pt, viteConfigTemplate as Q, documentModelOperationsModuleCreatorsFileTemplate as R, emptyStateFileTemplate as Rt, makeActionImportNames as S, editorsTemplate as St, documentModelTestFileTemplate as T, switchboardEntrypointTemplate as Tt, documentModelDocumentSchemaFileTemplate as U, documentModelGenIndexFileTemplate as V, createDocumentFileTemplate as Vt, documentModelGenCreatorsFileTemplate as W, docsFromCliHelpTemplate as X, documentEditorEditorFileTemplate as Y, vitestConfigTemplate as Z, analyticsFactoryTemplate as _, gitIgnoreTemplate as _t, subgraphLibFileTemplate as a, buildPowerhouseConfigTemplate as at, upgradeManifestTemplate as b, eslintConfigTemplate as bt, relationalDbProcessorTemplate as c, exportsTemplate as ct, relationalDbFactoryTemplate as d, mcpTemplate as dt, tsconfigPathsTemplate as et, processorsIndexTemplate as f, mainTsxTemplate as ft, analyticsIndexTemplate as g, indexHtmlTemplate as gt, analyticsProcessorTemplate as h, legacyIndexHtmlTemplate as ht, customSubgraphSchemaTemplate as i, powerhouseManifestTemplate as it, documentModelGenUtilsTemplate as j, agentsTemplate as jt, documentModelIndexTemplate as k, cursorMcpTemplate as kt, relationalDbMigrationsTemplate as l, packageJsonTemplate as lt, factoryBuildersTemplate as m, indexTsTemplate as mt, documentModelSubgraphSchemaTemplate as n, styleTemplate as nt, subgraphIndexFileTemplate as o, packageJsonExportsTemplate as ot, processorsFactoryTemplate as p, licenseTemplate as pt, documentModelRootActionsFileTemplate as q, customSubgraphResolversTemplate as r, readmeTemplate as rt, relationalDbSchemaTemplate as s, packageJsonScriptsTemplate as st, documentModelSubgraphResolversTemplate as t, subgraphsIndexTemplate as tt, relationalDbIndexTemplate as u, npmrcTemplate as ut, documentModelUtilsTemplate as v, syncAndPublishWorkflowTemplate as vt, makeTestCaseForAction as w, documentModelsTemplate as wt, documentModelOperationsModuleTestFileTemplate as x, editorsIndexTemplate as xt, upgradeTransitionTemplate as y, geminiSettingsTemplate as yt, documentModelOperationModuleActionsFileTemplate as z, driveExplorerFileTemplate as zt };
+
+//# sourceMappingURL=templates-DBvz_qPL.mjs.map