@powerhousedao/academy 2.5.0-dev.24 → 2.5.0-dev.26

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 2.5.0-dev.26 (2025-06-16)
+
+This was a version bump only for @powerhousedao/academy to align it with other projects, there were no code changes.
+
+## 2.5.0-dev.25 (2025-06-13)
+
+### 🚀 Features
+
+- start dependent services with switchboard ([188c82c6a](https://github.com/powerhouse-inc/powerhouse/commit/188c82c6a))
+
+### 🩹 Fixes
+
+- **docker:** request write permissions ([29d4d3fd7](https://github.com/powerhouse-inc/powerhouse/commit/29d4d3fd7))
+
+### ❤️ Thank You
+
+- Frank
+
 ## 2.5.0-dev.24 (2025-06-13)
 
 ### 🚀 Features

package/docs/academy/01-GetStarted/00-ExploreDemoPackage.md

@@ -18,7 +18,8 @@ Install the Powerhouse command-line tool `ph-cmd` and then use it to install a p
 
 ## Step 1: Install the Powerhouse CLI
 
-You will use the Powerhouse CLI to launch a local environment with a "**Contributor Billing**" package. This package demonstrates how you might track and bill for contributions in a project. First, you need the Powerhouse command-line interface (CLI). Open your terminal and run the installation command:
+You will use the Powerhouse CLI to launch a local environment with a "**ToDoList Demo Package**". 
+This is also the package that you'll recreate during the tutorials and get's you familiar with Powerhouse. 
 
 ```bash
 pnpm install -g ph-cmd
@@ -36,18 +37,13 @@ Now, use the `ph` command to install the demo package into a global project.
 
 ```bash
 # Install the package
-ph install @powerhousedao/contributor-billing
+ph install @powerhousedao/todo-demo-package.
 ```
 
-This command downloads and sets up the Contributor Billing package, making its features available in your Powerhouse environment.
+This command downloads and sets up the todo-demo-package, making its features available in your Powerhouse environment.
 
 You have now successfully installed `ph-cmd` and added your first package! 
 
-:::info 
-Let's explore what exactly you can do with this package. 
-At the bottom of the Connect Application you'll find a button with 'invoice'. This allows you to open an invoice document. The invoice document helps contributors to get paid for their work through crypto, stablecoins or a number of other currencies. Contributors can change the state of their invoice from draft to issued, while processors or clients can follow up on the payment of these invoices. In the next steps you can explore this for yourself. 
-:::
-
 ## Step 3: Run the Connect App in Studio mode
 To run the package locally in Connect Studio (our collaboration and contributor app), run the `ph connect` command. 
 

package/docs/academy/01-GetStarted/01-CreateNewPowerhouseProject.md

@@ -82,7 +82,9 @@ In the terminal, you will be asked to enter the project name. Fill in the projec
 
     A new browser window will open and you will see the Connect application. If it doesn't open automatically, you can open it manually by navigating to `http://localhost:3000/` in your browser.
 
-    You will see your local drive and a button to create a new drive. 
+    You will see your local drive and a button to create a new drive.    
+    If you local drive is not present navigate into Settings in the bottom left corner. Settings > Danger Zone > Clear Storage.    
+    Clear the storage of your localhost application as it might has an old session cached.   
 
 :::tip
 A **drive** is a folder to store and organize your documents in. Powerhouse offers the ability to build customized 'Drive Apps' for your documents. Think of a Drive App as a specialized lens—it offers **different ways to visualize, organize, and interact with** the data stored within a drive, making it more intuitive and efficient for specific use cases. To learn more, visit [Building A Drive App](/academy/MasteryTrack/BuildingUserExperiences/BuildingADriveExplorer)

package/docs/academy/01-GetStarted/02-DefineToDoListDocumentModel.md

@@ -79,7 +79,7 @@ To be able to define the document model, you need to open the document model edi
 ### The steps below show you how to do this:
 
 1. In the Connect application, click on **'document model'** to open the document model specification editor.
-2. Name your document model 'ToDoList' in the Connect application, paying close attention to capitalization. 
+2. Name your document model '**ToDoList**' in the Connect application, paying close attention to capitalization. 
 3. You'll be presented with a form to fill in metadata about the document model. Fill in the details in the respective fields. 
 
     In the **Document Type** field, type `powerhouse/todolist`. This defines the new type of document that will be created with this document model specification.

package/docs/academy/01-GetStarted/03-ImplementOperationReducers.md

@@ -111,10 +111,10 @@ Here are the tests for the three operations implemented in the reducers file. Th
 <details>
 <summary>Operation Reducers Tests</summary>
 ```typescript
-import utils from '../../gen/utils';
-import { reducer } from '../../gen/reducer';
-import * as creators from '../../gen/creators';
-import { ToDoListDocument } from '../../gen/types';
+import utils from '../../gen/utils.js';
+import { reducer } from '../../gen/reducer.js';
+import * as creators from '../../gen/creators.js';
+import { ToDoListDocument } from '../../gen/types.js';
 
 // REMARKS:
 // These tests demonstrate the event sourcing principles of our document model.

package/docs/academy/01-GetStarted/04-BuildToDoListEditor.md

@@ -29,7 +29,7 @@ Manual build steps are typically only needed when publishing packages.
 
 ## ToDoList Editor
 
-Below is the complete code for the To-Do List editor. 
+Below is the complete code for the To-Do List editor. Paste this code in `editors/to-do-list/editor.tsx`.
 
 <details>
 <summary>Complete ToDoList Editor Example (using Tailwind CSS)</summary>
@@ -43,7 +43,7 @@ import {
     ToDoItem,
     actions,
     ToDoListDocument,
-} from '../../document-models/to-do-list';
+} from '../../document-models/to-do-list/index.js';
 import { useState } from 'react';
 
 // EditorProps is a generic type that provides the document and a dispatch function.
@@ -207,16 +207,12 @@ The editor will update dynamically, so you can play around with your editor styl
 Congratulations!
 If you managed to follow this tutorial until this point, you have successfully implemented the **ToDoList** document model with its reducer operations and editor. 
 
-### Up Next: Drive Explorers & Drive Apps
-
-Now you can move on to creating a [custom drive explorer](/academy/MasteryTrack/BuildingUserExperiences/BuildingADriveExplorer) for your ToDoList document.    
-Imagine you have many ToDoLists sitting in a drive. A custom drive explorer will allow you to organize and track them at a glance, opening up a new world of possibilities to increase the functionality of your documents!
-
-
 ### Up Next: Mastery Track
 
-In the [Mastery Track chapther: Document Model Creation](/academy/MasteryTrack/DocumentModelCreation/WhatIsADocumentModel) we guide you through the theoretics of the previous steps while created a more advanced ToDoList.
+In the [Mastery Track chapther: Document Model Creation](/academy/MasteryTrack/DocumentModelCreation/WhatIsADocumentModel) we guide you through the theoretics of the previous steps while created a more advanced version of the ToDoList.
+
 You will learn: 
 - The in's & out's of a document model.
 - How to use UI & Scalar components from the Document Engineering system.
+- How to build Custom Drive Apps or Drive Explorers. 
 

package/docs/academy/01-GetStarted/home.mdx

@@ -85,15 +85,7 @@ import BrowserOnly from '@docusaurus/BrowserOnly';
     position: 'relative'
   }}>
     <img src="/img/Union.svg" alt="Powerhouse Union" width="250" />
-    <div style={{
-      position: 'absolute',
-      top: '18px',
-      backgroundColor: 'white',
-      padding: '8px 16px',
-      borderRadius: '8px',
-      textAlign: 'center',
-      zIndex: 2,
-    }}>
+    <div className={styles.masteryTrackTitle}>
       <h3 className="card-title" style={{ margin: 0 }}>Mastery Track</h3>
     </div>
   </div>

package/docs/academy/01-GetStarted/styles.module.css

@@ -96,4 +96,35 @@
 :global(.path-button:hover) {
   background: #ffffff;
   border-color: #d1d5db;
+}
+
+.masteryTrackTitle {
+  background-color: white;
+  padding: 8px 16px;
+  border-radius: 8px;
+  text-align: center;
+  z-index: 2;
+  position: absolute;
+  top: 18px;
+}
+
+:global([data-theme='dark']) .masteryTrackTitle {
+  background-color: var(--ifm-card-background-color);
+  border: 1px solid var(--ifm-color-emphasis-200);
+}
+
+:global([data-theme='dark']) .pathCard {
+  background: var(--ifm-card-background-color);
+  border: 1px solid var(--ifm-color-emphasis-200);
+}
+
+:global([data-theme='dark']) :global(.path-button) {
+  background: var(--ifm-color-emphasis-100);
+  border-color: var(--ifm-color-emphasis-200);
+  color: var(--ifm-font-color-primary);
+}
+
+:global([data-theme='dark']) :global(.path-button:hover) {
+  background: var(--ifm-color-emphasis-200);
+  border-color: var(--ifm-color-emphasis-300);
 } 

package/docs/academy/02-MasteryTrack/01-BuilderEnvironment/02-StandardDocumentModelWorkflow.md

@@ -1,9 +1,13 @@
-# Creating Powerhouse packages
+# Create Powerhouse packages
 
-This tutorial guides you through creating a Powerhouse Document Model, from initial setup to publishing a distributable package. We'll leverage the Powerhouse CLI and Connect Studio Mode for a streamlined development experience.
+:::warning
+**This tutorial is a summary for builders that are familiar with building document models**.    
+It guides you through creating a Powerhouse Document Model, from initial setup to publishing a distributable package. 
+Please start with the '**Get Started**' Chapter or '**Document Model Creation**' section if you are unfamiliar with building a document model.
+:::
 
 <details>
-<summary>Key Commands</summary>
+<summary>Key Commands that you'll use in this flow</summary>
 
 -   `pnpm install -g ph-cmd`: Installs the Powerhouse CLI globally.
 -   `ph init`: Initializes a new Powerhouse project or sets up the local environment.

package/docs/academy/02-MasteryTrack/01-BuilderEnvironment/03-BuilderTools.md

@@ -1,6 +1,6 @@
 # Powerhouse Builder Tooling
 
-This page provides an overview of all the builder tooling offered by the Powerhouse ecosystem.
+This page provides an overview of all the builder tooling offered by the Powerhouse ecosystem.   
 This list will be maintained and updated as our toolkit grows.
 
 ## Powerhouse Command Line Interface

package/docs/academy/02-MasteryTrack/02-DocumentModelCreation/01-WhatIsADocumentModel.md

@@ -2,10 +2,16 @@
 
 :::tip
 This chapter on **Document Model Creation** will help you with an in depth practicial understanding while building an **advanced ToDoList** document model. 
-If you have completed the Get Started tutorial you will revisit familiar topics. 
+Although not required, if you have completed the 'Get Started' tutorial you will revisit familiar topics and can update your existing document model.
 :::
 
-A Document Model is: 
+:::info **Definition: What is a Document Model?**
+A Document Model is a programmable document structure that defines how data is stored, changed, and interpreted in a decentralized system. It acts like a living blueprint—capturing state, tracking changes, and enabling interaction through defined operations.
+
+For instance, an invoice document model might define fields like *issuer*, *lineItems*, and *status*, with operations such as *AddLineItem* and *MarkAsPaid*.
+:::
+
+A Document Model can be understood as: 
 - A structured software framework that represents and **manages business logic** within a digital environment. 
 - A sophisticated template that **encapsulates the essential aspects of a digital process or a set of data**. 
 - A blueprints that define how data is **captured, manipulated, and visualised** within a system. 
@@ -37,19 +43,19 @@ Example of a **GraphQL-like state schema** for an invoice document:
 
 ```graphql
 type InvoiceState {
-  id: OID!             # Unique identifier for the invoice
-  issuer: OID!         # Reference to the issuing entity
-  recipient: OID!      # Reference to the recipient entity
-  status: String @default(value: "DRAFT") # Invoice status
-  dueDate: DateTime    # Payment due date
+  id: OID!                # Unique identifier for the invoice
+  issuer: OID!            # Reference to the issuing entity
+  recipient: OID!         # Reference to the recipient entity
+  status: String          # (value: "DRAFT") # Invoice status
+  dueDate: DateTime       # Payment due date
   lineItems: [LineItem!]! # List of line items
-  totalAmount: Currency  # Computed field for total invoice value
+  totalAmount: Currency   # Computed field for total invoice value
 }
 
 type LineItem {
   id: OID!
   description: String
-  quantity: Int @default(value: 1)
+  quantity: Int 
   unitPrice: Currency
 }
 ```
@@ -58,7 +64,6 @@ type LineItem {
 
 - Uses **GraphQL-like definitions** for a **clear, structured schema**.
 - Supports **custom scalar types** like `OID`, `Currency`, and `DateTime`. Or other Web3 specific scalars
-- Allows **default values** using `@default(value: "DRAFT")`.
 - Defines **relationships** using object references (`OID!`).
 
 The state schema acts as a **template** for document instances. Every new invoice created will follow this structure.
@@ -75,7 +80,7 @@ Example operations for modifying an invoice:
 input AddLineItemInput {
   invoiceId: OID!
   description: String
-  quantity: Int @default(value: 1)
+  quantity: Int 
   unitPrice: Currency
 }
 
@@ -89,7 +94,8 @@ input MarkAsPaidInput {
 }
 ```
 
-Each operation **modifies the document state** without altering past data. Instead, a new event is appended to the document history.
+Each operation **modifies the document state** without altering past data.    
+Instead, a new event is appended to the document history.
 
 ---
 
@@ -184,14 +190,16 @@ This removes the need for **complex database joins** and allows for **fast, stru
 
 Document Models offer a range of features that can be leveraged to create sophisticated, automated, and data-driven solutions:
 
-- **API Integration**: Document Models can be integrated with Switchboard API or external APIs, allowing for the exchange of data between Connect and other systems or services.
-
-- **Data Analysis**: The structured nature of Document Models makes them ideal for data analysis and reporting. Users can extract insights and generate reports based on the data captured within the models which is accessible through read models. (Operational data + Analytics data which takes into account time series of the data). 
-
-- **Version Control**: Similar to how Git manages changes to source code, Document Models in Connect will support version control, enabling users to track changes, compare different versions, and ensure data integrity over time.
+- **Automation**: Automate workflows using consistent, structured document logic.
+- **Auditability**: Maintain a full history of changes for compliance and transparency.
+- **API Integration**: Seamlessly connect with Switchboard or external APIs for data exchange.
+- **Data Analysis**: Enable real-time and historical insights through structured read models.
+- **Version Control**: Track and compare document states over time, similar to Git.
+- **Collaboration**: Empower decentralized teams to build, modify, and share documents asynchronously.
+- **Extensibility**: Add new fields, operations, and integrations over time without rewriting logic.
 
 Document Models are a powerful primitive within the Powerhouse vision, offering a flexible, structured, and efficient way to manage business logic and data. 
 
 ### Up Next: How to build a Document Model
 
-In the next chapters, we'll teach you how to build a ToDoList document model while explaining all of the theory that is involved. 
+In the next chapters, we'll teach you how to build a ToDoList document model while explaining all of the theory that is involved.

package/docs/academy/02-MasteryTrack/02-DocumentModelCreation/02-SpecifyTheStateSchema.md

@@ -31,6 +31,7 @@ You can modify types using lists and non-null indicators:
 ## Example: ToDoList State Schema
 
 Let's revisit the `ToDoList` example from the "Define the ToDoList document specification" tutorial.
+Only this time, we'll also add a 'Stats' type. Since we want to keep track of the number of completed To-Do's.
 
 ```graphql
 # The state of our ToDoList
@@ -44,6 +45,12 @@ type ToDoItem {
   text: String!
   checked: Boolean!
 }
+# The statistics on our to-do's
+type ToDoListStats {
+  total: Int!
+  checked: Int!
+  unchecked: Int!
+}
 ```
 
 ### Breakdown:
@@ -59,6 +66,11 @@ type ToDoItem {
     *   `text: String!`: The textual description of the to-do item. It cannot be null, ensuring every to-do has a description.
     *   `checked: Boolean!`: Indicates whether the to-do item is completed. It defaults to a boolean value (true or false) and cannot be null.
 
+*   **`ToDoListStats` type**: This type holds the summary statistics for the to-do list.
+    *   `total: Int!`: The total count of all to-do items. This field must be an integer and cannot be null.
+    *   `checked: Int!`: The number of to-do items that are marked as completed. This must be an integer and cannot be null.
+    *   `unchecked: Int!`: The number of to-do items that are still pending. This also must be an integer and cannot be null.
+
 ## Best Practices for Designing Your State Schema
 
 1.  **Start Simple, Iterate**: Begin with the core entities and properties. You can always expand and refine your schema as your understanding of the document's requirements grows.
@@ -73,5 +85,61 @@ type ToDoItem {
 
 By carefully defining your state schema, you lay a solid foundation for your Powerhouse document model, making it robust, maintainable, and easy to work with. The schema dictates not only how data is stored but also how it can be queried and mutated through operations, which will be covered in the next section.
 
-At the end of this Document Model Creation Chapter you will find the ToDoList Repository where you can explore the code and implementation of all the items we have discussed. 
-You'll be able to run the advanced ToDoList in Connect Studio and explore the reducers and editor code. 
+## Practical Implementation: Defining the State Schema in Connect
+
+Now that you understand the concepts behind the state schema, let's put it into practice. This section will guide you through creating a document model specification for the advanced ToDoList example discussed above.
+
+<details>
+<summary>Tutorial: The State Schema Specification</summary> 
+
+### Prerequisites
+
+-   You have a Powerhouse project set up. If not, please follow the [Create a new Powerhouse Project](../../GetStarted/CreateNewPowerhouseProject) tutorial.
+-   Connect Studio is running. If not, navigate to your project directory in the terminal and run `ph connect`.
+
+### Steps
+
+1.  **Create a New Document Model**:
+    -   With Connect Studio open in your browser, navigate into your local drive.
+    -   At the bottom of the page in the 'New Document' section, click the `DocumentModel` button to create a new document model specification.
+
+2.  **Define Document Metadata**:
+    -   **Name**: Give your document model a descriptive name, for example, `ToDoList`. **Pay close attention to capitalization, as it influences our code.**
+    -   **Document Type**: In the 'Document Type' field, enter a unique identifier for this document type, for instance, `powerhouse/todolist`.
+
+3.  **Specify the State Schema**:
+    -   In the code editor provided, you'll see a template for a GraphQL schema.
+    -   Replace the entire content of the editor with the advanced `ToDoList` schema we've designed in this chapter:
+
+    ```graphql
+    # The state of our ToDoList
+    type ToDoListState {
+      items: [ToDoItem!]!
+    }
+
+    # A single to-do item
+    type ToDoItem {
+      id: ID!
+      text: String!
+      checked: Boolean!
+    }
+    # The statistics on our to-do's
+    type ToDoListStats {
+      total: Int!
+      checked: Int!
+      unchecked: Int!
+    }
+    ```
+
+4.  **Sync Schema and View Initial State**:
+    -   After pasting the schema, click the **'Sync with schema'** button.
+    -   This action processes your schema and generates an initial JSON state for your document model based on the `ToDoListState` type. You can view this initial state, which helps you verify that your schema is structured correctly.
+
+    For now, you can ignore the "Modules & Operations" section. We will define and implement the operations that modify this state in the upcoming sections of this Mastery Track.
+
+By completing these steps, you have successfully specified the data structure for the advanced ToDoList document model. The next step is to define the operations that will allow users to interact with and change this state.
+
+</details>
+
+For a complete, working example, you can always refer to the [Example ToDoList Repository](./07-ExampleToDoListRepository.md) which contains the full implementation of the concepts discussed in this Mastery Track.
+

package/docs/academy/02-MasteryTrack/02-DocumentModelCreation/03-SpecifyDocumentOperations.md

@@ -16,10 +16,9 @@ Each operation acts as a command that, when applied, transitions the document fr
 
 ## Connecting Operations to the Schema
 
-In the "Define ToDoList Document Model" guide, we used GraphQL `input` types to define the structure of the data required for each operation. Let's revisit that:
+In the "Define ToDoList Document Model" chapter in the "Get Started" guide, we used GraphQL `input` types to define the structure of the data required for each operation. Let's revisit that:
 
 ```graphql
-# From 02-DefineToDoListDocumentModel.md
 # Defines a GraphQL input type for adding a new to-do item
 input AddTodoItemInput {
   id: ID!
@@ -96,7 +95,6 @@ The generated code from `ph generate` (as seen in `03-ImplementOperationReducers
 For example, the `ToDoListToDoListOperations` type generated by Powerhouse will expect methods corresponding to `addTodoItemOperation`, `updateTodoItemOperation`, and `deleteTodoItemOperation`.
 
 ```typescript
-// From 03-ImplementOperationReducers.md
 import { ToDoListToDoListOperations } from '../../gen/to-do-list/operations.js';
 
 export const reducer: ToDoListToDoListOperations = {
@@ -112,8 +110,65 @@ export const reducer: ToDoListToDoListOperations = {
 };
 ```
 
+## Practical Implementation: Defining Operations in Connect
+
+Now that you understand the theory, let's walk through the practical steps of defining these operations for our `ToDoList` document model within the Powerhouse Connect application.
+
+<details>
+<summary>Tutorial: Specifying `ToDoList` Operations</summary>
+
+Assuming you have already defined the state schema for the `ToDoList` as covered in the previous section, follow these steps to add the operations:
+
+1.  **Create a Module for Operations:**
+    Below the schema editor in Connect, find the input field labeled `Add module`. Modules help organize your operations.
+    *   Type `to_do_list` into the field and press Enter.
+
+2.  **Add the `ADD_TODO_ITEM` Operation:**
+    A new field, `Add operation`, will appear under your new module.
+    *   Type `ADD_TODO_ITEM` into this field and press Enter.
+    *   An editor will appear for the operation's input type. You need to define the data required for this operation. Paste the following GraphQL `input` definition into the editor:
+
+    ```graphql
+    # Defines a GraphQL input type for adding a new to-do item
+    input AddTodoItemInput {
+      id: ID!
+      text: String!
+    }
+    ```
+
+3.  **Add the `UPDATE_TODO_ITEM` Operation:**
+    *   In the `Add operation` field again, type `UPDATE_TODO_ITEM` and press Enter.
+    *   Paste the corresponding `input` definition into its editor:
+
+    ```graphql
+    # Defines a GraphQL input type for updating a to-do item
+    input UpdateTodoItemInput {
+      id: ID!
+      text: String
+      checked: Boolean
+    }
+    ```
+
+4.  **Add the `DELETE_TODO_ITEM` Operation:**
+    *   Finally, type `DELETE_TODO_ITEM` in the `Add operation` field and press Enter.
+    *   Paste its `input` definition:
+
+    ```graphql
+    # Defines a GraphQL input type for deleting a to-do item
+    input DeleteTodoItemInput {
+      id: ID!
+    }
+    ```
+
+5.  **Review and Export:**
+    After adding all three operations, your document model specification in Connect is complete for now. You can see how each operation (`ADD_TODO_ITEM`, etc.) is now explicitly linked to an input type that defines its payload.
+
+    The next step in a real project would be to click the `Export` button to save this specification file. In the next chapter, we will see how this exported file is used to generate code for our reducers.
+
+</details>
+
 ## Conclusion
 
-Specifying document operations is a foundational step in building robust and predictable document models in Powerhouse. By clearly defining the "what" (the operation and its input) before implementing the "how" (the reducer logic), you create a clear contract for state transitions. This approach enhances type safety, testability, and the overall maintainability of your document model.
+Specifying document operations is a foundational step in building robust and predictable document models in Powerhouse. By clearly defining the **"what" (the operation and its input)** before implementing the **"how" (the reducer logic)**, you create a clear contract for state transitions. This approach enhances type safety, testability, and the overall maintainability of your document model.
 
 In the next section, we will dive deeper into the implementation of the reducer functions for these specified operations.

package/docs/academy/02-MasteryTrack/02-DocumentModelCreation/04-UseTheDocumentModelGenerator.md

@@ -90,22 +90,42 @@ Leveraging the `ph generate` command offers numerous advantages:
 5.  **Alignment with Powerhouse Ecosystem:** The generated code is designed to integrate seamlessly with other parts of the Powerhouse ecosystem, such as the reducer execution engine and UI components.
 6.  **Single Source of Truth:** Ensures that your codebase (especially types and action creators) stays synchronized with the document model specification defined in Connect. If the specification changes, regenerating the model will update these components accordingly.
 
-## Example Workflow Snippet
+## Practical Implementation: Generating the `ToDoList` Model
 
-Let's assume you have defined a `ProjectTask` document model and exported `ProjectTask.phdm.zip`.
+Now that you understand what the Document Model Generator does, let's walk through the practical steps of using it with our `ToDoList` example.
 
-1.  **Navigate to your Powerhouse project root in the terminal.**
-2.  **Run the generator:**
+<details>
+<summary>Tutorial: Generating the `ToDoList` Document Model</summary>
+
+This tutorial assumes you have completed the previous steps in this Mastery Track, where you defined the state schema and operations for the `ToDoList` model in Connect and exported it.
+
+### Prerequisites
+
+*   **`ToDoList.phdm.zip` file**: You must have the document model specification file exported from Connect. If you do not have this file, please revisit the previous sections on specifying the state schema and operations.
+
+### Steps
+
+1.  **Place the Specification File in Your Project**:
+    *   Navigate to the root directory of your Powerhouse project.
+    *   Move or copy your `ToDoList.phdm.zip` file into this directory.
+
+2.  **Run the Generator Command**:
+    *   Open your terminal in the root directory of your Powerhouse project.
+    *   Execute the `ph generate` command, pointing to your specification file:
     ```bash
-    ph generate ProjectTask.phdm.zip
+    ph generate ToDoList.phdm.zip
     ```
-3.  **Explore the generated files:**
-    You would now find a new directory `document-models/project-task/` containing:
-    *   `project-task/spec.json`
-    *   `project-task/schema.graphql`
-    *   `project-task/gen/types.ts` (with `ProjectTaskState`, `AssignUserInput`, etc.)
-    *   `project-task/gen/operations.ts` (with `creators.assignUser(...)`, `creators.completeTask(...)`, etc.)
-    *   `project-task/src/reducers/project-task.ts` (with empty functions like `assignUserOperation`, `completeTaskOperation` awaiting your implementation).
+
+3.  **Explore the Generated Files**:
+    *   After the command completes successfully, you will find a new directory: `document-models/to-do-list/`.
+    *   Take a moment to explore its contents, which will match the structure described earlier in this document:
+        *   `spec.json` and `schema.graphql`: The definition of your model.
+        *   `gen/`: Type-safe, generated code including `types.ts`, `operations.ts`, etc.
+        *   `src/`: The skeleton for your implementation, most importantly `src/reducers/to-do-list.ts`, which will contain empty functions for `addTodoItemOperation`, `updateTodoItemOperation`, and `deleteTodoItemOperation`, ready for you to implement.
+
+With these files generated, you have successfully scaffolded your document model. The project is now set up for you to implement the core business logic.
+
+</details>
 
 ## Next Steps