@powerhousedao/academy 5.0.3 → 5.0.4

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 5.0.4 (2025-11-18)
+
+This was a version bump only for @powerhousedao/academy to align it with other projects, there were no code changes.
+
 ## 5.0.3 (2025-11-13)
 
 This was a version bump only for @powerhousedao/academy to align it with other projects, there were no code changes.

package/docs/academy/00-EthereumArgentinaHackathon.md

@@ -0,0 +1,207 @@
+---
+id: EthereumArgentinaHackathon
+title: Ethereum Argentina Hackathon
+---
+
+# Ethereum Argentina Hackathon
+
+**November 19-20, 2024**
+
+Welcome to the Vetra hacker page for the Ethereum Argentina Hackathon! We're excited to support developers building with Powerhouse during this event.
+
+## Overview
+
+Join us for two days of intensive development support as you build decentralized applications using the Vetra framework. Our team will be available online and at the mentor's table to help you navigate the builder platform, answer questions, and guide you through best practices.
+
+## 📅 Event Details
+
+- **Dates**: November 19-20, 2024
+- **Format**: Online & IRL Developer Support
+- **Time Zone**: Argentina Time (ART)
+- **Support Hours at Mentor Table @ la Rural**: Please get in touch [on Discord to schedule](https://discord.gg/pwQJwgaQKd)
+- **Hackathon informations**: [Taiki Hackathon](https://taikai.network/ethargentina/hackathons/tierra-de-buidlers-2025/overview)
+
+## 🚀 Getting Started
+
+<details>
+<summary> Vetra Introduction & Follow Along Demo </summary>
+
+Please Rewatch our Hackathon introduction & follow along tutorial. 
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/R5MAaGaopJg" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
+
+Find a complete overview of how to use the Vetra Studio for you project [here](./01-GetStarted/05-VetraStudio.md)
+
+**Quick Start Summary**
+
+- Step 1: Install the powerhouse-CLI: `pnpm install -g ph-cmd`
+- Step 2: Initialize a project & directory `ph init my-project-name`
+- Step 3: CD into you project directory
+- Step 4: Launch Vetra Studio with the `ph vetra`command
+- Step 5: Add the necessary document models & editors for your intended solution in Vetra Studio
+- Step 6: If you're well versed in schema creation or graphql. Just talk with an agent about your imagined solution.
+- Step 7: Start your preferred agent to help you with the initial scaffolding of your schema, operations and reducers. 
+- Step 8: Test your implementation in the "Vetra Preview Drive" with the `ph vetra --watch`command. 
+- Step 9: Run pnpm build and push your project to a remote repository. Follow the package publishing [Tutorial](./02-MasteryTrack/05-Launch/02-PublishYourProject.md)
+
+**Basic tips** 
+- 1️⃣ Write a detailed description of your intented functionality inside the document model specification manifest
+- 2️⃣ Ask your agent to ask for clarifying questions before starting any ideation process. 
+- 3️⃣ For each document model you'll want to create an accompanying editor in vetra studio. 
+- 4️⃣ An 'App' specifcation is an drive that can act as an app because of the specific interface you create for it. 
+
+### Before the Hackathon
+
+1. **Set Up Your Environment**
+   - Install the Powerhouse CLI
+   - Set up your development environment
+   - Review the [Get Started Guide](./01-GetStarted/home.mdx)
+
+2. **Explore the Platform**
+   - Check out the [Demo Package](./01-GetStarted/00-ExploreDemoPackage.mdx)
+   - Familiarize yourself with [Document Models](./02-MasteryTrack/02-DocumentModelCreation/01-WhatIsADocumentModel.md)
+
+3. **Join Our Community**
+   - Discord: [Join our server](#)
+
+
+</details>
+
+:::tip Use your preferred AI agent
+Vetra studio is compatible with Cursor, Claude and Gemini. Find the dedicated markdown files to guide your agent with the correct instruction in your directory. Your agent should also have access to the MCP's available. 
+::: 
+
+
+## **Hackathon Project Ideas**
+
+Powerhouse is perfect for building:
+
+- **Real World Use-cases**: Every document can act as a mini ledger/blockchain. 
+- **Decentralized Applications**: Create apps with built-in version control and collaboration.
+- **Document-Based Systems**: Build structured data applications.
+- **Collaborative Tools**: Enable real-time multi-user editing.
+- **Data Management Platforms**: Create systems with queryable, structured data.
+
+### Coordination & DAO Design
+
+- 🧩 **What if** DAOs weren't chaotic? What documents would you need to make them coordinate like space X and ship like stripe?
+- 🎯 **What if** making decisions as a group felt like playing a co-op strategy game. With a clearly aligned vision, instant dashboards and a way to capture hard won knowledge in expertise into custom software for the Dao?
+
+:::tip IDEA
+The ultimate DAO Template toolkit where vision & mission documents influence guidelines & onboarding for contributors.
+:::
+
+---
+
+### GovTech & Public Infrastructure
+
+- 🗳 **What if** local governments had to reach consensus with residents before making a decision? How would that look like?
+- 🚧 **What if** you could submit pothole fixes or transit complaints into a civic DAO, and track the response like GitHub issues?
+- 🧾 **What if** municipal budgets were editable public documents with community feedback loops?
+
+:::tip IDEA
+An Open Source Enterprise Resource Planning-suite for municipalities & governments
+:::
+
+---
+
+### Education & Group Work
+
+- 📝 **What if** your group project auto-divided work, tracked contributions, and paid out in real-time?
+- 👾 **What if** "homework" was a multiplayer quest, and grades came from the DAO?
+- 🏫 **What if** we DAO-ified a classroom and let the students vote on rules, roles, and rewards?
+
+:::tip IDEA
+The remote classroom SAAS back-end that fosters connection, gives purpose to bullies and empowers younger generation to dream big again.
+:::
+
+---
+
+### 💸 Grants, Crypto, and Incentive Design
+
+- 💰 **What if** grant tooling felt like bounty hunting across a galaxy of projects?
+- 📊 **What if** every grant had a live budget dashboard, contributor feed, and impact score?
+- 🎮 **What if** you could stake on coordination itself, betting that people will work together well?
+
+:::tip IDEA
+The future of grant platforms that dares to imagine grants in new ways. With follow up, tracking and impact visualisations of teams, time, risk & resources invested.
+:::
+
+---
+
+### 💸 Lawmaking, Legislation & Legal
+
+- 🧑‍⚖️ **What if** any government or DAO could fork a legal template, customize it, and track changes in a public, composable way?
+- 🎨 **What if** legislation could be transparently co-created by citizens, NGOs, and governments all with aligned incentives?
+- 💻 **What if** legislation, contracts & templates could exist on an open-source market place like software?
+- 🤖 **What if** a network agent could create a legal vehicle by simply inputing  set of requirements and risk preferences (in non legalese)?
+- 🤝 **What if** 2 agents in a network could negotiate terms of an agreement according to predefined functions and risk parameters, without lawyers?
+
+:::tip IDEA
+Build a Decentralized Lawmaking Engine using Reactive Document Models
+:::
+
+
+## 🛠️ Resources
+
+### Documentation
+
+- [Quick Start Guide](./01-GetStarted/home.mdx)
+- [Create a New Project](./01-GetStarted/01-CreateNewPowerhouseProject.md)
+- [Define Document Models](./01-GetStarted/02-DefineToDoListDocumentModel.md)
+- [Build Editors](./01-GetStarted/04-BuildToDoListEditor.md)
+- [API References](./04-APIReferences/00-PowerhouseCLI.md)
+
+### Tutorials
+
+- [To-Do List Example](./01-GetStarted/02-DefineToDoListDocumentModel.md)
+- [Chatroom Use Case](./03-ExampleUsecases/Chatroom/02-CreateNewPowerhouseProject.md)
+
+## 🏆 Judging Criteria
+
+Projects will be evaluated based on:
+
+- **Usefulness & Impact**: How well does it solve a certain job or problem?
+- **Composability/Structure**: How are the different document models and / or drive apps collaborating?
+- **Clarity of the developer or user experience**: Did you unlock the secret sauce of UX & reactive documents?
+- **Alignment with Vetra/Powerhouse principles**: Local-first, auditable, usefull for common good. 
+
+## 📋 Submission Guidelines
+
+### What to Submit
+
+- GitHub repository with your code
+- (Video) presentation (2-3 minutes)
+- README with:
+  - Project description
+  - Setup instructions
+  - Screenshots/demos
+  - Technologies used
+
+The Powerhouse team will add you as a builder on the Vetra platform and host your application and drive. 
+
+
+## Tips for Success
+
+### Development Tips
+
+1. **Start Simple**: Begin with a basic implementation and iterate
+2. **Use Templates**: Leverage existing examples and templates
+3. **Ask Questions**: Don't hesitate to reach out for help
+4. **Test Early**: Test your application frequently during development
+5. **Document**: Keep notes on your decisions and implementations
+
+### Presentation Tips
+
+1. **Show, Don't Tell**: Live demos are more impactful than slides
+2. **Tell a Story**: Explain the problem you're solving
+3. **Highlight Innovation**: Show what makes your solution unique
+4. **Be Concise**: Respect the time limits for presentations
+5. **Prepare Backup**: Have screenshots/video in case of technical issues
+
+---
+
+**Good luck, and happy hacking! 🚀**
+
+*Last updated: November 17, 2025*
+

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

@@ -17,7 +17,7 @@ pnpm install -g ph-cmd
 Verify the installation:
 
 ```bash
-ph-cmd --version
+ph --version
 ```
 
 ## Step 2: Install the to-do list demo package

package/docs/academy/01-GetStarted/05-VetraStudio.md

@@ -1,31 +1,26 @@
 # Tool: Vetra Studio 
 
-This chapter introduces you to one of the most powerfull features of the Powerhouse development framework: Specification Driven AI-control.  In the **'Get Started'** chapter we've been making use of strict schema definition principles to communicate the intended use case of our reactive documents. 
-
 :::tip Important
-The **schema definition language**, is a not only a shared language that bridges the gap between developer, designer and analyst but also the gap between **builder and AI-agent**. 
-:::
 
 ## Vision: Specification Driven AI
 
-At Powerhouse we are embracing the progress of AI assisted coding while unlocking the next level of AI control through **specification driven AI control**.
+In the **'Get Started'** chapter we've been making use of strict schema definition principles to communicate the intended use case of our reactive documents. 
+The **schema definition language**, is a not only a shared language that bridges the gap between developer, designer and analyst but also the gap between builder and AI-agent through **specification driven AI control**.
 
 - Communicate your solution and intent through a structured specification framework designed for AI collaboration.
 - Specifications enable precise, iterative edits, since all our specification documents are machine-readable and executable.
-- Specifications offer the ability to update exact parameters and properties as your specs evolve in lock-step with your agent. 
-- Specifications turn fragile sandcastles into solid, editable, and maintainable functionality with predictable results.
-
-This approach allows for the creation of editable specifications, enabling business analysts to modify details and instruct the AI to generate code based on updated specifications.
-It results in composable, maintainable, and scalable functionality.
+:::
 
 ## Introducing Vetra Studio
 
-**Vetra Studio** serves as a centralized hub for developers to access and manage specifications. 
-It allows developers to open packages (Git repositories with metadata) from a Vetra package library, providing access to a remote Vetra drive where all specifications are stored. 
+**Vetra Studio Drive**: Serves as a hub for developers to access, manage & share specification through a remote Vetra drive.   
+**Vetra Package Library**: Store, publish and fork git repositories of packages in the Vetra Package Library.    
+Visit the [Vetra Package Library here](https://vetra.io/packages)
 
-This setup ensures that all necessary documentation and project requirements are in one accessible location, streamlining communication and agreement on requirements and operations. Additionally, **Vetra Studio** functions as the orchestration hub where you as a builder assemble all the necessary specifications for your intended use-case, software solution or package. For each of the different **modules** that together form a package a specification document can be created in **Vetra Studio**. 
+**Vetra Studio Drive** functions as the orchestration hub where you as a builder assemble all the necessary specifications for your intended use-case, software solution or package. For each of the different **modules** that together form a package a **specification document** can be created in Vetra Studio Drive. 
 
 As Vetra Studio matures each of these specification documents will offer an interface by which you as a builder get more control over the modules that make up your package. 
+For now they offer you a template for code generation. 
 
 <figure className="image-container">
   <img
@@ -37,14 +32,14 @@ As Vetra Studio matures each of these specification documents will offer an inte
 
 ### Module Categories
 
-#### 1. Document Models 
+### 1. Document Models 
 - **Document model specification**: Defines the structure and operations of a document model using GraphQL SDL, ensuring consistent data management and processing.
 
-#### 2. User Experiences
+### 2. User Experiences
 - **Editor specification**: Outlines the interface and functionalities of a document model editor, allowing users to interact with and modify document data.
 - **Drive-app specification**: Specifies the UI and interactions for managing documents within a Drive, providing tailored views and functionalities.
 
-#### 3. Data integrations
+### 3. Data integrations
 - **Subgraph specification**: Details the connections and relationships within a subgraph, facilitating efficient data querying and manipulation.
 - **Codegen Processor Specification**: Describes the process for automatically generating code from document model specifications, ensuring alignment with intended architecture.
 - **RelationalDb Processor Specification**: Defines how relational databases are structured and queried, supporting efficient data management and retrieval.
@@ -57,6 +52,31 @@ As Vetra Studio matures each of these specification documents will offer an inte
   <figcaption>The Vetra Studio Drive, a builder app that collects all of the specification of a package.</figcaption>
 </figure>
 
+### Configure a Vetra drive in your project
+
+You can connect to a remote vetra drive instead of using the local one auto-generated when you run `ph vetra`
+If you run Vetra without the `--remote-drive` option: Vetra will create a Vetra drive for you that is local and lives in your local environment / local browser storage. 
+If you provide the remote drive with `--remote-drive` argument: Vetra will use this drive instead of creating a local one. the remote drive can be hosted whatever you want.
+The powerhouse config includes a Vetra URL for consistent project configuration across different environments.
+
+```vetra: {
+    driveId: string;
+    driveUrl: string;
+};
+```
+
+Imagine you are a builder and want to work on, or continue with a set of specifications from your team mates. 
+You could then add the specific remote Vetra drive to your powerhouse configuration in the `powerhouse.config.json`file to get going. 
+
+```
+"vetra": {
+    "driveId": "bai-specifications",
+    "driveUrl": "https://switchboard.staging.vetra.io/d/bai-specifications"
+  }
+```
+
+An example of a builder team building on the Powerhouse Vetra Ecosystem and it's complementary Vetra Studio Drive specifications for the different packages be found [here](https://vetra.io/builders/bai)
+
 ## Vetra Studio Workflow
 
 ### 1. Launch Vetra Studio
@@ -72,6 +92,21 @@ In interactive mode:
 - Changes require explicit confirmation before being processed
 - Provides better control and visibility over document changes
 
+#### Watch Mode 
+
+```bash
+ph vetra --interactive --watch
+```
+In watch mode:
+
+- Adding `--watch` to your command enables dynamic loading for document-models and editors in Vetra studio and switchboard. 
+- When enabled, the system will watch for changes in these directories and reload them dynamically.
+
+:::warning Be Aware
+When you are building your document model the code can break the Vetra Studio environment. 
+A full overview of the Vetra Studio commands can be found in the [Powerhouse CLI](/academy/APIReferences/PowerhouseCLI#vetra)
+:::
+
 #### Standard Mode
 ```bash
 ph vetra
@@ -86,28 +121,42 @@ In standard mode:
 Vetra Studio integrates deeply with Claude through MCP (Model Control Protocol). This is where AI comes into the mix and you get the chance to have greater control and direction over what your llm is coding for you. 
 
 #### 1. Start the Reactor MCP:
+
+Make sure you are in the same directory as your project. 
+Claude will automatically recognize the necessary files and MCP tools. 
+
+```bash
+claude
+```
+
+Since you're interacting with a llm it has a high capacit for interpretating your intentions. 
+Any commands in the same trend will do the job. 
+
 ```bash
-ph mcp
+connect to the reactor mcp
 ```
 
 #### 2. Verify MCP connection:
 - Check that the Reactor MCP is available. 
 - Confirm Vetra Studio shows "Connected to Reactor MCP"
 
--  To learn what is a [Reactor] itself read (apps/academy/docs/academy/Architecture/WorkingWithTheReactor)
--  To learn more about the [Reactor MCP] read (apps/academy/docs/academy/GetStarted/ReactorMCP)
+```bash
+Connected to MCP successfully! I can see there's a
+  "vetra-4de7fa45" drive available. The reactor-mcp server is
+  running and ready for document model operations.
+```
 
-#### Key Reactor MCP Features:
-- Automatic document model creation from natural language descriptions
-- Smart editor generation based on document models
-- Automatically triggers code generation when documents reach valid state
+-  To learn what is a [Reactor](apps/academy/docs/academy/Architecture/WorkingWithTheReactor) read the reactor article
+-  To learn more about the [Reactor MCP](apps/academy/docs/academy/GetStarted/ReactorMCP) read the reactor MCP article
 
-The powerhouse config includes a vetra URL for consistent project configuration across different environments.
+### Key Reactor MCP Features
 
-:::tip
-- Vetra supports integration with custom remote drives, allowing users to create, share and manage documents within these drives.
+- It supports automatic document model creation from natural language descriptions
+- It implements a smart editor based on the underlying document models
+- It automatically triggers code generation when documents reach valid state
 - The MCP server enables the agent to work with both existing and newly created document models.
-:::
+- Vetra supports integration with custom remote drives, allowing users to create, share and manage documents within these drives.
+
 
 ### 3. Vetra Studio Package Creation Workflow
 

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

@@ -20,14 +20,14 @@ import BrowserOnly from "@docusaurus/BrowserOnly";
     <div className={styles.cardContent}>
       <div style={{ maxWidth: '960px', margin: '0 auto', textAlign: 'center' }}>
         <div style={{ marginBottom: '1.5rem' }}>
-          <p style={{ fontSize: '1.1rem', marginBottom: '1rem' }}><strong>Welcome to Powerhouse!</strong></p>
-          <p style={{ lineHeight: '1.6', color: '#444' }}>As a developer, you're about to dive into a <strong>unique ecosystem built to empower decentralized organizations</strong>. Powerhouse provides the software, infrastructure, and frameworks that enable scalable network organizations to operate efficiently.</p>
+          <p style={{ fontSize: '1.1rem', marginBottom: '1rem' }}><strong>Welcome to Powerhouse Vetra!</strong></p>
+          <p style={{ lineHeight: '1.6', color: '#444' }}>As a developer, you're about to dive into a <strong>unique ecosystem built to empower decentralized organizations</strong>. Powerhouse Vetra provides the software, infrastructure, and frameworks that enable scalable network organizations to operate efficiently.</p>
         </div>
         <div style={{ margin: '20px 0', textAlign: 'center' }}>
           <iframe
-            src="https://drive.google.com/file/d/17dDKy-hQeI4ZlLiUZ4xhnXL4bDhJB0N-/preview"
+            src="https://www.youtube.com/embed/wCrUgPrMtak"
             frameBorder="0"
-            allow="autoplay; fullscreen"
+            allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
             allowFullScreen
             title="Powerhouse Introduction Video"
             style={{

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

@@ -3,7 +3,7 @@
 Let's set up your machine to start building your first Document Model. Don't worry if this is your first time setting up a development environment - we'll guide you through each step!
 
 :::info
-If you've already set up **Git, Node, and pnpm**, your most important step is to install the **Powerhouse CLI** with the command: `pnpm install ph-cmd`. A global install is recommended if you want to use the command from any directory as a power user. In this case use `pnpm install -g ph-cmd`. The Powerhouse CLI is used to create, build, and run your Document Models and gives you direct access to a series of Powerhouse Builder Tools. Move to the end of this page to [verify your installation.](#verify-installation)
+If you've already set up **Git, Node.js 22, and a package manager (pnpm or npm)**, your most important step is to install the **Powerhouse CLI** with the command: `pnpm install -g ph-cmd` or `npm install -g ph-cmd`. A global install is recommended if you want to use the command from any directory as a power user. The Powerhouse CLI is used to create, build, and run your Document Models and gives you direct access to a series of Powerhouse Builder Tools. Move to the end of this page to [verify your installation.](#verify-installation)
 :::
 
 ---
@@ -43,13 +43,15 @@ node.js 22 is a tool that lets us run our application. Let's install it step by
    - Once the installer downloads, double-click it to start installation
    - Click "Next" through the installation wizard, leaving all settings at their defaults
 
-3. **Install pnpm:**
+3. **Install a package manager (pnpm or npm):**
    - Open PowerShell (no need for admin mode)
-   - Type this command and press Enter:
+   - For pnpm (recommended), type this command and press Enter:
 
    ```powershell
    npm install -g pnpm
    ```
+   
+   - Note: Node.js comes with npm by default, so npm is already available after installing Node.js
 
 4. **Verify Installation:**
    - Open PowerShell (no need for admin mode)
@@ -57,9 +59,11 @@ node.js 22 is a tool that lets us run our application. Let's install it step by
    ```powershell
    node --version
    pnpm --version
+   # or
+   npm --version
    ```
 
-   - You should see version numbers appear after each command (e.g., v18.17.0). If you do, congratulations - Node.js and pnpm are installed!
+   - You should see version numbers appear after each command (e.g., v22.x.x for Node.js). If you do, congratulations - Node.js and your package manager are installed!
 
 > **Note**: If node.js 22 commands don't work in VS Code, restart VS Code to refresh environment variables.
 
@@ -82,7 +86,7 @@ node.js 22 is a tool that lets us run our application. Let's install it step by
    brew install node@22
    ```
 
-   - Then, install pnpm:
+   - Then, optionally install pnpm (npm comes with Node.js):
 
    ```bash
    brew install pnpm
@@ -93,9 +97,11 @@ node.js 22 is a tool that lets us run our application. Let's install it step by
    ```bash
    node --version
    pnpm --version
+   # or
+   npm --version
    ```
 
-   - If you see version numbers, you've successfully installed Node.js and pnpm!
+   - If you see version numbers, you've successfully installed Node.js and your package manager!
 
 #### For Linux (Ubuntu/Debian):
 
@@ -109,10 +115,12 @@ node.js 22 is a tool that lets us run our application. Let's install it step by
    sudo apt update
    ```
 
-3. **Install node.js 22 and pnpm:**
+3. **Install node.js 22 and optionally pnpm:**
 
    ```bash
-   sudo apt install nodejs pnpm
+   sudo apt install nodejs
+   # Optionally install pnpm (npm comes with Node.js)
+   sudo apt install pnpm
    ```
 
 4. **Verify Installation:**
@@ -120,6 +128,8 @@ node.js 22 is a tool that lets us run our application. Let's install it step by
    ```bash
    node --version
    pnpm --version
+   # or
+   npm --version
    ```
 
    - If you see version numbers, you're all set!
@@ -234,6 +244,12 @@ The Powerhouse CLI (installed via the `ph-cmd` package) is a command-line interf
 pnpm install -g ph-cmd
 ```
 
+Or if you're using npm:
+
+```bash
+npm install -g ph-cmd
+```
+
 Key commands include:
 
 - `ph connect` for running the Connect application locally

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

@@ -10,13 +10,13 @@ Please start with the '**Get Started**' Chapter or '**Document Model Creation**'
 <details>
 <summary>Key commands that you'll use in this flow</summary>
 
-- `pnpm install -g ph-cmd`: Installs the Powerhouse CLI globally.
+- `pnpm install -g ph-cmd` or `npm install -g ph-cmd`: Installs the Powerhouse CLI globally.
 - `ph init`: Initializes a new Powerhouse project or sets up the local environment.
 - `ph connect`: Runs Connect in Studio Mode for local development and testing.
 - `ph generate <YourModelName.phdm.zip>`: Generates scaffolding code from an exported document model specification.
 - `ph generate --editor YourModelName --document-types powerhouse/YourModelName`: Generates an editor template for a document model.
-- `pnpm build`: Builds the project for production.
-- `pnpm run test`: Runs unit tests.
+- `pnpm build` or `npm run build`: Builds the project for production.
+- `pnpm run test` or `npm test`: Runs unit tests.
 - `npm login`: Logs into your NPM account.
 - `npm publish`: Publishes your package to NPM.
 - `ph install @your-org-ph/your-package-name`: Installs a published package into a local Powerhouse environment.
@@ -33,8 +33,14 @@ Ensure you have the Powerhouse Command Line Interface (`ph-cmd`) installed. This
 pnpm install -g ph-cmd
 ```
 
+Or if you're using npm:
+
+```bash
+npm install -g ph-cmd
+```
+
 :::info **Prerequisites**
-The [Prerequisites](/academy/MasteryTrack/BuilderEnvironment/Prerequisites) guide for detailed installation instructions for Node.js, pnpm, and Git if you haven't set them up yet.
+See the [Prerequisites](/academy/MasteryTrack/BuilderEnvironment/Prerequisites) guide for detailed installation instructions for Node.js 22, package managers (pnpm or npm), and Git if you haven't set them up yet.
 :::
 
 ### 1.2. Initialize your project environment
@@ -54,9 +60,9 @@ When installing or using the Powerhouse CLI commands you are able to make use of
 
 | Command                            | Description                                           |
 | ---------------------------------- | ----------------------------------------------------- |
-| **pnpm install -g ph-cmd**         | Install latest stable version                         |
-| **pnpm install -g ph-cmd@dev**     | Install development version                           |
-| **pnpm install -g ph-cmd@staging** | Install staging version                               |
+| **pnpm install -g ph-cmd** or **npm install -g ph-cmd**         | Install latest stable version                         |
+| **pnpm install -g ph-cmd@dev** or **npm install -g ph-cmd@dev**     | Install development version                           |
+| **pnpm install -g ph-cmd@staging** or **npm install -g ph-cmd@staging** | Install staging version                               |
 | **ph init**                        | Use latest stable version of the boilerplate          |
 | **ph init --dev**                  | Use development version of the boilerplate            |
 | **ph init --staging**              | Use staging version of the boilerplate                |
@@ -143,6 +149,12 @@ It's crucial to test your reducer logic. Write unit tests in the `document-model
 pnpm run test
 ```
 
+Or with npm:
+
+```bash
+npm test
+```
+
 ### 3.4. Implement the document editor
 
 A document editor provides the user interface for interacting with your document model in Connect. Generate an editor template:
@@ -262,6 +274,12 @@ Compile and optimize your project for production:
 pnpm build
 ```
 
+Or with npm:
+
+```bash
+npm run build
+```
+
 This command typically creates a `dist/` or `build/` directory with the compiled assets. Ensure your `package.json`'s `files` array includes this directory and other necessary assets like `manifest.json`, `document-models`, and `editors` if they are not part of the build output but need to be in the package.
 
 ### 4.5. Version control

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

@@ -20,6 +20,12 @@ The Powerhouse CLI (`ph-cmd`) is a command-line interface tool that provides ess
 pnpm install -g ph-cmd
 ```
 
+Or if you're using npm:
+
+```bash
+npm install -g ph-cmd
+```
+
 Key commands include:
 
 - `ph connect` for running the Connect application locally
@@ -36,9 +42,9 @@ When installing or using the Powerhouse CLI commands you are able to make use of
 
 | Command                            | Description                                           |
 | ---------------------------------- | ----------------------------------------------------- |
-| **pnpm install -g ph-cmd**         | Install latest stable version                         |
-| **pnpm install -g ph-cmd@dev**     | Install development version                           |
-| **pnpm install -g ph-cmd@staging** | Install staging version                               |
+| **pnpm install -g ph-cmd** or **npm install -g ph-cmd **         | Install latest stable version                         |
+| **pnpm install -g ph-cmd@dev** or **npm install -g ph-cmd@dev**     | Install development version                           |
+| **pnpm install -g ph-cmd@staging** or **npm install -g ph-cmd@staging** | Install staging version                               |
 | **ph init**                        | Use latest stable version of the boilerplate          |
 | **ph init --dev**                  | Use development version of the boilerplate            |
 | **ph init --staging**              | Use staging version of the boilerplate                |
@@ -62,6 +68,8 @@ If you need to perform a clean reinstallation of the Powerhouse CLI (`ph-cmd`),
 
 ```bash
 pnpm uninstall -g ph-cmd
+# or with npm
+npm uninstall -g ph-cmd
 ```
 
 2. Remove the Powerhouse configuration directory:
@@ -75,12 +83,18 @@ rm -rf ~/.ph
 ```bash
 # For the latest stable version
 pnpm install -g ph-cmd
+# or with npm
+npm install -g ph-cmd 
 
 # For the staging version
 pnpm install -g ph-cmd@staging
+# or with npm
+npm install -g ph-cmd@staging
 
 # For a specific version
 pnpm install -g ph-cmd@<version>
+# or with npm
+npm install -g ph-cmd@<version>
 ```
 
 This process ensures a clean slate by removing both the CLI tool and its configuration files before installing the desired version. It's particularly useful when:

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

@@ -1,8 +1,11 @@
 # What is a document model?
 
 :::tip
-This chapter on **Document Model Creation** will help you with an in depth practicial understanding while building an **advanced to-do list** document model.
-Although not required, if you have completed the 'Get Started' tutorial you will revisit familiar topics and can update your existing document model.
+This chapter on **Document Model Creation** will help you with an in-depth practical understanding while building an **advanced to-do list** document model.
+
+If you have completed the [Get Started](/academy/GetStarted/CreateNewPowerhouseProject) tutorial (which includes creating a simple to-do list document model), you will revisit familiar topics and can enhance your existing document model with the advanced features covered in this Mastery Track, such as statistics tracking.
+
+Although not required, completing the Get Started tutorial first is highly recommended as it provides a hands-on foundation for the concepts explored in depth here.
 :::
 
 :::info **Definition: What is a Document Model?**