]*href="([^"]*)"[^>]*>(.*?)<\/a>/g,
+ '$2'
+ );
+
+ // Decode HTML entities
+ cleanHTML = cleanHTML.replace(/&/g, "&");
+ cleanHTML = cleanHTML.replace(/</g, "<");
+ cleanHTML = cleanHTML.replace(/>/g, ">");
+ cleanHTML = cleanHTML.replace(/"/g, '"');
+ cleanHTML = cleanHTML.replace(/'/g, "'");
+ cleanHTML = cleanHTML.replace(/ /g, " ");
+
+ // Clean up whitespace
+ cleanHTML = cleanHTML.replace(/\s+/g, " ");
+ cleanHTML = cleanHTML.replace(/\s*<\/p>/g, "");
+
+ return cleanHTML.trim();
+}
+
+async function main() {
+ console.log("Fetching latest topics...");
+ const latestData = await fetchJSON("https://forum.livepeer.org/latest.json");
+
+ const topics = latestData.topic_list?.topics || [];
+ console.log(`Found ${topics.length} topics`);
+
+ // Filter out old pinned topics
+ const filteredTopics = topics.filter((t) => !isOldPinned(t));
+ console.log(`After filtering: ${filteredTopics.length} topics`);
+
+ // Get top 4
+ const top4 = filteredTopics.slice(0, 4);
+ console.log(`Processing top 4 topics...`);
+
+ const processedTopics = [];
+
+ for (const topic of top4) {
+ console.log(`Processing topic ${topic.id}: ${topic.title}`);
+
+ // Fetch full topic data
+ const topicData = await fetchJSON(
+ `https://forum.livepeer.org/t/${topic.id}.json`
+ );
+
+ // Extract first post
+ const firstPost = topicData.post_stream?.posts?.find(
+ (p) => p.post_number === 1
+ );
+
+ if (!firstPost) {
+ console.log(` No first post found, skipping`);
+ continue;
+ }
+
+ const htmlContent = cleanAndFormatHTML(firstPost.cooked || "");
+ const datePosted = topic.created_at
+ ? new Date(topic.created_at).toLocaleDateString("en-US", {
+ year: "numeric",
+ month: "short",
+ day: "numeric",
+ })
+ : "";
+
+ processedTopics.push({
+ title: topic.title,
+ href: `https://forum.livepeer.org/t/${topic.id}`,
+ author: `By ${firstPost.name || firstPost.username || "Unknown"} (@${
+ firstPost.username || "unknown"
+ })`,
+ content: htmlContent,
+ replyCount: (topic.posts_count || 1) - 1,
+ datePosted: datePosted,
+ });
+ }
+
+ console.log(`Processed ${processedTopics.length} topics`);
+
+ // Generate JavaScript export with exact formatting
+ let jsExport = "export const forumData = [\n";
+
+ processedTopics.forEach((item, index) => {
+ jsExport += " {\n";
+ jsExport += ` title: "${item.title
+ .replace(/\\/g, "\\\\")
+ .replace(/"/g, '\\"')}",\n`;
+ jsExport += ` href: "${item.href}",\n`;
+ jsExport += ` author: "${item.author
+ .replace(/\\/g, "\\\\")
+ .replace(/"/g, '\\"')}",\n`;
+
+ // Content with proper escaping and indentation
+ const escapedContent = item.content
+ .replace(/\\/g, "\\\\")
+ .replace(/"/g, '\\"')
+ .replace(/\n/g, " ");
+
+ jsExport += ` content:\n "${escapedContent}",\n`;
+ jsExport += ` replyCount: ${item.replyCount},\n`;
+ jsExport += ` datePosted: "${item.datePosted}",\n`;
+ jsExport += " }";
+
+ if (index < processedTopics.length - 1) {
+ jsExport += ",";
+ }
+ jsExport += "\n";
+ });
+
+ jsExport += "];\n";
+
+ // Write to file
+ const outputPath = "snippets/automations/forum/forumData.jsx";
+ fs.mkdirSync("snippets/automations/forum", { recursive: true });
+ fs.writeFileSync(outputPath, jsExport);
+ console.log(`Written to ${outputPath}`);
+}
+
+main().catch((err) => {
+ console.error("Error:", err);
+ process.exit(1);
+});
diff --git a/.github/scripts/fetch-ghost-blog-data.js b/.github/scripts/fetch-ghost-blog-data.js
new file mode 100644
index 000000000..44e0d2f0a
--- /dev/null
+++ b/.github/scripts/fetch-ghost-blog-data.js
@@ -0,0 +1,101 @@
+const https = require("https");
+const fs = require("fs");
+
+// Fetch JSON from URL
+function fetchJSON(url) {
+ return new Promise((resolve, reject) => {
+ https
+ .get(url, (res) => {
+ let data = "";
+ res.on("data", (chunk) => {
+ data += chunk;
+ });
+ res.on("end", () => {
+ try {
+ resolve(JSON.parse(data));
+ } catch (e) {
+ reject(e);
+ }
+ });
+ })
+ .on("error", reject);
+ });
+}
+
+// Safe HTML escape - only escape backticks for template literals
+function safeHTML(html) {
+ return (html || "").replace(/`/g, "\\`");
+}
+
+// Format date
+function formatDate(iso) {
+ return new Date(iso).toLocaleDateString("en-US", {
+ month: "short",
+ day: "numeric",
+ year: "numeric",
+ });
+}
+
+async function main() {
+ console.log("Fetching Ghost blog posts...");
+
+ const apiUrl =
+ "https://livepeer-studio.ghost.io/ghost/api/content/posts/?key=eaf54ba5c9d4ab35ce268663b0&limit=4&include=tags,authors";
+
+ const response = await fetchJSON(apiUrl);
+
+ if (!response.posts || response.posts.length === 0) {
+ console.log("No posts found");
+ return;
+ }
+
+ console.log(`Found ${response.posts.length} posts`);
+
+ // Process posts
+ const posts = response.posts.map((p) => ({
+ title: p.title,
+ href: p.url,
+ author: p.primary_author?.name
+ ? `By ${p.primary_author.name}`
+ : "By Livepeer Team",
+ content: safeHTML(p.html),
+ datePosted: formatDate(p.published_at),
+ img: p.feature_image || "",
+ excerpt: safeHTML(p.excerpt),
+ readingTime: p.reading_time || 0,
+ }));
+
+ // Generate JavaScript export with template literals
+ let jsExport = "export const ghostData = [\n";
+
+ posts.forEach((post, index) => {
+ jsExport += "{\n";
+ jsExport += ` title: \`${post.title}\`,\n`;
+ jsExport += ` href: \`${post.href}\`,\n`;
+ jsExport += ` author: \`${post.author}\`,\n`;
+ jsExport += ` content: \`${post.content}\`,\n`;
+ jsExport += ` datePosted: \`${post.datePosted}\`,\n`;
+ jsExport += ` img: \`${post.img}\`,\n`;
+ jsExport += ` excerpt: \`${post.excerpt}\`,\n`;
+ jsExport += ` readingTime: ${post.readingTime}\n`;
+ jsExport += "}";
+
+ if (index < posts.length - 1) {
+ jsExport += ",";
+ }
+ jsExport += "\n";
+ });
+
+ jsExport += "];\n";
+
+ // Write to file
+ const outputPath = "snippets/automations/ghost/ghostBlogData.jsx";
+ fs.mkdirSync("snippets/automations/ghost", { recursive: true });
+ fs.writeFileSync(outputPath, jsExport);
+ console.log(`Written to ${outputPath}`);
+}
+
+main().catch((err) => {
+ console.error("Error:", err);
+ process.exit(1);
+});
diff --git a/.github/scripts/fetch-youtube-data.js b/.github/scripts/fetch-youtube-data.js
new file mode 100644
index 000000000..63d35ddd7
--- /dev/null
+++ b/.github/scripts/fetch-youtube-data.js
@@ -0,0 +1,122 @@
+const https = require("https");
+const fs = require("fs");
+
+const YOUTUBE_API_KEY = process.env.YOUTUBE_API_KEY;
+const CHANNEL_ID = process.env.CHANNEL_ID || "UCzfHtZnmUzMbJDxGCwIgY2g";
+
+function httpsGet(url) {
+ return new Promise((resolve, reject) => {
+ https
+ .get(url, (res) => {
+ let data = "";
+ res.on("data", (chunk) => (data += chunk));
+ res.on("end", () => resolve(JSON.parse(data)));
+ })
+ .on("error", reject);
+ });
+}
+
+function parseDuration(duration) {
+ const match = duration.match(/PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?/);
+ if (!match) return 0;
+
+ const hours = parseInt(match[1] || 0);
+ const minutes = parseInt(match[2] || 0);
+ const seconds = parseInt(match[3] || 0);
+
+ return hours * 3600 + minutes * 60 + seconds;
+}
+
+function escapeForJSX(str) {
+ return str
+ .replace(/\\/g, "\\\\")
+ .replace(/'/g, "\\'")
+ .replace(/"/g, '\\"')
+ .replace(/\n/g, " ")
+ .replace(/\r/g, "")
+ .replace(/\t/g, " ");
+}
+
+async function main() {
+ // Step 1: Get recent videos
+ console.log("Fetching recent videos...");
+ const searchUrl = `https://www.googleapis.com/youtube/v3/search?part=snippet&channelId=${CHANNEL_ID}&maxResults=50&order=date&type=video&key=${YOUTUBE_API_KEY}`;
+ const searchResults = await httpsGet(searchUrl);
+
+ if (!searchResults.items || searchResults.items.length === 0) {
+ console.log("No videos found");
+ return;
+ }
+
+ // Step 2: Get video details for each video
+ console.log(
+ `Found ${searchResults.items.length} videos, fetching details...`
+ );
+ const videoIds = searchResults.items.map((item) => item.id.videoId).join(",");
+ const detailsUrl = `https://www.googleapis.com/youtube/v3/videos?part=contentDetails,snippet&id=${videoIds}&key=${YOUTUBE_API_KEY}`;
+ const detailsResults = await httpsGet(detailsUrl);
+
+ // Step 3: Process and filter videos
+ const videos = [];
+ for (const video of detailsResults.items) {
+ const duration = video.contentDetails.duration;
+ const durationSeconds = parseDuration(duration);
+ const snippet = video.snippet;
+
+ // Check if it's a livestream
+ const isLivestream =
+ snippet.liveBroadcastContent === "live" ||
+ snippet.liveBroadcastContent === "upcoming" ||
+ duration === "PT0S" ||
+ snippet.title.toLowerCase().includes("watercooler") ||
+ snippet.title.toLowerCase().includes("fireside");
+
+ // Filter out Shorts (≤60 seconds and not livestreams)
+ const isShort =
+ durationSeconds <= 60 && durationSeconds > 0 && !isLivestream;
+
+ if (!isShort) {
+ videos.push({
+ title: snippet.title,
+ href: `https://www.youtube.com/watch?v=${video.id}`,
+ author: `By ${snippet.channelTitle || "Livepeer"}`,
+ content: (snippet.description || "").substring(0, 500),
+ publishedDate: new Date(snippet.publishedAt).toLocaleDateString(
+ "en-US",
+ { month: "short", day: "numeric", year: "numeric" }
+ ),
+ duration: duration,
+ thumbnailUrl: snippet.thumbnails.high.url,
+ });
+ }
+ }
+
+ console.log(`Filtered to ${videos.length} non-Short videos`);
+
+ // Step 4: Generate JSX content
+ const jsxContent = `export const youtubeData = [
+${videos
+ .map(
+ (v) => ` {
+ title: '${escapeForJSX(v.title)}',
+ href: '${v.href}',
+ author: '${v.author}',
+ content: '${escapeForJSX(v.content)}...',
+ publishedDate: '${v.publishedDate}',
+ duration: '${v.duration}',
+ thumbnailUrl: '${v.thumbnailUrl}'
+ }`
+ )
+ .join(",\n")}
+];
+`;
+
+ // Step 5: Write to file
+ fs.writeFileSync("snippets/automations/youtube/youtubeData.jsx", jsxContent);
+ console.log("Successfully wrote youtubeData.jsx");
+}
+
+main().catch((err) => {
+ console.error("Error:", err);
+ process.exit(1);
+});
diff --git a/.github/workflows/README-test-v2-pages.md b/.github/workflows/README-test-v2-pages.md
new file mode 100644
index 000000000..65cf50eb2
--- /dev/null
+++ b/.github/workflows/README-test-v2-pages.md
@@ -0,0 +1,152 @@
+# V2 Pages Browser Test Workflow
+
+This GitHub Actions workflow automatically tests all v2 pages from `docs.json` using Puppeteer in a headless browser whenever code is pushed or a PR is created.
+
+## What it does
+
+1. **Extracts all v2 pages** from `docs.json` (currently ~263 pages)
+2. **Starts a Mintlify dev server** in the background
+3. **Visits each page** using Puppeteer headless Chrome
+4. **Collects console errors**, warnings, and page errors
+5. **Reports results**:
+ - Workflow status (pass/fail)
+ - Artifact with detailed JSON report
+ - PR comment with summary (on pull requests)
+
+## When it runs
+
+- **On push** to `main` or `docs-v2-preview` branches
+- **On pull requests** targeting `main` or `docs-v2-preview` branches
+
+## Workflow steps
+
+1. Checkout repository
+2. Set up Node.js 22
+3. Install Mintlify globally
+4. Install npm dependencies (including Puppeteer)
+5. Start Mintlify dev server
+6. Wait for server to be ready (up to 2 minutes)
+7. Run the test script (`npm run test:v2-pages`)
+8. Upload test report as artifact
+9. Comment on PR with results (if PR)
+10. Stop dev server
+
+## Viewing results
+
+### In the workflow run
+- Check the workflow run status (green = all passed, red = some failed)
+- Download the `v2-pages-test-report` artifact for detailed JSON report
+
+### On Pull Requests
+- A bot comment will be posted/updated with:
+ - Total pages tested
+ - Pass/fail counts
+ - Pass rate percentage
+ - List of failed pages (first 10)
+ - Link to download full report
+
+### Example PR comment
+
+```
+## 📊 V2 Pages Test Results
+
+- **Total pages tested:** 263
+- **✅ Passed:** 250
+- **❌ Failed:** 13
+- **Pass rate:** 95.1%
+
+### Failed Pages
+
+- `v2/pages/01_about/livepeer-protocol/technical-architecture`
+- `v2/pages/04_gateways/run-a-gateway/configure/ai-configuration`
+...
+
+📥 Download the full test report from the workflow artifacts.
+```
+
+## Test report format
+
+The JSON report (`v2-page-test-report.json`) contains:
+
+```json
+{
+ "timestamp": "2026-01-15T10:30:00.000Z",
+ "baseUrl": "http://localhost:3000",
+ "totalPages": 263,
+ "passed": 250,
+ "failed": 13,
+ "results": [
+ {
+ "pagePath": "v2/pages/00_home/mission-control",
+ "url": "http://localhost:3000/00_home/mission-control",
+ "success": true,
+ "errors": [],
+ "warnings": [],
+ "logs": []
+ },
+ {
+ "pagePath": "v2/pages/01_about/livepeer-protocol/technical-architecture",
+ "url": "http://localhost:3000/01_about/livepeer-protocol/technical-architecture",
+ "success": false,
+ "errors": [
+ "Uncaught TypeError: Cannot read property 'map' of undefined"
+ ],
+ "warnings": [],
+ "logs": []
+ }
+ ]
+}
+```
+
+## Timeout and performance
+
+- **Per page timeout:** 30 seconds
+- **Server startup timeout:** 2 minutes
+- **Total workflow time:** ~15-20 minutes for 263 pages (depending on page complexity)
+
+## Troubleshooting
+
+### Server fails to start
+- Check the workflow logs for mint dev output
+- May need to increase wait time or check for port conflicts
+
+### Tests timeout
+- Some pages may be slow to load
+- Consider increasing per-page timeout in `scripts/test-v2-pages.js`
+
+### Puppeteer issues
+- The workflow uses the system Chrome/Chromium
+- If issues occur, may need to install additional dependencies
+
+## Manual testing
+
+To test locally before pushing:
+
+```bash
+# Start mint dev
+mint dev
+
+# In another terminal
+npm run test:v2-pages
+```
+
+## Customization
+
+### Test specific pages only
+Modify `scripts/test-v2-pages.js` to filter pages:
+
+```javascript
+const pages = getV2Pages().filter(page =>
+ page.includes('01_about') // Only test About section
+);
+```
+
+### Change timeout
+Update `TIMEOUT` constant in `scripts/test-v2-pages.js`
+
+### Skip on certain branches
+Add conditions to workflow:
+
+```yaml
+if: github.ref != 'refs/heads/experimental'
+```
diff --git a/.github/workflows/test-suite.yml b/.github/workflows/test-suite.yml
new file mode 100644
index 000000000..236065381
--- /dev/null
+++ b/.github/workflows/test-suite.yml
@@ -0,0 +1,112 @@
+name: Test Suite
+
+on:
+ push:
+ branches:
+ - main
+ - docs-v2-preview
+ pull_request:
+ branches:
+ - main
+ - docs-v2-preview
+
+jobs:
+ test-suite:
+ runs-on: ubuntu-latest
+
+ permissions:
+ contents: read
+ pull-requests: write
+
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v4
+
+ - name: Set up Node.js
+ uses: actions/setup-node@v4
+ with:
+ node-version: "22"
+ cache: 'npm'
+
+ - name: Install dependencies
+ run: npm install
+
+ - name: Run Style Guide Tests
+ continue-on-error: true
+ run: npm run test:style
+ id: style-test
+
+ - name: Run MDX Validation Tests
+ continue-on-error: true
+ run: npm run test:mdx
+ id: mdx-test
+
+ - name: Run Spelling Tests
+ continue-on-error: true
+ run: npm run test:spell
+ id: spell-test
+
+ - name: Run Quality Tests
+ continue-on-error: true
+ run: npm run test:quality
+ id: quality-test
+
+ - name: Install Mintlify globally
+ run: npm install -g mintlify
+
+ - name: Start Mintlify dev server
+ run: |
+ mint dev > /tmp/mint-dev.log 2>&1 &
+ echo $! > /tmp/mint-dev.pid
+ echo "Mint dev server starting (PID: $(cat /tmp/mint-dev.pid))"
+ continue-on-error: false
+
+ - name: Wait for server to be ready
+ run: |
+ echo "Waiting for mint dev server to start..."
+ for i in {1..60}; do
+ if curl -f -s http://localhost:3000 > /dev/null 2>&1; then
+ echo "✅ Server is ready!"
+ exit 0
+ fi
+ echo "Waiting... ($i/60)"
+ sleep 2
+ done
+ echo "❌ Server failed to start within 2 minutes"
+ tail -50 /tmp/mint-dev.log || true
+ exit 1
+
+ - name: Run Browser Tests (All Pages)
+ continue-on-error: true
+ run: |
+ # Force test ALL pages from docs.json (ensures complete coverage)
+ echo "Testing ALL pages from docs.json navigation..."
+ node tests/integration/browser.test.js
+ id: browser-test
+
+ - name: Stop Mintlify dev server
+ if: always()
+ run: |
+ if [ -f /tmp/mint-dev.pid ]; then
+ PID=$(cat /tmp/mint-dev.pid)
+ kill $PID 2>/dev/null || true
+ fi
+
+ - name: Test Summary
+ if: always()
+ run: |
+ echo "## Test Suite Results" >> $GITHUB_STEP_SUMMARY
+ echo "" >> $GITHUB_STEP_SUMMARY
+ echo "| Test | Status |" >> $GITHUB_STEP_SUMMARY
+ echo "|------|--------|" >> $GITHUB_STEP_SUMMARY
+ echo "| Style Guide | ${{ steps.style-test.outcome == 'success' && '✅' || '❌' }} |" >> $GITHUB_STEP_SUMMARY
+ echo "| MDX Validation | ${{ steps.mdx-test.outcome == 'success' && '✅' || '❌' }} |" >> $GITHUB_STEP_SUMMARY
+ echo "| Spelling | ${{ steps.spell-test.outcome == 'success' && '✅' || '❌' }} |" >> $GITHUB_STEP_SUMMARY
+ echo "| Quality | ${{ steps.quality-test.outcome == 'success' && '✅' || '❌' }} |" >> $GITHUB_STEP_SUMMARY
+ echo "| Browser | ${{ steps.browser-test.outcome == 'success' && '✅' || '❌' }} |" >> $GITHUB_STEP_SUMMARY
+
+ - name: Fail if any test failed
+ if: steps.style-test.outcome == 'failure' || steps.mdx-test.outcome == 'failure' || steps.spell-test.outcome == 'failure' || steps.quality-test.outcome == 'failure' || steps.browser-test.outcome == 'failure'
+ run: |
+ echo "❌ One or more tests failed"
+ exit 1
diff --git a/.github/workflows/test-v2-pages.yml b/.github/workflows/test-v2-pages.yml
new file mode 100644
index 000000000..c001436b0
--- /dev/null
+++ b/.github/workflows/test-v2-pages.yml
@@ -0,0 +1,184 @@
+name: Test V2 Pages
+
+on:
+ push:
+ branches:
+ - main
+ - docs-v2-preview
+ pull_request:
+ branches:
+ - main
+ - docs-v2-preview
+
+jobs:
+ test-pages:
+ runs-on: ubuntu-latest
+
+ permissions:
+ contents: read
+ pull-requests: write # For commenting on PRs
+
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v4
+
+ - name: Set up Node.js
+ uses: actions/setup-node@v4
+ with:
+ node-version: "22"
+ cache: 'npm'
+
+ - name: Install Mintlify globally
+ run: npm install -g mintlify
+
+ - name: Install dependencies
+ run: npm install
+
+ - name: Install jq (for JSON parsing)
+ run: sudo apt-get update && sudo apt-get install -y jq
+
+ - name: Start Mintlify dev server
+ run: |
+ mint dev > /tmp/mint-dev.log 2>&1 &
+ echo $! > /tmp/mint-dev.pid
+ echo "Mint dev server starting (PID: $(cat /tmp/mint-dev.pid))"
+ continue-on-error: false
+
+ - name: Wait for server to be ready
+ run: |
+ echo "Waiting for mint dev server to start..."
+ for i in {1..60}; do
+ if curl -f -s http://localhost:3000 > /dev/null 2>&1; then
+ echo "✅ Server is ready!"
+ exit 0
+ fi
+ echo "Waiting... ($i/60)"
+ sleep 2
+ done
+ echo "❌ Server failed to start within 2 minutes"
+ echo "Last 50 lines of mint dev log:"
+ tail -50 /tmp/mint-dev.log || true
+ exit 1
+
+ - name: Run V2 pages test
+ id: test-pages
+ continue-on-error: true
+ run: |
+ npm run test:v2-pages
+ TEST_EXIT_CODE=$?
+ echo "exit_code=$TEST_EXIT_CODE" >> $GITHUB_OUTPUT
+ echo "test_exit_code=$TEST_EXIT_CODE" >> $GITHUB_OUTPUT
+ exit $TEST_EXIT_CODE
+
+ - name: Upload test report
+ if: always()
+ uses: actions/upload-artifact@v4
+ with:
+ name: v2-pages-test-report
+ path: v2-page-test-report.json
+ retention-days: 7
+
+ - name: Parse test results
+ if: always()
+ id: test-results
+ run: |
+ if [ -f v2-page-test-report.json ]; then
+ TOTAL=$(jq -r '.totalPages' v2-page-test-report.json)
+ PASSED=$(jq -r '.passed' v2-page-test-report.json)
+ FAILED=$(jq -r '.failed' v2-page-test-report.json)
+
+ echo "total=$TOTAL" >> $GITHUB_OUTPUT
+ echo "passed=$PASSED" >> $GITHUB_OUTPUT
+ echo "failed=$FAILED" >> $GITHUB_OUTPUT
+
+ # Get failed pages summary
+ FAILED_PAGES=$(jq -r '.results[] | select(.success == false) | .pagePath' v2-page-test-report.json | head -10)
+ echo "failed_pages<> $GITHUB_OUTPUT
+ echo "$FAILED_PAGES" >> $GITHUB_OUTPUT
+ echo "EOF" >> $GITHUB_OUTPUT
+ else
+ echo "total=0" >> $GITHUB_OUTPUT
+ echo "passed=0" >> $GITHUB_OUTPUT
+ echo "failed=0" >> $GITHUB_OUTPUT
+ fi
+
+ - name: Comment on PR
+ if: github.event_name == 'pull_request' && always()
+ uses: actions/github-script@v7
+ with:
+ script: |
+ const fs = require('fs');
+ let comment = '## 📊 V2 Pages Test Results\n\n';
+
+ const total = '${{ steps.test-results.outputs.total }}';
+ const passed = '${{ steps.test-results.outputs.passed }}';
+ const failed = '${{ steps.test-results.outputs.failed }}';
+
+ if (total === '0') {
+ comment += '❌ Test report not found. The test may have failed to run.\n';
+ } else {
+ const passRate = ((parseInt(passed) / parseInt(total)) * 100).toFixed(1);
+ comment += `- **Total pages tested:** ${total}\n`;
+ comment += `- **✅ Passed:** ${passed}\n`;
+ comment += `- **❌ Failed:** ${failed}\n`;
+ comment += `- **Pass rate:** ${passRate}%\n\n`;
+
+ if (parseInt(failed) > 0) {
+ comment += '### Failed Pages\n\n';
+ const failedPages = `${{ steps.test-results.outputs.failed_pages }}`.split('\n').filter(p => p);
+ if (failedPages.length > 0) {
+ failedPages.slice(0, 10).forEach(page => {
+ comment += `- \`${page}\`\n`;
+ });
+ if (failedPages.length > 10) {
+ comment += `\n_... and ${failedPages.length - 10} more. See full report in artifacts._\n`;
+ }
+ }
+ comment += '\n📥 Download the full test report from the workflow artifacts.\n';
+ } else {
+ comment += '🎉 All pages passed!\n';
+ }
+ }
+
+ // Find existing comment
+ const comments = await github.rest.issues.listComments({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ issue_number: context.issue.number,
+ });
+
+ const botComment = comments.data.find(comment =>
+ comment.user.type === 'Bot' &&
+ comment.body.includes('## 📊 V2 Pages Test Results')
+ );
+
+ if (botComment) {
+ await github.rest.issues.updateComment({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ comment_id: botComment.id,
+ body: comment
+ });
+ } else {
+ await github.rest.issues.createComment({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ issue_number: context.issue.number,
+ body: comment
+ });
+ }
+
+ - name: Stop Mintlify dev server
+ if: always()
+ run: |
+ if [ -f /tmp/mint-dev.pid ]; then
+ PID=$(cat /tmp/mint-dev.pid)
+ kill $PID 2>/dev/null || true
+ echo "Stopped mint dev server (PID: $PID)"
+ fi
+
+ - name: Fail job if tests failed
+ if: steps.test-pages.outputs.test_exit_code != '0' && steps.test-pages.outputs.test_exit_code != ''
+ run: |
+ echo "❌ Test failed with exit code ${{ steps.test-pages.outputs.test_exit_code }}"
+ exit ${{ steps.test-pages.outputs.test_exit_code }}
diff --git a/.github/workflows/update-blog-data.yml b/.github/workflows/update-blog-data.yml
new file mode 100644
index 000000000..cabd9ff6e
--- /dev/null
+++ b/.github/workflows/update-blog-data.yml
@@ -0,0 +1,60 @@
+name: Update Blog and Forum Data
+
+on:
+ schedule:
+ - cron: "0 0 * * *" # Runs daily at midnight UTC
+ workflow_dispatch: # Allows manual trigger from GitHub UI
+
+jobs:
+ update-data:
+ runs-on: ubuntu-latest
+
+ permissions:
+ contents: write # Required to push changes
+
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v4
+ with:
+ token: ${{ secrets.GITHUB_TOKEN }}
+
+ - name: Fetch Ghost blog data
+ run: |
+ curl -f -o ghost-data.json "https://livepeer.org/ghost/api/content/posts/?key=YOUR_CONTENT_API_KEY&limit=all&include=tags,authors" || echo "[]" > ghost-data.json
+ continue-on-error: true
+
+ - name: Fetch Forum data
+ run: |
+ curl -f -o forum-data.json "https://forum.livepeer.org/latest.json" || echo "[]" > forum-data.json
+ continue-on-error: true
+
+ - name: Update Ghost data file
+ run: |
+ echo "export const ghostData = " > snippets/automations/blog/ghostBlogData.jsx
+ cat ghost-data.json >> snippets/automations/blog/ghostBlogData.jsx
+ echo ";" >> snippets/automations/blog/ghostBlogData.jsx
+
+ - name: Update Forum data file
+ run: |
+ echo "export const forumData = " > snippets/automations/forum/forumData.jsx
+ cat forum-data.json >> snippets/automations/forum/forumData.jsx
+ echo ";" >> snippets/automations/forum/forumData.jsx
+
+ - name: Check for changes
+ id: git-check
+ run: |
+ git diff --exit-code snippets/automations/ || echo "changed=true" >> $GITHUB_OUTPUT
+
+ - name: Commit and push if changed
+ if: steps.git-check.outputs.changed == 'true'
+ run: |
+ git config --global user.name 'github-actions[bot]'
+ git config --global user.email 'github-actions[bot]@users.noreply.github.com'
+ git add snippets/automations/blog/ghostBlogData.jsx
+ git add snippets/automations/forum/forumData.jsx
+ git commit -m "chore: update blog and forum data [skip ci]"
+ git push
+
+ - name: Cleanup
+ run: |
+ rm -f ghost-data.json forum-data.json
diff --git a/.github/workflows/update-forum-data.yml b/.github/workflows/update-forum-data.yml
new file mode 100644
index 000000000..91e658b99
--- /dev/null
+++ b/.github/workflows/update-forum-data.yml
@@ -0,0 +1,38 @@
+# NOTE: THIS GITHUB ACTION WILL ONLY RUN ON MAIN BRANCH.
+# N8N IS BEING USING AS AN ALTERNATIVE UNTIL THEN.
+# N8N workflow is in /snippets/automations/n8n-workflows/forum-to-mintlify-latest-topics.json
+name: Update Forum Data
+
+on:
+ schedule:
+ # Run daily at 00:00 UTC
+ - cron: "0 0 * * *"
+ workflow_dispatch: # Allow manual trigger
+
+jobs:
+ update-forum-data:
+ runs-on: ubuntu-latest
+
+ steps:
+ - name: Checkout docs repository
+ uses: actions/checkout@v4
+ with:
+ repository: livepeer/docs
+ ref: docs-v2-preview
+ token: ${{ secrets.DOCS_V2 }}
+
+ - name: Setup Node.js
+ uses: actions/setup-node@v4
+ with:
+ node-version: "18"
+
+ - name: Fetch and process forum data
+ run: |
+ node .github/scripts/fetch-forum-data.js
+
+ - name: Commit and push if changed
+ run: |
+ git config user.name "GitHub Action"
+ git config user.email "action@github.com"
+ git add snippets/automations/forum/forumData.jsx
+ git diff --quiet && git diff --staged --quiet || (git commit -m "Update forum data - $(date -u +"%Y-%m-%dT%H:%M:%SZ")" && git push)
diff --git a/.github/workflows/update-ghost-blog-data.yml b/.github/workflows/update-ghost-blog-data.yml
new file mode 100644
index 000000000..b3d44c1b5
--- /dev/null
+++ b/.github/workflows/update-ghost-blog-data.yml
@@ -0,0 +1,35 @@
+# NOTE: THIS GITHUB ACTION WILL ONLY RUN ON MAIN BRANCH.
+# N8N IS BEING USING AS AN ALTERNATIVE UNTIL THEN.
+# N8N workflow is in /snippets/automations/n8n-workflows/ghost-to-mintlify.json
+name: Update Ghost Blog Data
+
+on:
+ schedule:
+ - cron: "0 0 * * *"
+ workflow_dispatch:
+
+jobs:
+ update-ghost-data:
+ runs-on: ubuntu-latest
+
+ steps:
+ - name: Checkout docs repository
+ uses: actions/checkout@v4
+ with:
+ token: ${{ secrets.DOCS_V2 }}
+
+ - name: Setup Node.js
+ uses: actions/setup-node@v4
+ with:
+ node-version: "18"
+
+ - name: Fetch and process Ghost blog data
+ run: |
+ node .github/scripts/fetch-ghost-data.js
+
+ - name: Commit and push if changed
+ run: |
+ git config user.name "GitHub Action"
+ git config user.email "action@github.com"
+ git add snippets/automations/ghost/ghostBlogData.jsx
+ git diff --quiet && git diff --staged --quiet || (git commit -m "Update Ghost blog data - $(date -u +"%Y-%m-%dT%H:%M:%SZ")" && git push)
diff --git a/.github/workflows/update-youtube-data.yml b/.github/workflows/update-youtube-data.yml
new file mode 100644
index 000000000..05dfd5e10
--- /dev/null
+++ b/.github/workflows/update-youtube-data.yml
@@ -0,0 +1,158 @@
+# NOTE: THIS GITHUB ACTION WILL ONLY RUN ON MAIN BRANCH.
+# N8N IS BEING USING AS AN ALTERNATIVE UNTIL THEN.
+# N8N workflow is in /snippets/automations/n8n-workflows/youtube-to-mintlify.json
+# You will need to Add YOUTUBE_API_KEY secret in repo settings (Settings → Secrets → Actions) for this github action to work.
+
+name: Update YouTube Data
+
+on:
+ schedule:
+ - cron: "0 0 * * 0" # Weekly on Sunday at midnight UTC
+ workflow_dispatch: # Allow manual trigger
+
+jobs:
+ update-youtube:
+ runs-on: ubuntu-latest
+
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v4
+ with:
+ ref: main
+ token: ${{ secrets.GITHUB_TOKEN }}
+
+ - name: Setup Node.js
+ uses: actions/setup-node@v4
+ with:
+ node-version: "20"
+
+ - name: Fetch and process YouTube videos
+ env:
+ YOUTUBE_API_KEY: ${{ secrets.YOUTUBE_API_KEY }}
+ CHANNEL_ID: UCzfHtZnmUzMbJDxGCwIgY2g
+ run: |
+ node << 'EOF'
+ const https = require('https');
+ const fs = require('fs');
+
+ const YOUTUBE_API_KEY = process.env.YOUTUBE_API_KEY;
+ const CHANNEL_ID = process.env.CHANNEL_ID;
+
+ function httpsGet(url) {
+ return new Promise((resolve, reject) => {
+ https.get(url, (res) => {
+ let data = '';
+ res.on('data', (chunk) => data += chunk);
+ res.on('end', () => resolve(JSON.parse(data)));
+ }).on('error', reject);
+ });
+ }
+
+ function parseDuration(duration) {
+ const match = duration.match(/PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?/);
+ if (!match) return 0;
+
+ const hours = parseInt(match[1] || 0);
+ const minutes = parseInt(match[2] || 0);
+ const seconds = parseInt(match[3] || 0);
+
+ return hours * 3600 + minutes * 60 + seconds;
+ }
+
+ function escapeForJSX(str) {
+ return str
+ .replace(/\\/g, '\\\\')
+ .replace(/'/g, "\\'")
+ .replace(/"/g, '\\"')
+ .replace(/\n/g, ' ')
+ .replace(/\r/g, '')
+ .replace(/\t/g, ' ');
+ }
+
+ async function main() {
+ // Step 1: Get recent videos
+ console.log('Fetching recent videos...');
+ const searchUrl = `https://www.googleapis.com/youtube/v3/search?part=snippet&channelId=${CHANNEL_ID}&maxResults=50&order=date&type=video&key=${YOUTUBE_API_KEY}`;
+ const searchResults = await httpsGet(searchUrl);
+
+ if (!searchResults.items || searchResults.items.length === 0) {
+ console.log('No videos found');
+ return;
+ }
+
+ // Step 2: Get video details for each video
+ console.log(`Found ${searchResults.items.length} videos, fetching details...`);
+ const videoIds = searchResults.items.map(item => item.id.videoId).join(',');
+ const detailsUrl = `https://www.googleapis.com/youtube/v3/videos?part=contentDetails,snippet&id=${videoIds}&key=${YOUTUBE_API_KEY}`;
+ const detailsResults = await httpsGet(detailsUrl);
+
+ // Step 3: Process and filter videos
+ const videos = [];
+ for (const video of detailsResults.items) {
+ const duration = video.contentDetails.duration;
+ const durationSeconds = parseDuration(duration);
+ const snippet = video.snippet;
+
+ // Check if it's a livestream
+ const isLivestream = snippet.liveBroadcastContent === 'live' ||
+ snippet.liveBroadcastContent === 'upcoming' ||
+ duration === 'PT0S' ||
+ snippet.title.toLowerCase().includes('watercooler') ||
+ snippet.title.toLowerCase().includes('fireside');
+
+ // Filter out Shorts (≤60 seconds and not livestreams)
+ const isShort = durationSeconds <= 60 && durationSeconds > 0 && !isLivestream;
+
+ if (!isShort) {
+ videos.push({
+ title: snippet.title,
+ href: `https://www.youtube.com/watch?v=${video.id}`,
+ author: `By ${snippet.channelTitle || 'Livepeer'}`,
+ content: (snippet.description || '').substring(0, 500),
+ publishedDate: new Date(snippet.publishedAt).toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' }),
+ duration: duration,
+ thumbnailUrl: snippet.thumbnails.high.url
+ });
+ }
+ }
+
+ console.log(`Filtered to ${videos.length} non-Short videos`);
+
+ // Step 4: Generate JSX content
+ const jsxContent = `export const youtubeData = [
+ ${videos.map(v => ` {
+ title: '${escapeForJSX(v.title)}',
+ href: '${v.href}',
+ author: '${v.author}',
+ content: '${escapeForJSX(v.content)}...',
+ publishedDate: '${v.publishedDate}',
+ duration: '${v.duration}',
+ thumbnailUrl: '${v.thumbnailUrl}'
+ }`).join(',\n')}
+ ];
+ `;
+
+ // Step 5: Write to file
+ fs.writeFileSync('snippets/automations/youtube/youtubeData.jsx', jsxContent);
+ console.log('Successfully wrote youtubeData.jsx');
+ }
+
+ main().catch(err => {
+ console.error('Error:', err);
+ process.exit(1);
+ });
+ EOF
+
+ - name: Check for changes
+ id: git-check
+ run: |
+ git diff --exit-code snippets/automations/youtube/youtubeData.jsx || echo "changed=true" >> $GITHUB_OUTPUT
+
+ - name: Commit and push if changed
+ if: steps.git-check.outputs.changed == 'true'
+ run: |
+ git config user.name "GitHub Actions Bot"
+ git config user.email "actions@github.com"
+ git add snippets/automations/youtube/youtubeData.jsx
+ git commit -m "Update YouTube videos - $(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+ git push
diff --git a/.gitignore b/.gitignore
index e7e1da61e..e54d8c67b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,6 +22,9 @@ pnpm-lock.yaml
.env
.env.*local
+# Google OAuth secrets
+**/client_secret*.json
+
# ------------------------------------
# Logs
# ------------------------------------
@@ -68,3 +71,8 @@ build/
# External docs (fetched at build time)
# ------------------------------------
snippets/external/
+
+# ------------------------------------
+# Notion exports (contains API keys)
+# ------------------------------------
+notion/
diff --git a/.mintignore b/.mintignore
new file mode 100644
index 000000000..6a596171f
--- /dev/null
+++ b/.mintignore
@@ -0,0 +1,5 @@
+# Context data and internal reports (not published; contain MD that parses badly as MDX)
+docs/ABOUT/CONTEXT DATA/
+docs/ORCHESTRATORS/CONTEXT DATA/
+docs/DEVELOPERS/CONTEXT DATA/
+v2/pages/01_about/_contextData_/
diff --git a/COMPONENT_LIBRARY_STATUS_REPORT.md b/COMPONENT_LIBRARY_STATUS_REPORT.md
new file mode 100644
index 000000000..8852359c8
--- /dev/null
+++ b/COMPONENT_LIBRARY_STATUS_REPORT.md
@@ -0,0 +1,108 @@
+# Component Library Status Report
+
+**Generated:** 2026-02-16
+**Test Results:** All 6 category pages render correctly
+
+## ✅ Pages That Render
+
+1. **Display** - 13,732 chars, 0 errors
+2. **Primitives** - 12,556 chars, 0 errors
+3. **Content** - 7,167 chars, 0 errors
+4. **Layout** - 5,538 chars, 0 errors
+5. **Domain** - 914 chars, 0 errors
+6. **Integrations** - 4,144 chars, 0 errors
+
+## ❌ Pages That Do NOT Render
+
+1. **Main Component Library** (`/v2/pages/07_resources/documentation-guide/component-library`) - Parsing error detected
+
+## Components NOT Documented in Component Library
+
+Based on grep of all exported components vs what's imported in component library pages:
+
+### Primitives (Missing)
+- `BasicBtn` - from `buttons.jsx`
+- `LivepeerSVG` - from `icons.jsx`
+- `LivepeerIconOld` - from `icons.jsx`
+- `LinkArrow` - from `links.jsx` (imported but not documented)
+- `CardTitleTextWithArrow` - from `text.jsx` (imported but not documented)
+- `AccordionTitleWithArrow` - from `text.jsx` (imported but not documented)
+- `StyledTable` - from `tables.jsx`
+- `TableRow` - from `tables.jsx`
+- `TableCell` - from `tables.jsx`
+- `FlexContainer` - from `layout.jsx`
+- `GridContainer` - from `layout.jsx`
+- `Spacer` - from `layout.jsx`
+- `BorderedBox` - from `containers.jsx`
+- `CenteredContainer` - from `containers.jsx`
+- `FullWidthContainer` - from `containers.jsx`
+
+### Display (Missing)
+- `TitledVideo` - from `video.jsx`
+- `ShowcaseVideo` - from `video.jsx`
+- `YouTubeVideoData` - from `video.jsx`
+- `YouTubeVideoDownload` - from `video.jsx`
+- `Quote` - from `quote.jsx`
+- `FrameQuote` - from `quote.jsx`
+- `ShowcaseCards` - from `showcaseCards.jsx` (imported but not documented)
+- `SocialLinks` - from `socialLinks.jsx`
+- `CardCarousel` - from `CardCarousel.jsx`
+- `PageHeader` - from `frameMode.jsx`
+- `H1`, `H2`, `H3`, `H4`, `H5`, `H6` - from `frameMode.jsx`
+- `P` - from `frameMode.jsx`
+- `Divider` - from `frameMode.jsx`
+- `MarkdownEmbed` - from `embed.jsx` (imported but not documented)
+- `EmbedMarkdown` - from `embed.jsx` (imported but not documented)
+- `TwitterTimeline` - from `embed.jsx` (imported but not documented)
+
+### Content (Missing)
+- `CodeComponent` - from `code.jsx` (imported but not fully documented)
+- `ComplexCodeBlock` - from `code.jsx` (imported but not fully documented)
+- `CodeSection` - from `code.jsx` (imported but not fully documented)
+- `ResponseFieldGroup` - from `responseField.jsx` (commented out due to bug)
+
+### Layout (Missing)
+- `BasicList` - from `lists.jsx`
+- `IconList` - from `lists.jsx`
+- `StepList` - from `lists.jsx` (imported but not documented)
+- `StepLinkList` - from `lists.jsx` (imported but not documented)
+- `UpdateList` - from `lists.jsx` (imported but not documented)
+- `UpdateLinkList` - from `lists.jsx` (imported but not documented)
+- `ListSteps` - from `ListSteps.jsx`
+- `AccordionLayout` - from `text.jsx`
+- `QuadGrid` - from `quadGrid.jsx`
+- `ApiBaseUrlsTable` - from `api-base-urls-table.mdx`
+- `CardInCardLayout` - from `data.jsx`
+- `ForumLatestLayout` - from `data.jsx` (imported but not documented)
+
+### Domain (Missing)
+- `GatewayOffChainWarning` - from `callouts.jsx`
+- `GatewayOnChainWarning` - from `callouts.jsx`
+- `GatewayOnChainTTestnetNote` - from `callouts.jsx`
+- `OrchAddrNote` - from `callouts.jsx`
+- `TestVideoDownload` - from `callouts.jsx`
+- `FfmpegWarning` - from `callouts.jsx`
+- `QuickStartTabs` - from `quickstartTabs.jsx`
+- `QuickStartSteps` - from `quickstartTabs.jsx`
+- `Starfield` - from `HeroGif.jsx`
+- Portal components from `Portals.jsx`
+
+## Summary
+
+**Total Components Exported:** ~80+ components
+**Total Components Documented:** ~35 components
+**Total Components Missing:** ~45+ components
+
+## Fixes Applied
+
+1. ✅ Uncommented `CustomCodeBlock`, `CodeComponent`, `ComplexCodeBlock`, `CodeSection` in `content.mdx` - they work correctly
+2. ✅ Added JSX comment quirk to style guide (Section 9)
+3. ✅ All 6 category pages now render correctly
+4. ❌ Main component-library.mdx page has parsing error - needs investigation
+
+## Next Steps
+
+1. Fix parsing error in main `component-library.mdx` page
+2. Document all missing components listed above
+3. Add examples for all components
+4. Complete props documentation for all components
diff --git a/COMPREHENSIVE_CHANGE_REPORT.md b/COMPREHENSIVE_CHANGE_REPORT.md
new file mode 100644
index 000000000..ec601c07f
--- /dev/null
+++ b/COMPREHENSIVE_CHANGE_REPORT.md
@@ -0,0 +1,226 @@
+# COMPREHENSIVE CHANGE REPORT
+
+**Generated**: Comparing local fork against `upstream/docs-v2-preview` branch
+**Reference**: https://github.com/livepeer/docs/tree/docs-v2-preview
+
+## EXECUTIVE SUMMARY
+
+- **Total Changed Pages**: 174
+- **Total Changed Components**: 21
+- **Total Changed Files**: 195
+
+## CRITICAL FINDINGS
+
+### Portal Pages That May Be Broken
+
+The following portal pages have been changed and import components that have also changed:
+
+1. **`v2/pages/010_products/products-portal.mdx`** - Products Portal
+ - Imports: `Portals.jsx`, `frameMode.jsx`, `links.jsx` (all changed)
+
+2. **`v2/pages/05_orchestrators/orchestrators-portal.mdx`** - Orchestrators Portal
+ - Imports: `Portals.jsx`, `frameMode.jsx`, `links.jsx`, `layout.jsx` (all changed)
+
+3. **`v2/pages/06_lptoken/token-portal.mdx`** - Token Portal
+ - Imports: `Portals.jsx`, `frameMode.jsx`, `links.jsx`, `layout.jsx` (all changed)
+
+4. **`v2/pages/00_home/mission-control.mdx`** - Mission Control
+ - Imports: `Portals.jsx`, `frameMode.jsx`, `links.jsx` (all changed)
+
+5. **`v2/pages/04_gateways/gateways-portal.mdx`** - Gateways Portal
+ - Imports: `Portals.jsx` (changed)
+
+6. **`v2/pages/01_about/about-portal.mdx`** - About Portal
+ - Imports: Various components
+
+7. **`v2/pages/02_community/community-portal.mdx`** - Community Portal
+ - Imports: Various components
+
+8. **`v2/pages/03_developers/developer-portal.mdx`** - Developer Portal
+ - Imports: Various components
+
+9. **`v2/pages/07_resources/resources-portal.mdx`** - Resources Portal
+ - Imports: Various components
+
+## CHANGED COMPONENTS (21 files)
+
+These components have been modified and may break pages that import them:
+
+### 1. `snippets/components/domain/SHARED/Portals.jsx` ⚠️ CRITICAL
+- **Status**: Modified
+- **Impact**: Used by ALL portal pages
+- **Changes**: 6 additions, 18 deletions
+
+### 2. `snippets/components/display/frameMode.jsx` ⚠️ CRITICAL
+- **Status**: Modified
+- **Impact**: Used by portal pages in frame mode
+- **Changes**: 52 additions, 163 deletions (MAJOR REFACTOR)
+
+### 3. `snippets/components/primitives/layout.jsx` ⚠️ NEW
+- **Status**: New file
+- **Impact**: Used by orchestrators-portal.mdx and token-portal.mdx
+- **Changes**: 123 additions (new file)
+
+### 4. `snippets/components/primitives/links.jsx` ⚠️ MODIFIED
+- **Status**: Modified
+- **Impact**: Used by many pages
+- **Changes**: 4 additions, 35 deletions
+
+### 5. `snippets/components/layout/cards.jsx` ⚠️ MAJOR CHANGE
+- **Status**: Modified
+- **Impact**: Used by many pages
+- **Changes**: 2 additions, 330 deletions (MAJOR REFACTOR)
+
+### 6. `snippets/components/display/video.jsx`
+- **Status**: Modified
+- **Changes**: 71 additions, 6 deletions
+
+### 7. `snippets/components/content/code.jsx`
+- **Status**: Modified
+- **Changes**: 4 additions, 21 deletions
+
+### 8. `snippets/components/content/external-content.jsx`
+- **Status**: Modified
+- **Changes**: 6 additions, 22 deletions
+
+### 9. `snippets/components/display/CardCarousel.jsx`
+- **Status**: Modified
+- **Changes**: 9 additions, 6 deletions
+
+### 10. `snippets/components/display/zoomable-diagram.jsx`
+- **Status**: Modified
+- **Changes**: 39 additions, 79 deletions
+
+### 11. `snippets/components/domain/04_GATEWAYS/callouts.jsx`
+- **Status**: Modified
+- **Changes**: 14 additions, 26 deletions
+
+### 12. `snippets/components/gateways/callouts.jsx` ⚠️ DELETED
+- **Status**: DELETED
+- **Impact**: Any page importing this will break
+- **Changes**: File deleted (79 deletions)
+
+### 13. `snippets/components/gateways/warnings.jsx` ⚠️ DELETED
+- **Status**: DELETED
+- **Impact**: Any page importing this will break
+- **Changes**: File deleted (44 deletions)
+
+### 14. `snippets/components/integrations/coingecko.jsx`
+- **Status**: Modified
+- **Changes**: 9 additions, 26 deletions
+
+### 15. `snippets/components/layout/steps.jsx`
+- **Status**: Modified
+- **Changes**: 3 additions, 3 deletions
+
+### 16. `snippets/components/primitives/containers.jsx` ⚠️ NEW
+- **Status**: New file
+- **Changes**: 134 additions (new file)
+
+### 17. `snippets/components/primitives/tables.jsx` ⚠️ NEW
+- **Status**: New file
+- **Changes**: 152 additions (new file)
+
+### 18. `snippets/data/gateways/code.jsx`
+- **Status**: Modified
+- **Changes**: 0 additions, 69 deletions
+
+### 19. `snippets/data/gateways/flags.jsx`
+- **Status**: Modified
+- **Changes**: 0 additions, 47 deletions
+
+### 20. `snippets/data/gateways/index.jsx`
+- **Status**: Modified
+- **Changes**: 0 additions, 4 deletions
+
+### 21. `snippets/data/gateways/quickstart.jsx`
+- **Status**: Modified
+- **Changes**: 0 additions, 16 deletions
+
+## CHANGED PAGES (174 files)
+
+### Portal Pages (9 files) - HIGH PRIORITY
+
+1. `v2/pages/010_products/products-portal.mdx`
+2. `v2/pages/05_orchestrators/orchestrators-portal.mdx` ⚠️
+3. `v2/pages/06_lptoken/token-portal.mdx`
+4. `v2/pages/00_home/mission-control.mdx`
+5. `v2/pages/04_gateways/gateways-portal.mdx`
+6. `v2/pages/01_about/about-portal.mdx`
+7. `v2/pages/02_community/community-portal.mdx`
+8. `v2/pages/03_developers/developer-portal.mdx`
+9. `v2/pages/07_resources/resources-portal.mdx`
+
+### Home Pages (4 files)
+
+1. `v2/pages/00_home/home/primer.mdx`
+2. `v2/pages/00_home/home/trending-layout-tests.mdx`
+3. `v2/pages/00_home/introduction/vision.mdx`
+4. `v2/pages/00_home/mission-control.mdx`
+
+### Products Pages (100+ files)
+
+All Livepeer Studio API reference pages and guides have been changed.
+
+### About Pages (5 files)
+
+1. `v2/pages/01_about/about-livepeer/moved/livepeer-overview.mdx`
+2. `v2/pages/01_about/about-portal.mdx`
+3. `v2/pages/01_about/livepeer-protocol/overview.mdx`
+4. `v2/pages/01_about/livepeer-protocol/technical-architecture.mdx`
+5. `v2/pages/01_about/livepeer-protocol/treasury.mdx`
+6. `v2/pages/01_about/resources/livepeer-whitepaper.mdx`
+
+### Community Pages (1 file)
+
+1. `v2/pages/02_community/community-portal.mdx`
+
+### Developer Pages (7 files)
+
+1. `v2/pages/03_developers/ai-inference-on-livepeer/ai-pipelines/byoc.mdx`
+2. `v2/pages/03_developers/ai-inference-on-livepeer/ai-pipelines/comfystream.mdx`
+3. `v2/pages/03_developers/ai-inference-on-livepeer/ai-pipelines/overview.mdx`
+4. `v2/pages/03_developers/builder-opportunities/dev-programs.mdx`
+5. `v2/pages/03_developers/building-on-livepeer/developer-guide.mdx`
+6. `v2/pages/03_developers/developer-platforms/builder-hub.mdx`
+7. `v2/pages/03_developers/developer-portal.mdx`
+8. `v2/pages/03_developers/technical-references/apis.mdx`
+9. `v2/pages/03_developers/technical-references/awesome-livepeer.mdx`
+10. `v2/pages/03_developers/technical-references/sdks.mdx`
+
+### Gateway Pages (30+ files)
+
+Multiple gateway pages changed, including:
+- Portal, tools, references, configuration, installation, etc.
+
+### Orchestrator Pages (1 file)
+
+1. `v2/pages/05_orchestrators/orchestrators-portal.mdx` ⚠️
+
+### LP Token Pages (1 file)
+
+1. `v2/pages/06_lptoken/token-portal.mdx`
+
+### Resources Pages (15+ files)
+
+Multiple documentation guide pages changed.
+
+## RECOMMENDATIONS
+
+1. **IMMEDIATE**: Check all portal pages - they import `Portals.jsx` which has changed
+2. **IMMEDIATE**: Check `frameMode.jsx` - major refactor (163 deletions, 52 additions)
+3. **IMMEDIATE**: Check for any imports of deleted files:
+ - `snippets/components/gateways/callouts.jsx` (DELETED)
+ - `snippets/components/gateways/warnings.jsx` (DELETED)
+4. **HIGH PRIORITY**: Review `cards.jsx` - major refactor (330 deletions)
+5. **MEDIUM PRIORITY**: Review new components:
+ - `snippets/components/primitives/layout.jsx` (NEW)
+ - `snippets/components/primitives/containers.jsx` (NEW)
+ - `snippets/components/primitives/tables.jsx` (NEW)
+
+## NEXT STEPS
+
+1. Run `git diff upstream/docs-v2-preview` on each portal page
+2. Check for broken imports (especially deleted files)
+3. Test rendering of all portal pages
+4. Review component changes for breaking API changes
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 000000000..53a66a304
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,72 @@
+# Contributing to Livepeer Documentation
+
+Thank you for your interest in contributing to the Livepeer documentation! This guide provides a quick reference for contributing. For detailed information, see the [full contribution guide](v2/pages/07_resources/documentation-guide/contribute-to-the-docs.mdx).
+
+## Quick Start
+
+1. **Fork the repository** — [github.com/livepeer/docs](https://github.com/livepeer/docs)
+2. **Create a branch** — `git checkout -b docs/your-change`
+3. **Install pre-commit hooks** — `./.githooks/install.sh`
+4. **Make your changes** — Edit files in `v2/pages/`
+5. **Test locally** — `mint dev`
+6. **Submit a PR** — Open a pull request
+
+## Before You Start
+
+**MANDATORY:** Read the [Style Guide](v2/pages/07_resources/documentation-guide/style-guide.mdx) before making any changes!
+
+**Critical rules:**
+- ✅ Use CSS Custom Properties (`var(--accent)`) only
+- ❌ Never use `ThemeData` or hardcode colors
+- ✅ Use absolute imports: `/snippets/components/...`
+- ✅ Test in both light and dark modes
+
+## Where to Edit
+
+- **Main pages:** `v2/pages/[section]/`
+- **Components:** `snippets/components/`
+- **Data files:** `snippets/data/`
+- **Assets:** `snippets/assets/`
+
+## Development Setup
+
+```bash
+# Install Mintlify CLI
+npm i -g mintlify
+
+# Run development server
+mint dev
+
+# Install pre-commit hooks
+./.githooks/install.sh
+```
+
+## Pull Request Process
+
+1. Create a descriptive branch name: `docs/fix-typo-quickstart`
+2. Make your changes following the style guide
+3. Test locally with `mint dev`
+4. Commit with clear messages: `docs: fix typo in quickstart guide`
+5. Push to your fork
+6. Open a PR with a clear description
+
+## Review Process
+
+- PRs are reviewed by section owners (see [CODEOWNERS](.github/CODEOWNERS))
+- Review timeline: 48-72 hours for most changes
+- Address all feedback before merge
+
+## Resources
+
+- [Full Contribution Guide](v2/pages/07_resources/documentation-guide/contribute-to-the-docs.mdx)
+- [Style Guide](v2/pages/07_resources/documentation-guide/style-guide.mdx)
+- [Component Library](v2/pages/07_resources/documentation-guide/component-library)
+- [Documentation Guide](v2/pages/07_resources/documentation-guide/documentation-guide)
+
+## Questions?
+
+- Open a [GitHub issue](https://github.com/livepeer/docs/issues)
+- Ask in the Livepeer Discord
+- Check the [full contribution guide](v2/pages/07_resources/documentation-guide/contribute-to-the-docs.mdx)
+
+Thank you for contributing! 🎉
diff --git a/README.md b/README.md
index 6d2b0d8ba..381e203ce 100644
--- a/README.md
+++ b/README.md
@@ -14,3 +14,27 @@ Run the following command at the root of your documentation (where mint.json is)
```bash
mint dev
```
+
+### 🔧 Git Hooks (Required)
+
+This repository uses git hooks to enforce style guide compliance and code quality. **You must install them:**
+
+```bash
+./.githooks/install.sh
+```
+
+The pre-commit hook will:
+- ✅ Check for style guide violations (ThemeData, hardcoded colors, etc.)
+- ✅ Run verification scripts (syntax checks, validation)
+- ❌ Block commits with violations
+
+See [Git Hooks Documentation](docs/CONTRIBUTING/GIT-HOOKS.md) for details.
+
+### 📖 Before Contributing
+
+**MANDATORY:** Read these before making changes:
+
+1. **[Style Guide](v2/pages/07_resources/documentation-guide/style-guide.mdx)** - Production-grade styling guidelines
+2. **[Component Library](v2/pages/07_resources/documentation-guide/component-library.mdx)** - Available components
+3. **[Contribution Guide](docs/CONTRIBUTING/README.md)** - How to contribute
+4. **[Git Hooks](docs/CONTRIBUTING/GIT-HOOKS.md)** - Pre-commit hook documentation
diff --git a/browser-test-report.json b/browser-test-report.json
new file mode 100644
index 000000000..d18d3192d
--- /dev/null
+++ b/browser-test-report.json
@@ -0,0 +1,5 @@
+{
+ "timestamp": "2026-02-16T11:50:35.428Z",
+ "totalPages": 263,
+ "passed": true
+}
\ No newline at end of file
diff --git a/check-component-errors.js b/check-component-errors.js
new file mode 100644
index 000000000..334a543ff
--- /dev/null
+++ b/check-component-errors.js
@@ -0,0 +1,67 @@
+const puppeteer = require('puppeteer');
+
+(async () => {
+ const browser = await puppeteer.launch({ headless: true });
+ const page = await browser.newPage();
+
+ const errors = [];
+ const warnings = [];
+
+ page.on('console', msg => {
+ const text = msg.text();
+ if (msg.type() === 'error') {
+ errors.push(text);
+ } else if (msg.type() === 'warning') {
+ warnings.push(text);
+ }
+ });
+
+ page.on('pageerror', error => {
+ errors.push(error.toString());
+ });
+
+ await page.goto('http://localhost:3000/introduction/vision', { waitUntil: 'networkidle2' });
+ await new Promise(r => setTimeout(r, 5000));
+
+ // Check if component rendered by looking for Frame component (YouTubeVideo uses Frame)
+ const frameElements = await page.$$eval('[class*="frame"], [class*="Frame"]', els => els.length);
+ console.log('Frame elements found:', frameElements);
+
+ // Check page title to confirm it loaded
+ const title = await page.title();
+ console.log('Page title:', title);
+
+ // Check for React hydration errors
+ console.log('\nConsole errors (filtered):');
+ const realErrors = errors.filter(e =>
+ !e.includes('require is not defined') &&
+ !e.includes('fs has already been declared') &&
+ !e.includes('appendChild') &&
+ !e.includes('puppeteer')
+ );
+ realErrors.forEach(err => console.log(' -', err));
+
+ // Get the actual rendered HTML around where YouTubeVideo should be
+ const videoSection = await page.evaluate(() => {
+ const bodyText = document.body.innerText;
+ const youtubeIndex = bodyText.indexOf('Core Mission');
+ return {
+ hasCoreMission: youtubeIndex > -1,
+ bodyLength: bodyText.length,
+ htmlLength: document.body.innerHTML.length
+ };
+ });
+
+ console.log('\nPage content:', videoSection);
+
+ // Check if privacy-enhanced URLs are in the source
+ const source = await page.content();
+ const hasNocookie = source.includes('youtube-nocookie.com');
+ const hasRegularEmbed = source.includes('youtube.com/embed');
+
+ console.log('\nURL check:');
+ console.log(' Has youtube-nocookie.com:', hasNocookie);
+ console.log(' Has youtube.com/embed:', hasRegularEmbed);
+
+ await browser.close();
+})();
diff --git a/cspell.json b/cspell.json
new file mode 100644
index 000000000..82c1eeca5
--- /dev/null
+++ b/cspell.json
@@ -0,0 +1,80 @@
+{
+ "version": "0.2",
+ "language": "en-GB",
+ "dictionaryDefinitions": [
+ {
+ "name": "livepeer-terms",
+ "path": "./tests/config/spell-dict.json",
+ "addWords": true
+ }
+ ],
+ "dictionaries": [
+ "en-gb",
+ "typescript",
+ "node",
+ "npm",
+ "html",
+ "css",
+ "bash",
+ "docker",
+ "markdown",
+ "livepeer-terms"
+ ],
+ "ignoreWords": [
+ "mdx",
+ "jsx",
+ "frontmatter",
+ "Mintlify",
+ "livepeer",
+ "Livepeer"
+ ],
+ "ignorePaths": [
+ "node_modules/**",
+ "package-lock.json",
+ "*.log",
+ ".git/**",
+ "v1/**",
+ "snippets/assets/**",
+ "**/*.min.js",
+ "**/*.bundle.js"
+ ],
+ "flagWords": [
+ "color",
+ "colors",
+ "optimize",
+ "optimization",
+ "organize",
+ "organization",
+ "recognize",
+ "recognized"
+ ],
+ "overrides": [
+ {
+ "filename": "**/*.mdx",
+ "languageSettings": [
+ {
+ "languageId": "markdown",
+ "locale": "en-GB"
+ }
+ ]
+ },
+ {
+ "filename": "**/*.js",
+ "languageSettings": [
+ {
+ "languageId": "javascript",
+ "locale": "en-US"
+ }
+ ]
+ },
+ {
+ "filename": "**/*.jsx",
+ "languageSettings": [
+ {
+ "languageId": "javascript",
+ "locale": "en-US"
+ }
+ ]
+ }
+ ]
+}
diff --git a/docs.json b/docs.json
index 15de3b4ac..c78d9d63a 100644
--- a/docs.json
+++ b/docs.json
@@ -33,27 +33,28 @@
"icon": "house-heart",
"pages": [
"v2/pages/00_home/mission-control",
- "v2/pages/00_home/home/primer",
- "v2/pages/00_home/home/trending-topics"
+ "v2/pages/00_home/home/user-journey",
+ "v2/pages/00_home/home/primer"
]
},
{
"group": "Livepeer",
- "icon": "/snippets/assets/logos/Livepeer-Logo-Symbol-Light.svg",
+ "icon": "/snippets/assets/logos/Livepeer-Logo-Symbol-Theme.svg",
"pages": [
- "v2/pages/00_home/introduction/livepeer-story",
- "v2/pages/00_home/introduction/livepeer-vision",
- "v2/pages/00_home/introduction/livepeer-future",
- "v2/pages/00_home/introduction/livepeer-ecosystem"
+ "v2/pages/00_home/introduction/vision",
+ "v2/pages/00_home/introduction/evolution",
+ "v2/pages/00_home/introduction/why-livepeer",
+ "v2/pages/00_home/introduction/ecosystem",
+ "v2/pages/00_home/introduction/roadmap"
]
},
{
"group": "Showcase",
"icon": "clapperboard-play",
"pages": [
- "v2/pages/00_home/project-showcase/projects-built-on-livepeer",
- "v2/pages/00_home/project-showcase/livepeer-applications",
- "v2/pages/00_home/project-showcase/industry-verticals"
+ "v2/pages/00_home/project-showcase/showcase",
+ "v2/pages/00_home/project-showcase/industry-verticals",
+ "v2/pages/00_home/project-showcase/applications"
]
}
]
@@ -61,7 +62,7 @@
{
"anchor": "Get Started!",
"icon": "play",
- "pages": ["v2/pages/03_developers/"]
+ "pages": ["v2/pages/03_developers/building-on-livepeer/"]
},
{
"anchor": "Resource HUB",
@@ -88,29 +89,45 @@
"icon": "graduation-cap",
"pages": [
"v2/pages/01_about/about-portal",
+ "v2/pages/01_about/core-concepts/livepeer-overview",
"v2/pages/01_about/core-concepts/livepeer-core-concepts",
- "v2/pages/01_about/core-concepts/livepeer-glossary"
+ "v2/pages/01_about/core-concepts/mental-model"
]
},
{
"group": "Livepeer Protocol",
"icon": "cube",
"pages": [
- "v2/pages/01_about/livepeer-protocol/protocol-overview",
- "v2/pages/01_about/livepeer-protocol/livepeer-whitepaper",
- "v2/pages/01_about/livepeer-protocol/technical-overview",
- "v2/pages/01_about/livepeer-protocol/protocol-mechanisms"
+ "v2/pages/01_about/livepeer-protocol/overview",
+ "v2/pages/01_about/livepeer-protocol/core-mechanisms",
+ "v2/pages/01_about/livepeer-protocol/livepeer-token",
+ "v2/pages/01_about/livepeer-protocol/governance-model",
+ "v2/pages/01_about/livepeer-protocol/treasury",
+ "v2/pages/01_about/livepeer-protocol/protocol-economics",
+ "v2/pages/01_about/livepeer-protocol/technical-architecture"
]
},
{
"group": "Livepeer Network",
"icon": "circle-nodes",
"pages": [
- "v2/pages/01_about/livepeer-network/network-overview",
- "v2/pages/01_about/livepeer-network/actor-overview",
- "v2/pages/01_about/livepeer-network/governance-model",
- "v2/pages/01_about/livepeer-network/token",
- "v2/pages/01_about/livepeer-network/treasury"
+ "v2/pages/01_about/livepeer-network/overview",
+ "v2/pages/01_about/livepeer-network/actors",
+ "v2/pages/01_about/livepeer-network/job-lifecycle",
+ "v2/pages/01_about/livepeer-network/marketplace",
+ "v2/pages/01_about/livepeer-network/technical-architecture",
+ "v2/pages/01_about/livepeer-network/interfaces"
+ ]
+ },
+ {
+ "group": "Resources",
+ "icon": "books",
+ "pages": [
+ "v2/pages/01_about/resources/livepeer-whitepaper",
+ "v2/pages/01_about/resources/livepeer-glossary",
+ "v2/pages/01_about/resources/blockchain-contracts",
+ "v2/pages/01_about/resources/technical-roadmap",
+ "v2/pages/01_about/resources/gateways-vs-orchestrators"
]
}
]
@@ -128,7 +145,7 @@
]
},
{
- "tab": "Products",
+ "tab": "Platforms",
"icon": "film-canister",
"anchors": [
{
@@ -140,40 +157,119 @@
"icon": "play",
"pages": [
"v2/pages/010_products/products-portal",
- "v2/pages/010_products/products/builder-hub"
+ "v2/pages/010_products/products/all-ecosystem/product-hub",
+ "v2/pages/010_products/products/all-ecosystem/ecosystem-products"
]
},
{
"group": "Daydream",
- "icon": "video-camera",
+ "icon": "camera-movie",
"pages": [
"v2/pages/010_products/products/daydream/daydream"
]
},
{
"group": "Livepeer Studio",
- "icon": "user-robot",
+ "icon": "film-canister",
"pages": [
- "v2/pages/010_products/products/livepeer-studio/livepeer-studio"
+ "v2/pages/010_products/products/livepeer-studio/overview/overview",
+ "v2/pages/010_products/products/livepeer-studio/overview/client-use-cases",
+ {
+ "group": "Get started",
+ "pages": [
+ "v2/pages/010_products/products/livepeer-studio/getting-started/overview",
+ "v2/pages/010_products/products/livepeer-studio/overview/quickstart",
+ "v2/pages/010_products/products/livepeer-studio/getting-started/authentication",
+ "v2/pages/010_products/products/livepeer-studio/getting-started/studio-cli"
+ ]
+ },
+ {
+ "group": "Livestream",
+ "pages": [
+ "v2/pages/010_products/products/livepeer-studio/overview/livestream-overview",
+ "v2/pages/010_products/products/livepeer-studio/guides/create-livestream",
+ "v2/pages/010_products/products/livepeer-studio/guides/playback-livestream",
+ "v2/pages/010_products/products/livepeer-studio/guides/stream-via-obs",
+ "v2/pages/010_products/products/livepeer-studio/guides/livestream-from-browser",
+ "v2/pages/010_products/products/livepeer-studio/guides/multistream",
+ "v2/pages/010_products/products/livepeer-studio/guides/clip-livestream",
+ "v2/pages/010_products/products/livepeer-studio/guides/stream-health",
+ "v2/pages/010_products/products/livepeer-studio/guides/optimize-latency"
+ ]
+ },
+ {
+ "group": "Video on demand",
+ "pages": [
+ "v2/pages/010_products/products/livepeer-studio/overview/vod-overview",
+ "v2/pages/010_products/products/livepeer-studio/guides/upload-asset",
+ "v2/pages/010_products/products/livepeer-studio/guides/playback-asset",
+ "v2/pages/010_products/products/livepeer-studio/guides/encrypted-assets",
+ "v2/pages/010_products/products/livepeer-studio/guides/thumbnails-vod",
+ "v2/pages/010_products/products/livepeer-studio/guides/transcode-video"
+ ]
+ },
+ {
+ "group": "Access control & security",
+ "pages": [
+ "v2/pages/010_products/products/livepeer-studio/guides/access-control/overview",
+ "v2/pages/010_products/products/livepeer-studio/guides/access-control/webhooks",
+ "v2/pages/010_products/products/livepeer-studio/guides/access-control/jwt"
+ ]
+ },
+ {
+ "group": "Events & analytics",
+ "pages": [
+ "v2/pages/010_products/products/livepeer-studio/guides/webhooks",
+ "v2/pages/010_products/products/livepeer-studio/guides/listen-to-events",
+ "v2/pages/010_products/products/livepeer-studio/guides/analytics/overview"
+ ]
+ },
+ {
+ "group": "Player & embed",
+ "pages": [
+ "v2/pages/010_products/products/livepeer-studio/guides/player-and-embed"
+ ]
+ },
+ {
+ "group": "Reference",
+ "pages": [
+ "v2/pages/010_products/products/livepeer-studio/overview/api-overview",
+ "v2/pages/010_products/products/livepeer-studio/api-reference/overview",
+ "v2/pages/010_products/products/livepeer-studio/overview/sdks-overview",
+ "v2/pages/010_products/products/livepeer-studio/guides/managing-projects"
+ ]
+ }
]
},
{
"group": "Stream.place",
- "icon": "video-camera",
+ "icon": "projector",
"pages": [
"v2/pages/010_products/products/streamplace/streamplace",
- "v2/pages/010_products/products/streamplace/streamplace-guide",
- "v2/pages/010_products/products/streamplace/streamplace-architecture",
- "v2/pages/010_products/products/streamplace/streamplace-integration",
- "v2/pages/010_products/products/streamplace/streamplace-provenance",
- "v2/pages/010_products/products/streamplace/streamplace-funding"
+ {
+ "group": "Stream.place",
+ "pages": [
+ "v2/pages/010_products/products/streamplace/streamplace-guide",
+ "v2/pages/010_products/products/streamplace/streamplace-architecture",
+ "v2/pages/010_products/products/streamplace/streamplace-integration",
+ "v2/pages/010_products/products/streamplace/streamplace-provenance",
+ "v2/pages/010_products/products/streamplace/streamplace-funding"
+ ]
+ }
]
},
{
- "group": "All Ecosystem Products",
- "icon": "video-camera",
+ "group": "Embody Avatars",
+ "icon": "user-robot",
"pages": [
- "v2/pages/010_products/products/all-ecosystem/ecosystem-products"
+ "v2/pages/010_products/products/embody/overview"
+ ]
+ },
+ {
+ "group": "Frameworks",
+ "icon": "clapperboard-play",
+ "pages": [
+ "v2/pages/010_products/products/frameworks/frameworks"
]
}
]
@@ -204,25 +300,26 @@
"pages": [
"v2/pages/03_developers/developer-portal",
"v2/pages/03_developers/building-on-livepeer/developer-guide",
+ "v2/pages/03_developers/building-on-livepeer/partners",
+ "v2/pages/03_developers/building-on-livepeer/developer-journey"
+ ]
+ },
+ {
+ "group": "Quickstart",
+ "icon": "fast-forward",
+ "pages": [
{
- "group": "Quickstart",
- "icon": "fast-forward",
- "expanded": true,
+ "group": "Real-time Video",
"pages": [
- {
- "group": "Real-time Video",
- "pages": [
- "v2/pages/03_developers/building-on-livepeer/quick-starts/livepeer-ai",
- "v2/pages/03_developers/livepeer-real-time-video/video-streaming-on-livepeer/README.mdx"
- ]
- },
- {
- "group": "AI Pipelines",
- "pages": [
- "v2/pages/03_developers/building-on-livepeer/quick-starts/video-streaming",
- "v2/pages/03_developers/building-on-livepeer/quick-starts/livepeer-ai"
- ]
- }
+ "v2/pages/03_developers/building-on-livepeer/quick-starts/livepeer-ai",
+ "v2/pages/03_developers/livepeer-real-time-video/video-streaming-on-livepeer/README.mdx"
+ ]
+ },
+ {
+ "group": "AI Pipelines",
+ "pages": [
+ "v2/pages/03_developers/building-on-livepeer/quick-starts/video-streaming",
+ "v2/pages/03_developers/building-on-livepeer/quick-starts/livepeer-ai"
]
}
]
@@ -282,8 +379,8 @@
{
"group": "SDKs & APIs",
"pages": [
- "v2/pages/03_developers/technical-references-sdks.-and-apis/sdks",
- "v2/pages/03_developers/technical-references-sdks.-and-apis/apis"
+ "v2/pages/03_developers/technical-references/sdks",
+ "v2/pages/03_developers/technical-references/apis"
]
},
"v2/pages/03_developers/technical-references/awesome-livepeer",
@@ -312,24 +409,18 @@
"icon": "torii-gate",
"groups": [
{
- "group": "About Gateways",
+ "group": "Gateway Knowledge Hub",
"icon": "graduation-cap",
"pages": [
"v2/pages/04_gateways/gateways-portal",
- {
- "group": "Gateway Knowledge Hub",
- "expanded": true,
- "pages": [
- "v2/pages/04_gateways/about-gateways/gateway-explainer",
- "v2/pages/04_gateways/about-gateways/gateway-functions",
- "v2/pages/04_gateways/about-gateways/gateway-architecture",
- "v2/pages/04_gateways/about-gateways/gateway-economics"
- ]
- }
+ "v2/pages/04_gateways/about-gateways/gateway-explainer",
+ "v2/pages/04_gateways/about-gateways/gateway-functions",
+ "v2/pages/04_gateways/about-gateways/gateway-architecture",
+ "v2/pages/04_gateways/about-gateways/gateway-economics"
]
},
{
- "group": "Quickstart",
+ "group": "Quickstart ⚡",
"icon": "/snippets/assets/logos/Livepeer-Logo-Symbol-Light.svg",
"pages": [
"v2/pages/04_gateways/run-a-gateway/quickstart-a-gateway",
@@ -354,7 +445,7 @@
]
},
{
- "group": "Run Your Own Gateway",
+ "group": "Run A Gateway",
"icon": "sign-posts-wrench",
"pages": [
{
@@ -427,17 +518,11 @@
]
},
{
- "group": "Gateway Tools & Dashboards",
+ "group": "Gateway Tools & Resources",
"icon": "tools",
"pages": [
"v2/pages/04_gateways/gateway-tools/explorer",
- "v2/pages/04_gateways/gateway-tools/livepeer-tools"
- ]
- },
- {
- "group": "Gateway Guides & Resources",
- "icon": "laptop-file",
- "pages": [
+ "v2/pages/04_gateways/gateway-tools/livepeer-tools",
"v2/pages/04_gateways/guides-and-resources/community-guides",
"v2/pages/04_gateways/guides-and-resources/community-projects",
"v2/pages/04_gateways/guides-and-resources/faq"
@@ -527,51 +612,117 @@
"icon": "microchip",
"groups": [
{
- "group": "About Orchestrators (GPU Nodes)",
+ "group": "Orchestrator Knowledge Hub",
"icon": "graduation-cap",
"pages": [
"v2/pages/05_orchestrators/orchestrators-portal",
"v2/pages/05_orchestrators/about-orchestrators/overview",
- {
- "group": "Orchestrator Functions",
- "pages": [
- "v2/pages/05_orchestrators/about-orchestrators/orchestrator-functions/transcoding",
- "v2/pages/05_orchestrators/about-orchestrators/orchestrator-functions/ai-pipelines"
- ]
- }
+ "v2/pages/05_orchestrators/about-orchestrators/orchestrator-functions",
+ "v2/pages/05_orchestrators/about-orchestrators/architecture",
+ "v2/pages/05_orchestrators/about-orchestrators/economics"
+ ]
+ },
+ {
+ "group": "Quickstart ⚡",
+ "icon": "/snippets/assets/logos/Livepeer-Logo-Symbol-Theme.svg",
+ "pages": [
+ "v2/pages/05_orchestrators/quickstart/overview",
+ "v2/pages/05_orchestrators/quickstart/join-a-pool",
+ "v2/pages/05_orchestrators/quickstart/orchestrator-setup"
]
},
{
- "group": "Set up an Orchestrator",
+ "group": "Run an Orchestrator",
"icon": "gear-code",
"pages": [
- "v2/pages/05_orchestrators/setting-up-an-orchestrator/hardware-requirements",
- "v2/pages/05_orchestrators/setting-up-an-orchestrator/orchestrator-stats",
{
- "group": "Setting Up An Orchestrator",
+ "group": "Orchestrator Setup Guide",
"pages": [
- "v2/pages/05_orchestrators/setting-up-an-orchestrator/setting-up-an-orchestrator/quickstart-add-your-gpu-to-livepeer",
- "v2/pages/05_orchestrators/setting-up-an-orchestrator/join-a-pool",
- "v2/pages/05_orchestrators/setting-up-an-orchestrator/setting-up-an-orchestrator/data-centres-and-large-scale-hardware-providers"
+ "v2/pages/05_orchestrators/setting-up-an-orchestrator/overview",
+ {
+ "group": "Setup Checklist",
+ "pages": [
+ "v2/pages/05_orchestrators/setting-up-an-orchestrator/hardware-requirements"
+ ]
+ },
+ {
+ "group": "Installation",
+ "pages": [
+ "v2/pages/05_orchestrators/setting-up-an-orchestrator/orchestrator-stats"
+ ]
+ },
+ {
+ "group": "Configuration",
+ "pages": [
+ "v2/pages/05_orchestrators/setting-up-an-orchestrator/setting-up-an-orchestrator/quickstart-add-your-gpu-to-livepeer"
+ ]
+ },
+ {
+ "group": "Testing",
+ "pages": [
+ "v2/pages/05_orchestrators/setting-up-an-orchestrator/setting-up-an-orchestrator/data-centres-and-large-scale-hardware-providers"
+ ]
+ },
+ {
+ "group": "Network Integration",
+ "pages": [
+ "v2/pages/05_orchestrators/setting-up-an-orchestrator/setting-up-an-orchestrator/data-centres-and-large-scale-hardware-providers"
+ ]
+ },
+ {
+ "group": "Monitor & Optimise",
+ "pages": [
+ "v2/pages/05_orchestrators/setting-up-an-orchestrator/setting-up-an-orchestrator/data-centres-and-large-scale-hardware-providers"
+ ]
+ }
]
}
]
},
{
- "group": "Orchestrator Tooling",
- "icon": "tools",
+ "group": "Advanced Orchestrator Information",
+ "icon": "gamepad",
"pages": [
- "v2/pages/05_orchestrators/orchestrator-tooling/orchestrator-tools",
- "v2/pages/05_orchestrators/orchestrator-tooling/orchestrator-dashboards"
+ "v2/pages/05_orchestrators/advanced-setup/staking-LPT",
+ "v2/pages/05_orchestrators/advanced-setup/rewards-and-fees",
+ "v2/pages/05_orchestrators/advanced-setup/delegation",
+ "v2/pages/05_orchestrators/advanced-setup/ai-pipelines",
+ "v2/pages/05_orchestrators/advanced-setup/run-a-pool"
]
},
{
- "group": "Orchestrator Guides & Resources",
+ "group": "Orchestrator Tools & Resources",
"icon": "laptop-file",
"pages": [
- "v2/pages/05_orchestrators/orchestrator-guides-and-references/orchestrator-guides-and-references",
- "v2/pages/05_orchestrators/orchestrator-guides-and-references/orchestrator-resources",
- "v2/pages/05_orchestrators/orchestrator-guides-and-references/orchestrator-community-and-help"
+ "v2/pages/05_orchestrators/orchestrator-tools-and-resources/orchestrator-tools",
+ "v2/pages/05_orchestrators/orchestrator-tools-and-resources/community-pools",
+ "v2/pages/05_orchestrators/orchestrator-tools-and-resources/orchestrator-guides",
+ "v2/pages/05_orchestrators/orchestrator-tools-and-resources/orchestrator-resources",
+ "v2/pages/05_orchestrators/orchestrator-tools-and-resources/orchestrator-community-and-help"
+ ]
+ },
+ {
+ "group": "Technical References",
+ "icon": "code",
+ "pages": [
+ {
+ "group": "Orchestrators",
+ "pages": [
+ "v2/pages/05_orchestrators/references/faq"
+ ]
+ },
+ {
+ "group": "API & CLI Reference",
+ "pages": [
+ "v2/pages/05_orchestrators/references/cli-flags"
+ ]
+ },
+ {
+ "group": "On-Chain Reference",
+ "pages": [
+ "v2/pages/05_orchestrators/references/faq"
+ ]
+ }
]
}
]
@@ -600,42 +751,45 @@
"group": "About LPT",
"icon": "graduation-cap",
"pages": [
- "v2/pages/06_delegators/token-portal",
- "v2/pages/06_delegators/about-lpt-livepeer-token/overview",
- "v2/pages/06_delegators/about-lpt-livepeer-token/why-have-a-token",
- "v2/pages/06_delegators/about-lpt-livepeer-token/livepeer-token-economics",
- "v2/pages/06_delegators/about-lpt-livepeer-token/how-to-get-lpt",
- "v2/pages/06_delegators/about-lpt-livepeer-token/delegators"
+ "v2/pages/06_lptoken/token-portal",
+ "v2/pages/06_lptoken/about/overview",
+ "v2/pages/06_lptoken/about/purpose",
+ "v2/pages/06_lptoken/about/tokenomics",
+ "v2/pages/06_lptoken/about/mechanics"
]
},
{
"group": "Delegating LPT",
"icon": "money-bill-transfer",
"pages": [
- "v2/pages/06_delegators/delegating-lpt/overview",
- "v2/pages/06_delegators/delegating-lpt/delegation-economics",
- "v2/pages/06_delegators/delegating-lpt/how-to-delegate-lpt"
+ "v2/pages/06_lptoken/delegation/overview",
+ "v2/pages/06_lptoken/delegation/about-delegators",
+ "v2/pages/06_lptoken/delegation/delegation-guide"
]
},
{
"group": "Livepeer Governance",
"icon": "box-ballot",
"pages": [
- "v2/pages/06_delegators/livepeer-governance/overview",
- "v2/pages/06_delegators/livepeer-governance/livepeer-governance",
- "v2/pages/06_delegators/livepeer-governance/livepeer-treasury"
+ "v2/pages/06_lptoken/governance/overview",
+ "v2/pages/06_lptoken/governance/model",
+ "v2/pages/06_lptoken/governance/processes"
]
},
{
"group": "Livepeer Treasury",
- "pages": [" "]
+ "pages": [
+ "v2/pages/06_lptoken/treasury/overview",
+ "v2/pages/06_lptoken/treasury/proposals",
+ "v2/pages/06_lptoken/treasury/allocations"
+ ]
},
{
"group": "Guides & Resources",
"icon": "books",
"pages": [
- "v2/pages/06_delegators/token-resources/lpt-exchanges",
- "v2/pages/06_delegators/token-resources/lpt-eth-usage"
+ "v2/pages/06_lptoken/resources/exchanges",
+ "v2/pages/06_lptoken/resources/lpt-eth-usage"
]
}
]
@@ -665,14 +819,15 @@
"icon": "people-group",
"pages": [
"v2/pages/02_community/community-portal",
- "v2/pages/02_community/livepeer-community/livepeer-Latest-Topics",
- "v2/pages/02_community/livepeer-community/community-guidelines"
+ "v2/pages/02_community/livepeer-community/trending-topics",
+ "v2/pages/02_community/livepeer-community/roadmap"
]
},
{
"group": "Livepeer Connect",
"icon": "hashtag",
"pages": [
+ "v2/pages/02_community/livepeer-community/community-guidelines",
"v2/pages/02_community/livepeer-connect/news-and-socials",
"v2/pages/02_community/livepeer-connect/events-and-community-streams",
"v2/pages/02_community/livepeer-connect/forums-and-discussions"
@@ -696,9 +851,12 @@
]
},
{
- "group": "[TO DELETE] Tests",
+ "group": "Resources",
+ "icon": "books",
"pages": [
- "v2/pages/02_community/livepeer-community/trending-test"
+ "v2/pages/02_community/livepeer-community/media-kit",
+ "v2/pages/02_community/livepeer-community/trending-test",
+ "v2/pages/02_community/livepeer-community/latest-topics"
]
}
]
@@ -736,7 +894,23 @@
"v2/pages/07_resources/documentation-guide/documentation-overview",
"v2/pages/07_resources/documentation-guide/documentation-guide",
"v2/pages/07_resources/documentation-guide/docs-features-and-ai-integrations",
- "v2/pages/07_resources/documentation-guide/contribute-to-the-docs"
+ "v2/pages/07_resources/documentation-guide/style-guide",
+ "v2/pages/07_resources/documentation-guide/snippets-inventory",
+ "v2/pages/07_resources/documentation-guide/contribute-to-the-docs",
+ "v2/pages/07_resources/documentation-guide/automations-workflows",
+ {
+ "group": "Component Library",
+ "icon": "puzzle-piece",
+ "pages": [
+ "v2/pages/07_resources/documentation-guide/component-library",
+ "v2/pages/07_resources/documentation-guide/component-library/primitives",
+ "v2/pages/07_resources/documentation-guide/component-library/display",
+ "v2/pages/07_resources/documentation-guide/component-library/content",
+ "v2/pages/07_resources/documentation-guide/component-library/layout",
+ "v2/pages/07_resources/documentation-guide/component-library/integrations",
+ "v2/pages/07_resources/documentation-guide/component-library/domain"
+ ]
+ }
]
},
{
@@ -874,6 +1048,7 @@
"pages": [
"v2/pages/09_internal/internal-overview",
"v2/pages/09_internal/docs-status",
+ "v2/pages/09_internal/governance",
"v2/pages/09_internal/strategic-alignment",
"v2/pages/09_internal/docs-philosophy",
"v2/pages/09_internal/definitions",
@@ -2955,25 +3130,6 @@
"prompt": "Need help? Ask our AI"
},
"footer": {
- "links": [
- {
- "header": "links",
- "items": [
- {
- "label": "custom link here",
- "href": "https://livepeer.org"
- },
- {
- "label": "custom link here",
- "href": "https://livepeer.org"
- },
- {
- "label": "custom link here",
- "href": "https://livepeer.org"
- }
- ]
- }
- ],
"socials": {
"website": "https://forum.livepeer.org",
"github": "https://github.com/livepeer",
diff --git a/docs/ABOUT/00-NAV-AND-PAGE-INDEX.md b/docs/ABOUT/00-NAV-AND-PAGE-INDEX.md
new file mode 100644
index 000000000..b23d6cacb
--- /dev/null
+++ b/docs/ABOUT/00-NAV-AND-PAGE-INDEX.md
@@ -0,0 +1,72 @@
+# About Section — Nav Order & Page Index
+
+Source: `docs.json` (About tab). Use this order for reviews and IA.
+
+---
+
+## Nav order (docs.json)
+
+### Group 1: About Livepeer
+| # | Page path | File exists | Notes |
+|---|-----------|-------------|--------|
+| 1 | `v2/pages/01_about/about-portal` | ✅ about-portal.mdx | Portal; all cards currently link to livepeer-network/overview (wrong). |
+| 2 | `v2/pages/01_about/core-concepts/livepeer-overview` | ✅ | |
+| 3 | `v2/pages/01_about/core-concepts/livepeer-core-concepts` | ✅ | Duplicate content blocks; broken image ref. |
+| 4 | `v2/pages/01_about/core-concepts/mental-model` | ✅ | Stray `*/}` in Examples (syntax). |
+
+### Group 2: Livepeer Protocol
+| # | Page path | File exists | Notes |
+|---|-----------|-------------|--------|
+| 5 | `v2/pages/01_about/livepeer-protocol/overview` | ✅ | |
+| 6 | `v2/pages/01_about/livepeer-protocol/core-mechanisms` | ✅ | |
+| 7 | `v2/pages/01_about/livepeer-protocol/livepeer-token` | ✅ | |
+| 8 | `v2/pages/01_about/livepeer-protocol/governance-model` | ✅ | |
+| 9 | `v2/pages/01_about/livepeer-protocol/treasury` | ✅ | |
+| 10 | `v2/pages/01_about/livepeer-protocol/protocol-economics` | ✅ | |
+| 11 | `v2/pages/01_about/livepeer-protocol/technical-architecture` | ✅ | |
+
+### Group 3: Livepeer Network
+| # | Page path | File exists | Notes |
+|---|-----------|-------------|--------|
+| 12 | `v2/pages/01_about/livepeer-network/overview` | ✅ | Very short; placeholder feel. |
+| 13 | `v2/pages/01_about/livepeer-network/actors` | ✅ | Good content; opens with fragment. |
+| 14 | `v2/pages/01_about/livepeer-network/job-lifecycle` | ✅ | |
+| 15 | `v2/pages/01_about/livepeer-network/marketplace` | ✅ marketplace.mdx | Created from CONTEXT DATA/Network/livepeer_marketplace.md. |
+| 16 | `v2/pages/01_about/livepeer-network/technical-architecture` | ✅ technical-architecture.mdx | Created from CONTEXT DATA/Network/livepeer_technical_stack.md. |
+| 17 | `v2/pages/01_about/livepeer-network/interfaces` | ✅ interfaces.mdx | Created from CONTEXT DATA/Network/livepeer_interfaces.md; nav fixed (was interfaces?). |
+
+Existing files in `livepeer-network/` not in nav: `supply-side.mdx`, `scaling.mdx`, `fee-flow.mdx`, `demand-side.mdx`, `livepeer-actors/*` (orchestrators, gateways, end-users, delegators).
+
+### Group 4: Resources
+| # | Page path | File exists | Notes |
+|---|-----------|-------------|--------|
+| 18 | `v2/pages/01_about/resources/livepeer-whitepaper` | ✅ | |
+| 19 | `v2/pages/01_about/resources/livepeer-glossary` | ✅ | |
+| 20 | `v2/pages/01_about/resources/blockchain-contracts` | ✅ | |
+| 21 | `v2/pages/01_about/resources/technical-roadmap` | ✅ | |
+| 22 | `v2/pages/01_about/resources/gateways-vs-orchestrators` | ✅ | |
+
+---
+
+## Other 01_about pages (not in About nav)
+
+- `tab-index.mdx`
+- `faq-about.mdx` — **Not a FAQ.** Contains IA blueprint / structural notes (“Good. This is the right moment to fix the IA…”). Should be replaced with real FAQ or moved to internal.
+- `about-livepeer/moved/*` — Moved content; clarify if linked anywhere.
+
+---
+
+## Context data locations
+
+- **v2/pages/01_about/_contextData_/**
+ - `deep-research-report.md` (style guide + core mechanism overview, ELI5, mermaid)
+ - `deep-research-report (IA).md`
+ - `protocol-frameworks-report.mdx.md` (six-part framework, mental model, layered stack)
+
+- **docs/ABOUT/CONTEXT DATA/**
+ - `Protocol/` — livepeer_core_mechanisms.md, livepeer_governance_model.md, livepeer_protocol_economics.md, livepeer_technical_architecture.md, livepeer_treasury.md, livepeer_token.md, deep-research-report*.md
+ - `Network/` — livepeer_network_overview.md, livepeer_network_actors.md, livepeer_job_lifecycle.md, livepeer_marketplace.md, livepeer_interfaces.md, livepeer_technical_stack.md
+ - `Resources_References/livepeer_about_section_references.md` — canonical refs, metrics, external links
+ - `livepeer_ia_protocol_report.md`, `livepeer_docs_rebuild.md`
+
+Use these for accuracy checks, upgrade ideas, and ensuring copy aligns with canonical framing (protocol vs network, actors, rounds, Arbitrum, Confluence).
diff --git a/docs/ABOUT/ABOUT-SECTION-COPY-REVIEW.md b/docs/ABOUT/ABOUT-SECTION-COPY-REVIEW.md
new file mode 100644
index 000000000..f14c43685
--- /dev/null
+++ b/docs/ABOUT/ABOUT-SECTION-COPY-REVIEW.md
@@ -0,0 +1,381 @@
+# About Section — Copy Review (2026)
+
+Per-page review: accuracy, context data, upgrades, IA, style, completion, resources/media, code audit, modularisation.
+Pages follow **docs.json** nav order. Context sources: `v2/pages/01_about/_contextData_/` and `docs/ABOUT/CONTEXT DATA/`.
+
+---
+
+## 1. About Portal (`about-portal.mdx`)
+
+**2026 accuracy**
+- “Ethereum Mainnet and Arbitrum Mainnet” + “Since the Confluence upgrade, the protocol primarily runs on Arbitrum” is correct (Confluence live Feb 2022; protocol on Arbitrum).
+- “Gateways (formerly Broadcasters)” is correct.
+
+**Context data**
+- `livepeer_ia_protocol_report.md`: protocol vs network, roles; aligns with portal messaging.
+- `livepeer_about_section_references.md`: use for “Further reading” and explorer/contract links.
+
+**Upgrades**
+- Add one line on AI: e.g. “The network also runs AI inference (generative video, image, LLM) alongside transcoding.”
+- Keep technical but approachable; avoid jargon in the hero (e.g. “transcode” is fine; “probabilistic micropayments” better in Protocol pages).
+
+**IA**
+- Fix card links: all six cards point to `./livepeer-network/overview`. Should be: Core Concepts → `./core-concepts/livepeer-overview`, Mental Model → `./core-concepts/mental-model`, Livepeer Protocol → `./livepeer-protocol/overview`, Livepeer Network → `./livepeer-network/overview`, Glossary → `./resources/livepeer-glossary`, Whitepaper → `./resources/livepeer-whitepaper`.
+- Consider a “Quick links” strip under the hero (Overview, Protocol, Network, Glossary, Whitepaper) for scannability.
+
+**Style**
+- Normalise spacing in imports (e.g. `H5,P` → `H5, P`).
+- Remove commented-out blocks before publish or move to internal.
+
+**Complete?**
+- **No.** Broken card links; optional hero line on AI.
+
+**Resources / media**
+- [Confluence upgrade (Medium)](https://medium.com/livepeer-blog/the-confluence-upgrade-is-live-3b6b342ea71e) — link in “Learn more” or Resources.
+- [Livepeer Explorer](https://explorer.livepeer.org/) — “See the network” CTA.
+- Short hero video or GIF: stream → transcoding → playback (e.g. from Livepeer marketing or a 30s Loom).
+
+**Code audit**
+- Typo: “incenticises” in overview copy (if present) → “incentivises”.
+- Portal imports: 7 lines; consider barrel (see DRY report).
+- `LogoHeroContainer` uses `height="20px"`; other portals use `imgHeight` — normalise prop name.
+
+**Modularise**
+- Extract overview paragraph + “Key concepts” list into a snippet (e.g. `AboutPortalCopy.jsx` or MDX fragment) so portal and other landing pages can reuse.
+- Card grid: consider a data-driven component (e.g. `aboutPortalCards` in a JSON/JS) to avoid link drift.
+
+---
+
+## 2. Livepeer Overview (`core-concepts/livepeer-overview.mdx`)
+
+**2026 accuracy**
+- Protocol on Arbitrum, LPT on L1, network off-chain: correct.
+- DePIN framing and “demand-side / supply-side / protocol” match current positioning.
+- “Rounds” — context data says ~6 hrs in one place, ~21.5 hrs in another; verify current round length (RoundsManager) and state once in docs.
+
+**Context data**
+- `_contextData_/deep-research-report.md`: Executive Summary, ELI5, actors, rounds, Trickle pipeline — use to enrich “Protocol vs Network” and add one short ELI5 paragraph.
+- `livepeer_ia_protocol_report.md`: table of contracts (BondingManager, TicketBroker, RoundsManager, Governor, LivepeerToken); consider adding a “Protocol at a glance” table.
+
+**Upgrades**
+- Add 1–2 sentences on Livepeer AI (beta) and that AI jobs are routed off-protocol (gateway → orchestrator) for 2026 clarity.
+- Replace or supplement “Platforms? Workers?” card with “Developers & platforms” and link to Products/Developers; remove question mark.
+
+**IA**
+- Good separation of Protocol / Network / Protocol vs Network / Actors.
+- “See more on the architectural layers” link to mental-model is correct; add a back-link from mental-model to this page.
+
+**Style**
+- Fix typo “incenticises” → “incentivises”.
+- Remove or collapse the large `` block for production; move to internal or delete.
+
+**Complete?**
+- **Mostly.** Needs typo fix, optional ELI5, and cleanup of old notes.
+
+**Resources / media**
+- Mermaid diagram in `deep-research-report.md` (Gateway → Orchestrator → CDN, Delegator → Orchestrator, Rewards) — port into this page.
+- [Token Flows – mechanism design](https://tokenflows.xyz/tutorials/introduction-tutorials/module3/) already linked; keep.
+- [Livepeer Explorer – network stats](https://explorer.livepeer.org/) for “See the network in action”.
+
+**Code audit**
+- `LinkArrow` import from `'snippets/components/...'` (no leading slash); other imports use `/snippets/...` — use consistent path style.
+- QuadGrid + 4 Cards: consider shared “ActorsOverview” component used here and in actors.mdx.
+
+**Modularise**
+- “Protocol vs Network” table + “On-chain vs Off-chain” bullets → reusable snippet (e.g. `ProtocolNetworkComparison.mdx`).
+- Actor cards (Orchestrators, Gateways, Delegators, Platforms) → data-driven component or snippet to keep nav links (e.g. /orchestrators, /gateways) in one place.
+
+---
+
+## 3. Livepeer Core Concepts (`core-concepts/livepeer-core-concepts.mdx`)
+
+**2026 accuracy**
+- On-chain vs off-chain and “Bridge” (ETH deposits, tickets, LPT for staking not payment) are accurate.
+- “Livepeer Protocol = Arbitrum One” and “LPT = Ethereum mainnet” correct.
+
+**Context data**
+- Same as §2; `deep-research-report.md` “Core Mechanism” and protocol/network separation align.
+- Fix: trailing “U” in “on‑chainU” (typo).
+
+**Upgrades**
+- Add one sentence that AI inference is part of the network layer (orchestrators/workers), not a separate “actor type,” for 2026.
+- “Broadcasters” in the Network list: add “(legacy term; see Gateways)” to avoid confusion.
+
+**IA**
+- Duplicate structure: “Overview and separation” + Tabs (Overview, Protocol, Network, Actors) then again “# Overview” and “# Core Concepts” with repeated tables. Consolidate into a single flow: intro → Protocol vs Network table → On-chain vs Off-chain → Actors (reuse from livepeer-overview or actors.mdx).
+- Remove duplicate “# Overview” and “# Livepeer Actors” blocks; keep one canonical version.
+
+**Style**
+- Remove or replace broken image: `../../.gitbook/assets/image (1).png` (missing; placeholder “INSERT LIVEPEER ACTOR DIAGRAM”). Use a diagram from context (mermaid) or link to Explorer.
+
+**Complete?**
+- **No.** Duplicate content, broken image, typo “on‑chainU”.
+
+**Resources / media**
+- Use mermaid “Actors and flow” from context data.
+- Link to “Actors” page and “Mental model” for deeper dives.
+
+**Code audit**
+- Imports: `Protocol`, `Network`, `Actors` from snippets/pages/01_ABOUT/concepts/ — ensure those files exist and paths are correct (case: 01_ABOUT).
+- Tabs: ensure Tab title matches content (Overview vs Protocol vs Network vs Actors).
+
+**Modularise**
+- Replace inline Protocol/Network/Actors copy with the same snippets used in livepeer-overview or dedicated `concepts/protocol.mdx`, `network.mdx`, `actors.mdx` to avoid drift.
+- Single “Protocol vs Network” table component used here and in livepeer-overview.
+
+---
+
+## 4. Mental Model (`core-concepts/mental-model.mdx`)
+
+**2026 accuracy**
+- OSI-like stack and “crypto-economic control plane” are accurate.
+- Layer 7 (Daydream, Streamplace, Studio) and “AI Gateways” are current; “Cascade” appears in context — add if it’s a public product name.
+
+**Context data**
+- `protocol-frameworks-report.mdx.md`: six-part framework and layered stack — aligns; consider citing “canonical stack” in a short intro.
+- `livepeer_ia_protocol_report.md`: Layer 7 examples; confirm Cascade vs “Cascade” naming.
+
+**Upgrades**
+- Add 1–2 sentences on “AI workloads” in Layer 3 (Distributed Execution) and Layer 7 (e.g. Daydream for AI).
+- Fix syntax error: Line ~256 `**Examples:** ... Metaverse/XR video. */}` — remove stray `*/}` (leftover comment close).
+
+**IA**
+- Clear progression Layer 1 → 10.
+- “See More Products & Platforms” and “See the Showcase” links are correct; ensure 010_products and 00_home paths work in production.
+
+**Style**
+- Replace inline `style={{ border: "1px solid #2d9a67", ... }}` with a shared “InfoCard” or theme variable (e.g. `var(--livepeer-green)`) for consistency and light mode.
+- ` image would be good ` — either add an image or remove.
+
+**Complete?**
+- **Mostly.** Syntax fix required; optional Layer 3/7 AI line.
+
+**Resources / media**
+- [OSI model (Wikipedia)](https://en.wikipedia.org/wiki/OSI_model) — already referenced; keep.
+- Diagram: “Stack diagram” (Protocol / Network / Platform layers) as image or mermaid for hero.
+- Video: “What is DePIN?” or “Livepeer in 2 minutes” if available (e.g. YouTube).
+
+**Code audit**
+- Long commented block at end (Lines ~284–428): remove or move to internal doc.
+- Accordion components: ensure `description` prop (with Subtitle/Badge) is consistent; no missing closing tags.
+
+**Modularise**
+- Each Accordion (Layer 1–10) could be driven from a config array (title, OSI label, badges, body) to reduce duplication and ease reorder.
+- Shared “LayerCard” or “StackLayer” component for the green-bordered layer boxes.
+
+---
+
+## 5. Protocol Overview (`livepeer-protocol/overview.mdx`)
+
+**2026 accuracy**
+- “Protocol is on-chain coordination, security and economic layer” and contract roles (BondingManager, RoundsManager, TicketBroker, Governor, Treasury) are correct.
+- Whitepaper 2017 and Confluence/Arbitrum are accurate.
+- Typo: “cyrptoeconomic” → “cryptoeconomic”.
+
+**Context data**
+- `docs/ABOUT/CONTEXT DATA/Protocol/livepeer_core_mechanisms.md`: Bonding flow, parameters, delegation — use to cross-check.
+- `livepeer_ia_protocol_report.md`: Contract table and job routing (transcoding stake-based; AI non-protocol-routed) — add one sentence on AI job routing for 2026.
+
+**Upgrades**
+- Add a single “Protocol at a glance” table (contract → purpose) from context; link to blockchain-contracts for detail.
+- Clarify round duration (e.g. “~6 hours” or “~21.5 hours” per RoundsManager) once confirmed.
+
+**IA**
+- Accordion section map (Core Mechanisms, LPT, Governance, Treasury, Protocol Economics, Technical Architecture) is good; links are correct.
+- Add “Next: Core Mechanisms” or breadcrumb at bottom.
+
+**Style**
+- Fix “cyrptoeconomic” and “its essential” → “it’s essential”.
+- Quote component: keep; ensure FrameQuote and Card for whitepaper are consistent with rest of section.
+
+**Complete?**
+- **Yes** after typo fixes and optional table.
+
+**Resources / media**
+- [Livepeer Whitepaper (GitHub)](https://github.com/livepeer/wiki/blob/master/WHITEPAPER.md) — already linked.
+- [Token Flows – Game theory](https://tokenflows.xyz/tutorials/introduction-tutorials/module3/) — already linked.
+- [Governance / LIPs](https://forum.livepeer.org/c/lips/) — add in “Governance” paragraph.
+
+**Code audit**
+- `LinkArrow` from `'snippets/components/...'` (no leading slash) — align with codebase convention.
+- DynamicTable: ensure headerList/itemsList are consistent; consider shared “ContractTable” for protocol pages.
+
+**Modularise**
+- “Protocol Design 101” and “Guiding Principles” could be a shared snippet for protocol intro.
+- Contract list → from a single data file (e.g. `protocolContracts.json`) so overview and blockchain-contracts stay in sync.
+
+---
+
+## 6. Core Mechanisms (`livepeer-protocol/core-mechanisms.mdx`)
+
+**2026 accuracy**
+- Staking, delegation, inflation, slashing, rounds, ticket system align with context and protocol.
+- Context notes that slashing can be disabled/evolving — add a short caveat (“Slashing is part of the design; current status may vary. See governance and LIPs.”).
+
+**Context data**
+- `Protocol/livepeer_core_mechanisms.md`: Bonding flow mermaid, parameters (unbonding 7 days), rewardCut/feeShare — use to validate and add one mermaid diagram.
+
+**Upgrades**
+- Add a simple mermaid “Bonding flow” (User stakes → Select Orchestrator → BondingManager → Eligible for work → Rewards).
+- One sentence on how tickets work (probabilistic payment per segment) without full detail; link to technical-architecture or resources.
+
+**IA**
+- Fits under Protocol; cross-links to livepeer-token, governance-model, protocol-economics are logical.
+- Add “See also: Livepeer Token” and “See also: Protocol Economics” at bottom.
+
+**Style**
+- AccordionGroup: ensure all accordions have titles and bodies; consistent icon use.
+
+**Complete?**
+- **Yes** with optional diagram and slashing caveat.
+
+**Resources / media**
+- [BondingManager (GitHub)](https://github.com/livepeer/protocol/blob/master/contracts/bonding/BondingManager.sol) — link in “Parameters” or “Further reading”.
+- [Explorer – Staking](https://explorer.livepeer.org/) — “Stake or delegate” CTA.
+
+**Code audit**
+- DynamicTable usage: check column alignment and monospaceColumns.
+- ValueResponseField: ensure it’s used consistently with other protocol pages.
+
+**Modularise**
+- Mechanism list (staking, delegation, inflation, slashing, rounds) → shared “MechanismSummary” component or data file for protocol section.
+
+---
+
+## 7–11. Livepeer Protocol (remaining pages)
+
+**livepeer-token, governance-model, treasury, protocol-economics, technical-architecture**
+- Apply same pattern: (1) Verify 2026 facts (Arbitrum, LPT on L1, round length, inflation mechanics). (2) Cross-check with `docs/ABOUT/CONTEXT DATA/Protocol/*.md` and `livepeer_about_section_references.md` for metrics (totalBonded, inflationRate, treasury). (3) Add “See also” and explorer/forum links. (4) Fix any typos and normalise components (DynamicTable, Cards, Accordions). (5) Consider shared “ProtocolPageLayout” or intro snippet for consistency.
+
+---
+
+## 12. Network Overview (`livepeer-network/overview.mdx`)
+
+**2026 accuracy**
+- Gateways, Orchestrators, Delegators roles are correct.
+- Node types (Broadcaster Node, Gateway Node, Orchestrator, Transcoder, AI Worker) match go-livepeer; “LivepeerNode” and “LivpeerServer” typo → “LivepeerServer”.
+
+**Context data**
+- `Network/livepeer_network_overview.md`: session lifecycle (video example), compute separation (video vs AI), key participants table — use to expand this page (add session diagram and “Video vs AI” subsection).
+
+**Upgrades**
+- Add 2–3 short paragraphs from context: “What is the Livepeer Network?”, “Key network participants” table, and one mermaid “Session lifecycle: video example.”
+- Clarify “Broadcaster Node” vs “Gateway Node” (Gateway = broadcaster + AI session manager); add one line on Trickle/segment routing.
+
+**IA**
+- This page is currently very short; it should be the main “Network” entry. Add structure: What is the network? → Node types → Core components → How it fits with protocol (link to Protocol overview).
+- Fix nav: add missing “marketplace” and “technical-architecture” pages under Livepeer Network or remove from docs.json until created.
+
+**Style**
+- Replace generic “Core Components” list with the table from context (Gateway Nodes, Orchestrators, Workers, etc.) for scannability.
+
+**Complete?**
+- **No.** Too thin; typo “LivpeerServer”; needs content from context.
+
+**Resources / media**
+- [go-livepeer](https://github.com/livepeer/go-livepeer) — link for “Orchestrator Node.”
+- Session lifecycle mermaid from context.
+- Optional: short video “From stream to transcoded output” (architecture walkthrough).
+
+**Code audit**
+- PreviewCallout at top: consider moving to frontmatter-driven layout when available.
+- Incomplete “Broadcast Sessions Manager:” and “Orchestrator” / “Transcoder” lines — finish or remove.
+
+**Modularise**
+- “Node types” and “Core components” → shared snippet or table component used in network section.
+- Reuse “Actors” table from actors.mdx or context for consistency.
+
+---
+
+## 13. Actors (`livepeer-network/actors.mdx`)
+
+**2026 accuracy**
+- Three main roles (Orchestrators, Delegators, Gateways) and “Gateways (formerly Broadcasters)” are correct.
+- Confluence and “migrated to Arbitrum” are accurate.
+- “Transcoders now refer simply to the GPU instances attached to Orchestrators” — good clarification.
+
+**Context data**
+- `Network/livepeer_network_actors.md` and context “Key network participants” — align table and role descriptions.
+- `_contextData_/deep-research-report.md`: ELI5 (Uber for video) — consider adding a short “In a nutshell” callout.
+
+**Upgrades**
+- Fix opening: page starts with “and performs actions defined by the system” (fragment). Prepend “A Livepeer actor is any role or entity that participates in the Livepeer protocol or network ” so the first sentence is complete.
+- Add “Role summary” table at top (Actor | Stake | Responsibilities | Earns) from protocol overview or context.
+
+**IA**
+- Good fit under Livepeer Network.
+- Cross-link to livepeer-protocol/overview (Actors and Roles) and to gateways/orchestrators/delegators sections in other tabs.
+
+**Style**
+- Use consistent heading levels (## for main sections, ### for subsections).
+- “Key Role Flow” line: format as a small diagram or bullet list for readability.
+
+**Complete?**
+- **No.** Opening sentence fragment must be fixed.
+
+**Resources / media**
+- [Explorer – Orchestrators](https://explorer.livepeer.org/) — “See active orchestrators.”
+- Diagram: “Actors and flow” (Gateway → Orchestrator → Delegator, with “stake” and “jobs/fees” labels) from context mermaid.
+
+**Code audit**
+- Ensure no broken internal links.
+- “--” on its own line: replace with proper divider component or remove.
+
+**Modularise**
+- Role summary table → shared “ActorsTable” used in protocol overview and here.
+- “Core Actors” and “Role Summary” sections could be driven from a single data structure (e.g. `aboutActors.js`).
+
+---
+
+## 14. Job Lifecycle & remaining Network pages
+
+**job-lifecycle.mdx**
+- Cross-check with `docs/ABOUT/CONTEXT DATA/Network/livepeer_job_lifecycle.md` for 2026 accuracy and add sequence diagram if missing.
+- Ensure video vs AI job paths are both described (or linked to Gateways/Orchestrators docs).
+
+**Missing from nav**
+- `marketplace`, `technical-architecture`, `interfaces?`: either create placeholder pages or remove from docs.json. If created, use `Network/livepeer_marketplace.md`, `livepeer_technical_stack.md`, `livepeer_interfaces.md` from context.
+
+---
+
+## 15–17. (Placeholders for marketplace, technical-architecture, interfaces)
+
+- **Recommendation:** Remove `livepeer-network/marketplace`, `livepeer-network/technical-architecture`, and `livepeer-network/interfaces?` from docs.json until pages exist, or add stub pages that link to “Coming soon” and point to Network overview / Protocol technical-architecture.
+- Context has `livepeer_marketplace.md`, `livepeer_technical_stack.md`, `livepeer_interfaces.md` — use when drafting.
+
+---
+
+## 18–22. Resources (whitepaper, glossary, blockchain-contracts, technical-roadmap, gateways-vs-orchestrators)
+
+**livepeer-whitepaper.mdx**
+- 2026: Accurate; “Livepeer today” and “Key technical shifts (Streamflow, Arbitrum, AI)” are good.
+- Add “Last updated” or “Whitepaper as of 2017; network has evolved (Arbitrum, AI).”
+- Merkle Mine and ICO note: keep; good colour.
+- ExternalContent: ensure GitHub embed or link works; fallback to “View on GitHub” if embed fails.
+
+**livepeer-glossary.mdx, blockchain-contracts.mdx, technical-roadmap.mdx, gateways-vs-orchestrators.mdx**
+- Verify against `Resources_References/livepeer_about_section_references.md` and context Protocol/Network files.
+- Ensure contract addresses and ABIs are 2026 (Arbitrum); link to Arbiscan and Explorer.
+- technical-roadmap: align with public roadmap; add “Current focus (2026)” if available.
+
+**Resources / media (section-wide)**
+- [Explorer](https://explorer.livepeer.org/), [Forum LIPs](https://forum.livepeer.org/c/lips/), [Protocol GitHub](https://github.com/livepeer/protocol), [Streamflow](https://blog.livepeer.org/the-streamflow-upgrade-to-livepeer/), [Daydream](https://blog.livepeer.org/introducing-daydream), [Cascade](https://blog.livepeer.org/introducing-cascade) — use in “Further reading” and inline where relevant.
+
+---
+
+## Summary: completion and priority
+
+| Priority | Item |
+|----------|------|
+| **P0** | Fix about-portal card links (all point to livepeer-network/overview). |
+| **P0** | Fix actors.mdx opening fragment; fix livepeer-core-concepts duplicate content and “on‑chainU”; fix mental-model `*/}`. |
+| **P0** | Fix typos: “incenticises”, “cyrptoeconomic”, “its essential”, “LivpeerServer”. |
+| **P1** | Remove or fix docs.json entries for missing pages (marketplace, technical-architecture, interfaces?). |
+| **P1** | Expand livepeer-network/overview using context data (session lifecycle, participants table). |
+| **P1** | Replace or remove broken image in livepeer-core-concepts; remove large commented blocks for production. |
+| **P2** | Add ELI5 or “At a glance” where suggested; add mermaid diagrams from context; link Explorer/Forum/contracts. |
+| **P2** | faq-about.mdx: replace IA blueprint with real FAQ or move to internal. |
+
+---
+
+*Next: see [ABOUT-SECTION-STYLE-GUIDE.md](./ABOUT-SECTION-STYLE-GUIDE.md) for copy, components, branding, and styling.*
diff --git a/docs/ABOUT/ABOUT-SECTION-STYLE-GUIDE.md b/docs/ABOUT/ABOUT-SECTION-STYLE-GUIDE.md
new file mode 100644
index 000000000..aa8e8659c
--- /dev/null
+++ b/docs/ABOUT/ABOUT-SECTION-STYLE-GUIDE.md
@@ -0,0 +1,146 @@
+# About Section — Style Guide
+
+Canonical guide for **copy**, **components**, **branding**, and **styling** in the v2 About section (01_about). Use this when creating or editing About pages so the section feels consistent and on-brand.
+
+---
+
+## 1. Copy and voice
+
+### Tone
+- **Technical but approachable.** Explain protocol and network concepts clearly; avoid unnecessary jargon. Define terms on first use (e.g. “staking,” “round,” “ticket,” “Gateway”).
+- **Confident and current.** Use present tense and 2026-accurate facts (Arbitrum, Confluence, AI network). Avoid “will” for already-shipped features.
+- **Concise.** Short paragraphs (2–4 sentences). Use bullets and tables for lists and comparisons. One main idea per paragraph.
+
+### Terminology (consistent across About)
+| Use | Avoid / clarify |
+|-----|------------------|
+| **Gateway** (primary term for job-submitting node) | “Broadcaster” only when noting “formerly Broadcasters” or legacy context. |
+| **Orchestrator** | Not “transcoder” for the node role; “Transcoder” = worker/process attached to an Orchestrator. |
+| **Delegator** | LPT holders who bond to Orchestrators. |
+| **Protocol** (on-chain) | Use for contracts, staking, governance, payments. |
+| **Network** (off-chain) | Use for nodes, transcoding, AI inference, job routing. |
+| **Stake / bond / delegate** | Use consistently: “stake LPT,” “bond to an Orchestrator,” “delegate.” |
+| **LPT** | “Livepeer Token” on first use per page; then LPT. |
+| **Confluence** | “Confluence upgrade” when referring to Arbitrum migration (Feb 2022). |
+| **Round** | Define once (e.g. “protocol round (~X hours)”); link to RoundsManager or docs. |
+
+### Structure per page
+- **Opening:** One or two sentences stating what the page covers and why it matters.
+- **Body:** Clear headings (H2, H3); one theme per section. Prefer tables and bullets over long prose for roles, contracts, and comparisons.
+- **Progressive depth:** Optional “Executive summary” or “In a nutshell” at top for key pages (Overview, Protocol overview, Network overview); then detail.
+- **Closing:** “See also” or “Next” links to related About pages and to Gateways/Orchestrators/Developers where relevant.
+
+### Spelling and grammar
+- **UK or US:** Pick one and stick to it (e.g. “decentralised” vs “decentralized”). Current docs mix; recommend **US** for consistency with “docs.livepeer.org” and code (e.g. “BondingManager”).
+- **Typos to fix:** “incenticises” → “incentivises”; “cyrptoeconomic” → “cryptoeconomic”; “its essential” → “it’s essential”; “LivpeerServer” → “LivepeerServer”; “on‑chainU” → “on-chain.”
+
+---
+
+## 2. Components
+
+### Shared patterns
+- **Callouts:** Use ``, ``, `` for asides. Reserve `` for warnings (e.g. slashing, migration deadlines). Use a single “under construction” pattern (e.g. PreviewCallout) driven by frontmatter or wrapper where possible (see DRY report).
+- **Cards:** Use for primary CTAs (e.g. “Read the Whitepaper,” “See Contract Addresses,” “Go to Orchestrators”). Prefer `horizontal` and `arrow` for links. Keep title and description short.
+- **Tables:** Use `DynamicTable` or a shared `StyledTable` for contract lists, role summaries, and comparisons. Avoid inline style objects; use theme variables or a table component (see DRY).
+- **Accordions:** Use for “Learn more” or long reference content (e.g. protocol mechanisms, stack layers). Keep title concise; body can be bullets or short paragraphs.
+- **Quotes:** Use `` or `` for whitepaper or key protocol statements; attribute clearly.
+
+### About-specific
+- **Portal hero:** Same structure across About, Gateways, Orchestrators, etc.: HeroSectionContainer, HeroImageBackgroundComponent (e.g. Starfield), HeroContentContainer, LogoHeroContainer, PortalHeroContent (title, subtitle, refCardLink, overview). Keep overview to 2–4 sentences.
+- **Protocol section map:** Accordion grid (e.g. Core Mechanisms, LPT, Governance, Treasury, Protocol Economics, Technical Architecture) with AccordionTitleWithArrow linking to child pages. Reuse pattern on Protocol overview.
+- **Stack / mental model:** Use Accordions for each layer; optional Badge for “Protocol,” “Orchestrators,” “Gateways.” Prefer theme colours over hardcoded hex (e.g. `var(--accent)` or `var(--livepeer-green)`).
+
+### Do not
+- Rely on `.gitbook/assets` or broken image paths; use `/snippets/assets/` or hosted URLs.
+- Leave “INSERT DIAGRAM HERE” or “image would be good” in published copy; add asset or remove.
+- Use different import path styles (e.g. `'snippets/...'` vs `'/snippets/...'`); pick one (prefer `/snippets/...`).
+
+---
+
+## 3. Branding
+
+### Livepeer positioning (About section)
+- **Tagline-style:** “Decentralized infrastructure for real-time video and AI” or “Open, on-demand AI & media infrastructure.”
+- **DePIN:** Use when framing the project (“one of the earliest DePIN projects”); link to a short explainer or blog if needed.
+- **Product names:** Use official names: Livepeer Protocol, Livepeer Network, Livepeer Token (LPT), go-livepeer, Daydream, Streamplace, Livepeer Studio. Use “Cascade” only if it’s the current public name (confirm with product).
+
+### Links and CTAs
+- **Primary:** Explorer (explorer.livepeer.org), Protocol GitHub (github.com/livepeer/protocol), Forum LIPs (forum.livepeer.org/c/lips/), Whitepaper (github.com/livepeer/wiki/blob/master/WHITEPAPER.md).
+- **Secondary:** Contract addresses (docs or Arbiscan), Streamflow blog, Daydream/Cascade posts, Token Flows (tokenflows.xyz) for mechanism design.
+- **Internal:** Prefer relative links within 01_about (e.g. `./livepeer-protocol/overview`, `../resources/livepeer-glossary`). Use full path for other tabs (e.g. `/gateways`, `/orchestrators`) as per routing.
+
+### Visual identity
+- **Colour:** Use theme variables (e.g. `var(--accent)`, `var(--livepeer-green)`) instead of hardcoded `#2d9a67` or `#b636dd` so light/dark and future themes stay consistent.
+- **Icons:** Use Mintlify/GitBook icon set consistently (e.g. `cube` for protocol, `circle-nodes` for network, `coin` for token).
+- **Logos:** Use official assets from `/snippets/assets/` (e.g. LivepeerDocsLogo.svg, domain-specific social previews). Do not introduce ad-hoc logos.
+
+---
+
+## 4. Styling
+
+### Layout
+- **Portal pages:** Full-width hero; then content in PortalContentContainer. Keep card grids to 2 columns on desktop (e.g. `Columns cols={2}`).
+- **Content pages:** Standard doc layout with sidebar. Use H2 for main sections, H3 for subsections; avoid deep nesting (H4 max).
+- **Spacing:** Use consistent vertical rhythm (e.g. marginBottom on Dividers and sections). Avoid negative margins except where already in use for visual alignment.
+
+### Inline styles
+- **Minimise.** Prefer components (Card, Accordion, Badge, Table) over raw `style={{}}`. Where needed (e.g. layer boxes in mental-model), use a shared “LayerCard” or theme variables.
+- **Borders and boxes:** Use theme colour and a shared border-radius (e.g. 8px) so all boxes in About look the same.
+
+### Typography
+- **Headings:** Sentence case or title case consistently. No full caps for section titles.
+- **Code:** Use backticks for contract names, repo names, and technical terms (e.g. `BondingManager`, `go-livepeer`, `TicketBroker`).
+- **Lists:** Use `-` or `*` for unordered lists; numbered lists for steps. Keep list items short (one line where possible).
+
+---
+
+## 5. IA and navigation
+
+### About tab structure (docs.json)
+- **About Livepeer:** about-portal, core-concepts (livepeer-overview, livepeer-core-concepts, mental-model).
+- **Livepeer Protocol:** overview, core-mechanisms, livepeer-token, governance-model, treasury, protocol-economics, technical-architecture.
+- **Livepeer Network:** overview, actors, job-lifecycle; then marketplace, technical-architecture, interfaces only when pages exist.
+- **Resources:** livepeer-whitepaper, livepeer-glossary, blockchain-contracts, technical-roadmap, gateways-vs-orchestrators.
+
+### Cross-linking
+- From Portal: every card must link to the correct child page (not all to livepeer-network/overview).
+- From Protocol overview: link to each Protocol subpage and to Resources (whitepaper, blockchain-contracts).
+- From Network overview: link to actors, job-lifecycle, and (if present) marketplace/technical-architecture; link to Gateways/Orchestrators tabs for “Run a node” or “Use the network.”
+- From Mental model: link to Products and Showcase; keep paths correct (010_products, 00_home).
+
+### Breadcrumbs and “See also”
+- Rely on sidebar for hierarchy. Add inline “See also” at the bottom of long pages (e.g. “See also: Core Mechanisms, Livepeer Token, Governance”).
+
+---
+
+## 6. Context data and accuracy
+
+### When editing About pages
+- **Check:** `v2/pages/01_about/_contextData_/` and `docs/ABOUT/CONTEXT DATA/` for canonical phrasing, contract names, and structure (protocol vs network, actors, rounds).
+- **Metrics:** Use `livepeer_about_section_references.md` for explorer, inflation, treasury, and contract links; update addresses/ABIs for 2026 (Arbitrum).
+- **Diagrams:** Prefer mermaid in repo or snippets over external images so they stay in sync. Use context reports (e.g. deep-research-report.md, protocol-frameworks-report) for flow and stack diagrams.
+
+### 2026 accuracy checklist
+- [ ] Protocol on Arbitrum; LPT on Ethereum L1.
+- [ ] Confluence and migration referenced correctly (Feb 2022).
+- [ ] AI network and “AI jobs” described where relevant (gateway → orchestrator; non-protocol-routed).
+- [ ] Round duration and slashing status stated or linked (governance/LIPs).
+- [ ] Contract list and links match current deployments (Arbiscan, docs).
+- [ ] Product names (Daydream, Streamplace, Studio, Cascade) current and correctly spelled.
+
+---
+
+## 7. Checklist for new or revised About pages
+
+- [ ] Title and description match the page purpose; keywords include main terms (livepeer, protocol/network, topic).
+- [ ] First use of “LPT,” “Gateway,” “Orchestrator,” “Delegator” clarified if needed.
+- [ ] No broken links (internal or external); card and Accordion links point to the right pages.
+- [ ] No placeholder text (“INSERT…”, “image would be good”) left in published copy.
+- [ ] Tables and lists use shared components or theme; no duplicated inline styles.
+- [ ] “See also” or “Next” links to related About pages and relevant other tabs.
+- [ ] Context data and references checked for accuracy and 2026 updates.
+- [ ] Spell-check: incentivises, cryptoeconomic, it’s, LivepeerServer, on-chain (no trailing U).
+
+---
+
+*This style guide is part of the About section review. See [00-NAV-AND-PAGE-INDEX.md](./00-NAV-AND-PAGE-INDEX.md) for nav order and [ABOUT-SECTION-COPY-REVIEW.md](./ABOUT-SECTION-COPY-REVIEW.md) for per-page review and code suggestions.*
diff --git a/docs/ABOUT/CONTEXT DATA/Network/livepeer_interfaces.md b/docs/ABOUT/CONTEXT DATA/Network/livepeer_interfaces.md
new file mode 100644
index 000000000..78abf9bfb
--- /dev/null
+++ b/docs/ABOUT/CONTEXT DATA/Network/livepeer_interfaces.md
@@ -0,0 +1,175 @@
+# Livepeer Interfaces
+
+Livepeer exposes multiple access interfaces for developers, creators, and infrastructure operators to interact with the protocol and network. These include SDKs, REST and gRPC APIs, the CLI, GraphQL endpoints, and playback tooling for on-chain and off-chain applications.
+
+This page breaks down each interface by usage type, target user, supported capabilities, and sample integration paths.
+
+---
+
+## Interface Categories
+
+| Interface | Use Case | Users | Access Medium |
+|------------------|-------------------------------------|--------------------------|---------------|
+| REST API | Start sessions, control workflows | App developers, gateways| HTTPS |
+| gRPC API | Fast low-latency session control | Gateway nodes | gRPC |
+| GraphQL API | Explore network, jobs, rewards | Analysts, explorers | GraphQL |
+| JS SDK | Playback, ingest, session control | Frontend developers | JavaScript |
+| CLI | Orchestrator & delegator control | Node operators | Terminal |
+| Smart Contracts | Protocol-level operations | Power users/devs | Solidity / RPC|
+
+---
+
+## 1. REST API (Livepeer Studio)
+
+Available at: `https://livepeer.studio/api`
+
+### Common Endpoints:
+- `POST /stream` – Create video stream ingest session
+- `POST /transcode` – On-demand file transcode
+- `POST /ai/infer` – Submit AI job (e.g. image enhancement)
+- `GET /session/:id` – Fetch session status
+
+**Docs:** [https://livepeer.studio/docs](https://livepeer.studio/docs)
+
+---
+
+## 2. gRPC API (Gateway Nodes)
+
+gRPC allows high-throughput, low-latency orchestrator routing.
+
+### Methods:
+- `ReserveSession`
+- `Heartbeat`
+- `ReportJobComplete`
+- `OrchestratorList`
+
+Used by:
+- Studio Gateway
+- Daydream Gateway
+- Cascade
+
+**Proto:** [gateway.proto](https://github.com/livepeer/protocol/blob/master/proto/gateway.proto)
+
+---
+
+## 3. GraphQL Explorer API
+
+Access detailed Livepeer on-chain and network state:
+
+Endpoint: `https://explorer.livepeer.org/graphql`
+
+### Example Queries:
+```graphql
+query GetOrchestrators {
+ orchestrators {
+ id
+ totalStake
+ rewardCut
+ serviceURI
+ }
+}
+```
+
+Also supports:
+- Delegator rewards
+- Inflation rate
+- Total active stake
+- Round info
+
+Used by:
+- [https://explorer.livepeer.org](https://explorer.livepeer.org)
+
+---
+
+## 4. JS SDK
+
+[GitHub → @livepeer/sdk](https://github.com/livepeer/js-sdk)
+
+Install:
+```bash
+npm install @livepeer/sdk
+```
+
+### Features:
+- Ingest (create stream, push video)
+- AI job submit
+- View session output
+- Wallet support (ETH, credit)
+- Playback and stats
+
+### Example:
+```js
+const { createStream } = require('@livepeer/sdk');
+const stream = await createStream({ name: 'My Stream' });
+```
+
+Used in:
+- Livepeer Studio
+- Daydream
+- VJ apps (MetaDJ)
+
+---
+
+## 5. CLI
+
+Install via Go build or Docker.
+
+```bash
+go install github.com/livepeer/go-livepeer
+```
+
+### Commands:
+- `stake`, `unbond`, `withdraw`
+- `reward`, `claim`
+- `transcode`, `broadcast`, `query`
+
+Ideal for orchestrator testing or protocol analysis.
+
+---
+
+## 6. Smart Contract Interfaces
+
+Interact directly with protocol via:
+
+| Contract | Function | Arbitrum Address |
+|------------------|--------------------------------------|-------------------------------------|
+| `BondingManager` | stake, reward, unbond | `0xINSERT_CURRENT_ADDRESS` |
+| `TicketBroker` | redeem tickets, deposit, withdraw | `0xINSERT_CURRENT_ADDRESS` |
+| `Governor` | vote, queue, execute LIPs | `0xINSERT_CURRENT_ADDRESS` |
+
+Use: `ethers.js`, `viem`, `hardhat` or JSON-RPC
+
+---
+
+## Workflow Examples
+
+### Transcode from Web App
+```js
+await sdk.createStream({ profile: '720p', name: 'MyCam' });
+```
+
+### Run AI Image2Image
+```bash
+curl -X POST /ai/infer \
+ -d '{ "model": "sdxl", "input": "image.png" }'
+```
+
+### Check Node Metrics
+```bash
+livepeer_cli status
+```
+
+---
+
+## References
+
+- [Livepeer Studio API](https://livepeer.studio/docs)
+- [Livepeer Explorer GraphQL](https://explorer.livepeer.org/graphql)
+- [Livepeer JS SDK](https://github.com/livepeer/js-sdk)
+- [Smart Contract ABIs](https://github.com/livepeer/protocol/tree/master/abi)
+- [Livepeer Protocol Repo](https://github.com/livepeer/protocol)
+
+---
+
+📎 Final section of the `network/` documentation group complete.
+
diff --git a/docs/ABOUT/CONTEXT DATA/Network/livepeer_job_lifecycle.md b/docs/ABOUT/CONTEXT DATA/Network/livepeer_job_lifecycle.md
new file mode 100644
index 000000000..8053bce44
--- /dev/null
+++ b/docs/ABOUT/CONTEXT DATA/Network/livepeer_job_lifecycle.md
@@ -0,0 +1,151 @@
+# Livepeer Job Lifecycle
+
+This document explains the full lifecycle of a compute job on the Livepeer Network, including both **video transcoding** and **AI inference** jobs. It outlines how sessions are established, how jobs are routed and executed, how payments are made and validated, and how output is returned to clients.
+
+Job lifecycle spans both off-chain and on-chain actions:
+
+| Layer | Function |
+|------------------|------------------------------------------------|
+| Gateway (off-chain) | Accepts jobs, validates auth/payment |
+| Orchestrator (hybrid) | Coordinates job execution and reward tracking |
+| Worker (off-chain) | Executes the compute |
+| Smart Contracts (on-chain) | Verifies tickets, issues rewards |
+
+---
+
+## Session Setup
+
+A compute job begins when a client (e.g., Livepeer Studio, SDK, or AI pipeline) submits a session request.
+
+**Gateway Node actions:**
+- Validates API key or ETH/credit balance
+- Assigns job metadata (type, resolution, latency, duration)
+- Routes to a registered orchestrator
+
+If credit-based: balance is deducted
+If ETH-based: ticket session initialized
+
+---
+
+## Path 1: Video Transcoding
+
+```mermaid
+sequenceDiagram
+ participant C as Client
+ participant G as Gateway
+ participant O as Orchestrator
+ participant W as Transcoder
+ participant TB as TicketBroker (L2)
+
+ C->>G: Submit stream (RTMP/HLS)
+ G->>O: Assign session
+ O->>W: Transcode segments
+ W-->>O: Transcoded output
+ O->>TB: Redeem winning tickets
+ O-->>C: HLS playback URL returned
+```
+
+**Key Features:**
+- Segmented stream (e.g., 2s chunks)
+- FFmpeg-based transcoding
+- Winning tickets returned every N segments
+- Job status monitored by orchestrator
+
+---
+
+## Path 2: AI Inference
+
+```mermaid
+sequenceDiagram
+ participant A as AI Client
+ participant G as Gateway
+ participant O as Orchestrator
+ participant W as ML Worker
+ participant TB as TicketBroker (L2)
+
+ A->>G: Upload input (image/video)
+ G->>O: Dispatch to AI-capable orchestrator
+ O->>W: Run ML model
+ W-->>O: Returns output
+ O->>TB: Redeem ticket / credit
+ O-->>A: Return output image/frames
+```
+
+**Use Cases:**
+- Frame enhancement
+- Object detection
+- Latent diffusion (e.g., Stable Diffusion, ComfyUI)
+
+---
+
+## Payment & Verification
+
+Livepeer uses **probabilistic micropayments**:
+- Broadcaster sends tickets to orchestrator
+- Each ticket has a chance to be a winner
+- On-chain contract `TicketBroker` validates the signature and redemption
+- Winning tickets pay out larger ETH amounts
+
+**Why it matters:**
+- Reduces L2 gas cost
+- Allows real-time streaming with no per-segment tx
+
+**On success:**
+- ETH credited to orchestrator
+- Orchestrator later claims LPT inflation rewards (see `BondingManager`)
+
+---
+
+## Fault Tolerance
+
+Orchestrators:
+- Monitor worker availability
+- Reassign jobs on failure
+- Log tickets claimed vs failed
+
+Gateways:
+- Retry on orchestrator timeout
+- Rotate to new orchestrator pool
+
+---
+
+## Merkle Snapshot & Rewards
+
+On each round (~5760 blocks):
+- Orchestrators submit Merkle proof of work completed
+- Includes ETH fees earned and delegator % share
+- Protocol calculates and mints LPT rewards
+- Rewards can be claimed by orchestrators and delegators
+
+Contract Involved:
+- `RoundsManager`
+- `MerkleSnapshot`
+- `L2ClaimBridge`
+
+---
+
+## Metrics
+
+| Job Type | Metric | Placeholder |
+|-------------------|-----------------------------------|----------------------|
+| Transcoding | Streams per day | `INSERT_VIDEO_JOBS` |
+| AI Inference | Frames per day | `INSERT_AI_FRAMES` |
+| Avg Latency | Worker response time | `INSERT_LAT_MS` |
+| Ticket Win Rate | % of tickets redeemed | `INSERT_TICKET_WIN` |
+
+Source: [Livepeer Explorer](https://explorer.livepeer.org)
+
+---
+
+## References
+
+- [TicketBroker.sol](https://github.com/livepeer/protocol/blob/master/contracts/job/)
+- [Livepeer SDK (job API)](https://github.com/livepeer/js-sdk)
+- [Gateway routing docs](https://livepeer.studio/docs)
+- [Stable Diffusion x Livepeer](https://blog.livepeer.org/ai-on-livepeer)
+- [Orchestrator examples](https://livepeer.org/docs/orchestrators)
+
+---
+
+Next: `marketplace.mdx`
+
diff --git a/docs/ABOUT/CONTEXT DATA/Network/livepeer_marketplace.md b/docs/ABOUT/CONTEXT DATA/Network/livepeer_marketplace.md
new file mode 100644
index 000000000..c3cc4f377
--- /dev/null
+++ b/docs/ABOUT/CONTEXT DATA/Network/livepeer_marketplace.md
@@ -0,0 +1,165 @@
+# Livepeer Marketplace
+
+The Livepeer Network supports a dynamic decentralized marketplace for real-time media compute: transcoding and AI inference. Unlike static infrastructure platforms, Livepeer's open marketplace introduces real-time **bidding, routing, and pricing** of jobs across a global pool of orchestrators.
+
+This document outlines the design of the marketplace layer, its actor behaviors, session economics, and design proposals for advanced matching.
+
+---
+
+## Marketplace Overview
+
+| Element | Role |
+|--------------------------|--------------------------------------------------------|
+| **Broadcaster/Client** | Submit job requests (stream, image, session intent) |
+| **Gateway** | Matches requests to suitable orchestrators |
+| **Orchestrator** | Advertises availability, pricing, and capabilities |
+| **Worker** | Executes compute task |
+| **TicketBroker** | Receives tickets for ETH reward upon verified work |
+
+This market is **continuous** — orchestrators are always bidding for sessions.
+
+---
+
+## Demand: Client Workloads
+
+Clients submit various media compute jobs:
+
+| Job Type | Example Use Case | Payment Style |
+|------------------|-------------------------------------------|-------------------|
+| Live Stream | RTMP ingest for video platforms | Per-minute ETH / credits |
+| AI Inference | Frame-by-frame image-to-image generation | Per-job (frame, token) |
+| File Transcode | Static MP4 → web formats | Batch credits |
+
+**API Examples:**
+- Livepeer Studio REST
+- Gateway POST job
+- ComfyStream interface (AI)
+
+---
+
+## Supply: Orchestrator Nodes
+
+Orchestrators advertise:
+
+- Hardware specs (GPU/CPU, memory)
+- Region/latency
+- Supported workloads (video, AI, both)
+- Price per segment / frame / token
+
+They update via gateway-side gRPC or REST heartbeat endpoints.
+
+---
+
+## Routing Logic
+
+```mermaid
+graph TD
+ B[Client] --> G[Gateway Node]
+ G --> O1[Orchestrator A]
+ G --> O2[Orchestrator B]
+ O1 --> W1[Worker]
+ O2 --> W2[Worker]
+```
+
+The gateway scores orchestrators by:
+- Latency to input source
+- Workload match
+- Cost-per-job
+- Availability + retry buffer
+
+Session is **routed** to best match (no on-chain gas impact).
+
+---
+
+## Price Discovery
+
+The current Livepeer implementation uses **posted pricing** (orchestrator-set), not auction-based. A few notes:
+
+- Clients can be matched to the lowest available compatible provider.
+- Bids may vary by:
+ - Region (US-East vs EU-Central)
+ - GPU load (AI-heavy orchestrators charge more)
+ - Quality profile (1080p60 vs 720p30)
+
+In development: LIP to introduce dynamic auction for AI sessions.
+
+---
+
+## Payments & Settlements
+
+Clients pay via:
+- ETH tickets (via protocol)
+- Credit balance (tracked off-chain)
+
+Orchestrators:
+- Claim tickets to `TicketBroker`
+- Accumulate earnings
+- Claim inflation (LPT) rewards from `BondingManager`
+
+---
+
+## Credit System Extensions
+
+Some gateways provide user-friendly pricing:
+
+| Currency | Top-up Methods | Denomination |
+|----------|------------------------|--------------------|
+| USD | Credit card, USDC | $0.01 per minute |
+| ETH | Metamask, smart wallet | 0.001 ETH per job |
+
+Orchestrators can price in USD-equivalent via oracle-based quoting.
+
+---
+
+## Observability
+
+Each session logs:
+- Latency to first response
+- Retry count
+- Orchestrator ID and region
+- Price paid (ETH or credit)
+
+Future: Marketplace indexers to surface real-time job flow stats.
+
+---
+
+## Protocol-Market Boundaries
+
+| Layer | Description | Example |
+|------------------|----------------------------------------------|-------------------------------------|
+| Protocol | Verifies work and pays ETH & LPT rewards | `TicketBroker`, `BondingManager` |
+| Marketplace | Matches jobs to compute providers | Gateway load balancer |
+| Interface Layer | Abstracts API, SDK, session negotiation | Livepeer Studio SDK, Daydream API |
+
+---
+
+## Metrics (Insert Live)
+
+| Metric | Placeholder |
+|----------------------------|---------------------|
+| Avg price per segment | `INSERT_SEG_PRICE` |
+| Orchestrator fill rate | `INSERT_FILL_RATE` |
+| AI job queue depth | `INSERT_QUEUE_LEN` |
+
+---
+
+## Future Upgrades (LIPs Proposed)
+
+- **LIP-78: Spot job auctions**
+- **LIP-81: Credit-to-protocol sync bridge**
+- **LIP-85: Orchestrator staking influence on job routing**
+
+---
+
+## References
+
+- [Livepeer Gateway Routing](https://livepeer.studio/docs)
+- [TicketBroker.sol](https://github.com/livepeer/protocol/tree/master/contracts/job)
+- [Orchestrator Node Setup](https://livepeer.org/docs/guides/orchestrator)
+- [Forum: LIP Proposals](https://forum.livepeer.org/c/lips/)
+- [ComfyStream AI](https://blog.livepeer.org/real-time-ai-comfyui)
+
+---
+
+Next: `technical-stack.mdx`
+
diff --git a/docs/ABOUT/CONTEXT DATA/Network/livepeer_network_actors.md b/docs/ABOUT/CONTEXT DATA/Network/livepeer_network_actors.md
new file mode 100644
index 000000000..a269754f5
--- /dev/null
+++ b/docs/ABOUT/CONTEXT DATA/Network/livepeer_network_actors.md
@@ -0,0 +1,158 @@
+# Livepeer Network Actors
+
+Livepeer’s decentralized network consists of multiple types of actors who interact both on- and off-chain to deliver secure, scalable, and cost-efficient media compute infrastructure. Each role has distinct permissions, responsibilities, and revenue paths.
+
+This section documents the actors that form the Livepeer Network, including their function, economic incentives, operational responsibilities, and integration points with the core protocol.
+
+---
+
+## Actor Overview Table
+
+| Actor | On-Chain? | Staked LPT? | Runs Compute? | Pays ETH? | Primary Role |
+|------------------|-----------|-------------|----------------|-----------|-----------------------------------------|
+| Orchestrator | ✅ | ✅ | ✅ | ❌ | Coordinates work, earns ETH & LPT |
+| Worker | ❌ | ❌ | ✅ | ❌ | Performs media/AI jobs |
+| Broadcaster | ❌ | ❌ | ❌ | ✅ | Submits jobs, pays ETH |
+| Delegator | ✅ | ✅ | ❌ | ❌ | Stakes LPT to earn yield |
+| Gateway Node | ❌ | ❌ | ❌ | ❌ | Routes jobs, manages sessions |
+| Governor | ✅ | ✅ | ❌ | ❌ | Votes on LIPs, governs protocol logic |
+
+---
+
+## 1. Orchestrators
+
+Orchestrators are the backbone of the Livepeer Network. They:
+
+- Stake LPT on Ethereum L1
+- Connect to Arbitrum for ETH tickets and job tracking
+- Bid for session assignments via gateways
+- Coordinate local compute via workers (FFmpeg/AI)
+- Collect ETH fees and LPT inflation rewards
+- Set reward/fee cut percentages for delegators
+
+They operate the `livepeer` node and must:
+- Maintain uptime
+- Validate winning tickets
+- Submit Merkle proofs for rewards
+
+**On-chain responsibilities:**
+- Bonding/unbonding
+- Reward claiming (L2 → L1 bridge)
+- Slashing if misbehavior proven
+
+---
+
+## 2. Workers
+
+Workers are external or local processes assigned jobs by an orchestrator. They may be:
+- Transcoders (video)
+- Inference nodes (AI/ML)
+- Specialized compute (e.g. image-to-image)
+
+They do not hold stake and are untrusted in protocol eyes. Trust is proxy-based:
+- Orchestrator vouches for them
+- Faults lead to orchestrator slashing
+
+**Software Examples:**
+- GPU FFmpeg
+- WebRTC workers
+- Python inference scripts (e.g. ComfyStream)
+
+---
+
+## 3. Broadcasters
+
+Broadcasters are clients (apps, services, SDKs) who:
+- Submit video/AI jobs to the network
+- Pay in ETH or credits via gateways
+- Receive output (e.g., transcoded stream)
+
+They don’t need LPT or protocol interaction.
+
+**Integration modes:**
+- Livepeer Studio SDK
+- REST/gRPC Gateway APIs
+- RTMP/WHIP ingest endpoints
+
+---
+
+## 4. Delegators
+
+Delegators support the protocol by:
+- Staking (bonding) LPT to orchestrators
+- Sharing in inflation and fee rewards
+
+They don’t operate infra but:
+- Choose which orchestrators to support
+- Monitor performance, fee cuts, uptime
+
+**Economic exposure:**
+- Receive slashing if their orchestrator misbehaves
+- Yield = Inflation * (1 - reward cut)
+
+See: [Delegator Dashboard](https://explorer.livepeer.org/delegators)
+
+---
+
+## 5. Gateway Nodes
+
+Gateways are API-facing edge routers that:
+- Receive job/session requests
+- Select orchestrators (bidding layer)
+- Validate ETH deposits or credit balance
+- Provide auth / rate-limiting / metering
+
+Not protocol-governed; implemented by:
+- Livepeer Studio
+- Daydream
+- Partners (ComfyStream, etc)
+
+They may be incentivized off-chain or integrated with LPT flow (future LIP).
+
+---
+
+## 6. Governor
+
+The Governor contract governs protocol logic:
+- Executes passed LIPs (Livepeer Improvement Proposals)
+- Controls parameter updates (inflation, bonding target)
+- Manages treasury disbursement via multi-sig
+
+Governance is token-weighted, using:
+- LPT (bonded)
+- Snapshot (off-chain signaling)
+- Quorum + majority rules
+
+See: [`Governor.sol`](https://github.com/livepeer/protocol/blob/master/contracts/governance/Governor.sol)
+
+---
+
+## Economic Roles in Context
+
+```mermaid
+graph TD
+ B[Delegator] --> O[Orchestrator]
+ O --> W[Worker]
+ Bc[Broadcaster] --> G[Gateway]
+ G --> O
+ O --> TB[TicketBroker (Arbitrum)]
+ TB --> O
+ G --> Gv[Governor]
+ O --> Gv
+```
+
+Each actor plays into both market function (work execution) and protocol security (staking, slashing).
+
+---
+
+## References
+
+- [Livepeer Docs – Delegators](https://livepeer.org/docs/guides/delegator)
+- [Livepeer Studio Gateway](https://livepeer.studio/docs)
+- [Protocol GitHub](https://github.com/livepeer/protocol)
+- [LIP Index](https://forum.livepeer.org)
+
+---
+
+Next section: `job-lifecycle.mdx`
+
diff --git a/docs/ABOUT/CONTEXT DATA/Network/livepeer_network_overview.md b/docs/ABOUT/CONTEXT DATA/Network/livepeer_network_overview.md
new file mode 100644
index 000000000..682f989c5
--- /dev/null
+++ b/docs/ABOUT/CONTEXT DATA/Network/livepeer_network_overview.md
@@ -0,0 +1,144 @@
+# Livepeer Network Overview
+
+While the Livepeer protocol defines cryptoeconomic and smart contract infrastructure on Ethereum and Arbitrum, the Livepeer **network** consists of off-chain actors, compute resources, job routing layers, and gateways that coordinate decentralized video and AI workloads in real time.
+
+This page introduces the architectural structure of the Livepeer Network, how it relates to the protocol, and who operates key components.
+
+---
+
+## What Is the Livepeer Network?
+
+The **Livepeer Network** is the off-chain infrastructure and set of actors that execute real work—stream transcoding, AI inference, and other media computation—via open interfaces and permissionless coordination. It includes:
+
+- Compute node operators (Orchestrators, Workers)
+- Job routers and session gateways
+- End-user applications and media clients
+- Credit systems and off-chain accounting layers
+
+The protocol provides incentives and correctness guarantees. The **network performs the jobs.**
+
+---
+
+## Key Network Participants
+
+| Actor | Role in the Network |
+|----------------|------------------------------------------------------------------------|
+| **Gateway Nodes** | Accept session requests, handle API keys, route to orchestrators |
+| **Orchestrators** | Bid for jobs, validate tickets, distribute to local workers |
+| **Workers** | Execute compute tasks: transcoding (FFmpeg) or inference (AI model) |
+| **Clients** | Submit streams via Livepeer Studio, CLI, SDKs, or integrated platforms |
+| **Gatekeeper Services** | (Optional) perform workload verification, credit balance resolution |
+
+---
+
+## Session Lifecycle: Video Example
+
+```mermaid
+sequenceDiagram
+ participant App as Client App / SDK
+ participant GW as Gateway Node
+ participant O as Orchestrator
+ participant W as Worker
+ participant TB as TicketBroker (L2)
+
+ App->>GW: Start stream session (API key or payment)
+ GW->>O: Route to available orchestrator
+ O->>W: Assign transcode job
+ W-->>O: Transcoded segment
+ O->>TB: Submit winning ticket claim
+ O-->>App: Returns final segment URL
+```
+
+Session metadata, monitoring, and reporting are managed off-chain but linked to protocol rewards.
+
+---
+
+## Compute Separation: Video vs AI
+
+| Workload Type | Description | Example Session Path |
+|---------------|-------------------------------------|--------------------------------------------------|
+| Transcoding | Convert bitrate, resolution, format | HLS stream → FFmpeg Worker → .m3u8 + .ts output |
+| Inference | Run ML model on image/video input | MP4 → Stable Diffusion Worker → output frame |
+
+The same orchestrator may support both job types or specialize. Selection depends on job metadata.
+
+---
+
+## Gateway Design
+
+Gateways are **entry points**, not smart contracts.
+
+| Gateway Type | Description | Examples |
+|--------------------|----------------------------------------------|---------------------------------|
+| Livepeer Gateway | Public, runs at api.livepeer.org | Used by Livepeer Studio, SDKs |
+| Daydream Gateway | ML-optimized, handles image/video inference | Used by MetaDJ, dotSimulate |
+| Custom Gateways | Partner-hosted with custom auth/routing | E.g., ComfyStream, cascade labs|
+
+Gateways manage:
+- API keys or credit balances
+- Compute routing logic
+- Input/output delivery
+
+They **do not require protocol governance** to operate.
+
+---
+
+## Compute Credit System (Optional)
+
+Many workloads are paid via internal credit systems that:
+- Top up via ETH or USDC
+- Deduct credits per minute or per image
+- Are tracked off-chain by gateway providers
+
+Payment reconciliation via protocol occurs at orchestrator layer.
+
+---
+
+## Observability and Monitoring
+
+Livepeer Studio and gateway hosts run real-time monitoring tools:
+
+- Stream quality (fps, bitrate, segment latency)
+- Orchestrator logs (retries, drops, error codes)
+- Credit consumption logs
+
+These metrics are reported to operators but not persisted on-chain.
+
+---
+
+## Decentralization Guarantees
+
+The network maintains:
+- **Redundant routing** across multiple gateways
+- **Permissionless compute** registration for orchestrators
+- **Decentralized payment** via probabilistic ETH tickets
+
+Slashing and quality verification remain protocol-level enforcement paths.
+
+---
+
+## Network Health Metrics (Insert Live)
+
+| Metric | Placeholder |
+|----------------------------|---------------------------|
+| Active Gateways | `INSERT_COUNT` |
+| Orchestrator Uptime (avg) | `INSERT_PCT` |
+| Job Throughput | `INSERT_TOTAL_JOBS` |
+| AI Sessions per Day | `INSERT_AI_VOLUME` |
+
+Source: [explorer.livepeer.org](https://explorer.livepeer.org)
+
+---
+
+## References
+
+- [Livepeer SDK](https://github.com/livepeer/js-sdk)
+- [Daydream AI Gateway](https://docs.daydream.livepeer.org)
+- [MetaDJ on Livepeer](https://blog.livepeer.org/metadj)
+- [Builder story: dotSimulate](https://blog.livepeer.org/builders-dotsimulate)
+- [Gateway modes (cascade)](https://forum.livepeer.org/t/lip-77-arbitrum-native)
+
+---
+
+Next: `actors.mdx`
+
diff --git a/docs/ABOUT/CONTEXT DATA/Network/livepeer_technical_stack.md b/docs/ABOUT/CONTEXT DATA/Network/livepeer_technical_stack.md
new file mode 100644
index 000000000..6a0dca524
--- /dev/null
+++ b/docs/ABOUT/CONTEXT DATA/Network/livepeer_technical_stack.md
@@ -0,0 +1,144 @@
+# Livepeer Technical Stack
+
+This section outlines the full stack of tools, infrastructure, and components that power the Livepeer Network at the node, gateway, and client level. It covers orchestrator tooling, gateway middleware, interfaces, CLI, SDKs, and monitoring integrations.
+
+Livepeer’s architecture is modular and developer-facing: you can run an orchestrator, build a custom AI gateway, or use APIs to build media apps on decentralized compute.
+
+---
+
+## Architecture Layers
+
+```mermaid
+graph TD
+ UI[Apps / SDKs / Interfaces]
+ API[Gateway APIs / REST / GraphQL]
+ GW[Gateway Nodes]
+ O[Orchestrator Node (livepeer)]
+ W[Worker Layer (FFmpeg / AI)]
+ P[Protocol (Ethereum / Arbitrum)]
+
+ UI --> API --> GW --> O --> W
+ O --> P
+```
+
+---
+
+## Orchestrator Node
+
+The orchestrator node runs `livepeer`, available at:
+[https://github.com/livepeer/go-livepeer](https://github.com/livepeer/go-livepeer)
+
+### Key Components:
+- **Transcoder selection** (internal or external workers)
+- **Ticket validation** (L2 TicketBroker)
+- **Reward claim (Merkle submission)**
+- **LPT staking (BondingManager)**
+- **Region advertisement** (for routing)
+
+**Deployment modes:**
+- Bare metal with GPU
+- Containerized
+- Cloud auto-scaling
+
+**Tools:**
+- `livepeer_cli` – stake, set fee/reward cut, monitor sessions
+- `livepeer_exporter` – Prometheus metrics exporter
+
+---
+
+## Worker Layer
+
+Workers can be local or remote services:
+
+| Type | Language/Runtime | Example Use |
+|-------------|------------------|-----------------------------------------------|
+| Transcoder | FFmpeg | .ts segment processing |
+| Inference | Python (Torch) | AI tasks, e.g., SDXL image-to-image |
+| Plugin | WebRTC / C++ | Real-time browser capture or object detection |
+
+Configured via orchestrator `config.json` or env vars.
+
+---
+
+## Gateway Infrastructure
+
+Gateways manage:
+- Session auth (API key, ETH deposit, credit check)
+- Job routing
+- Session logging
+
+**Codebases:**
+- [Studio Gateway](https://github.com/livepeer/studio-gateway)
+- [Daydream Gateway](https://github.com/livepeer/daydream)
+- [Cascade Load Balancer](https://github.com/livepeer/cascade)
+
+**Features:**
+- Rate limiting, region scoring
+- Health probes, fallback orchestrators
+- Credit tracking via Postgres/Redis
+
+---
+
+## APIs
+
+| API | Protocol | Description |
+|--------------|----------|--------------------------------------|
+| REST Gateway | HTTPS | Transcode, AI job control |
+| gRPC Gateway | gRPC | Fast session handshakes, monitoring |
+| Explorer API | GraphQL | Metrics, staking, round data |
+
+Available via:
+- `https://livepeer.studio/api`
+- `https://explorer.livepeer.org/graphql`
+
+---
+
+## CLI and SDKs
+
+- **CLI:** `livepeer_cli`
+ - Stake LPT
+ - Bond/unbond
+ - Set orchestrator fees
+ - Watch active sessions
+
+- **SDKs:**
+ - [Livepeer JS SDK](https://github.com/livepeer/js-sdk)
+ - Playback, ingest, AI session tools
+ - Works in Node.js, browser
+
+- **Python AI Pipelines:**
+ - `livepeer-python` (internal only)
+ - Used in dotSimulate, MetaDJ
+
+---
+
+## Monitoring & Observability
+
+| Tool | Metric Type | Description |
+|-------------------|-------------------------|-----------------------------------------|
+| Prometheus | Session, CPU, ticketing | Exposed via `livepeer_exporter` |
+| Grafana Dashboards| Visual ops | Studio & orchestrator internal views |
+| Loki | Logs | Transcode errors, API retries |
+| Gateway Logs | Credits, API, routing | Per-session logs in Redis / S3 |
+
+---
+
+## Deployment Examples
+
+- [orchestrator-on-aws](https://github.com/livepeer/orchestrator-on-aws)
+- [studio-gateway-deploy](https://github.com/livepeer/studio-gateway-deploy)
+- [ai-node-pipeline](https://github.com/livepeer/daydream)
+
+---
+
+## References
+
+- [Livepeer GitHub](https://github.com/livepeer)
+- [Livepeer Orchestrator Docs](https://livepeer.org/docs/guides/orchestrator)
+- [Daydream Gateway Code](https://github.com/livepeer/daydream)
+- [Livepeer Explorer API](https://explorer.livepeer.org)
+
+---
+
+Next section: `interfaces.mdx`
+
diff --git a/docs/ABOUT/CONTEXT DATA/Protocol/Core Mechanisms.pdf b/docs/ABOUT/CONTEXT DATA/Protocol/Core Mechanisms.pdf
new file mode 100644
index 000000000..b6ff64da5
Binary files /dev/null and b/docs/ABOUT/CONTEXT DATA/Protocol/Core Mechanisms.pdf differ
diff --git a/docs/ABOUT/CONTEXT DATA/Protocol/Livepeer Protocol Core Mechanisms (2026).pdf b/docs/ABOUT/CONTEXT DATA/Protocol/Livepeer Protocol Core Mechanisms (2026).pdf
new file mode 100644
index 000000000..7a4989a96
Binary files /dev/null and b/docs/ABOUT/CONTEXT DATA/Protocol/Livepeer Protocol Core Mechanisms (2026).pdf differ
diff --git a/docs/ABOUT/CONTEXT DATA/Protocol/OverviewReport.pdf b/docs/ABOUT/CONTEXT DATA/Protocol/OverviewReport.pdf
new file mode 100644
index 000000000..4e4c81de0
Binary files /dev/null and b/docs/ABOUT/CONTEXT DATA/Protocol/OverviewReport.pdf differ
diff --git a/docs/ABOUT/CONTEXT DATA/Protocol/deep-research-report (1).md b/docs/ABOUT/CONTEXT DATA/Protocol/deep-research-report (1).md
new file mode 100644
index 000000000..28f7095b4
--- /dev/null
+++ b/docs/ABOUT/CONTEXT DATA/Protocol/deep-research-report (1).md
@@ -0,0 +1,424 @@
+# Executive Summary
+
+This document proposes a **production-grade documentation** set for Livepeer (2026) that strictly separates **Protocol** (on-chain) and **Network** (off-chain) content. It covers all requested pages with clear MDX headers, concise purpose statements, detailed outlines (with subsections and mermaid diagrams), exact citations, media suggestions, newcomer examples, and cross-links. The protocol pages focus on staking, inflation, LPT, governance, treasury, and contracts on Arbitrum【43†L108-L116】【42†L1-L4】; the network pages focus on nodes, workflows, marketplaces, and applications. Legacy terms (like “Broadcaster”, “Transcoder”) are flagged and replaced (e.g. “Gateway”, “Worker”), and hybrid items (e.g. AI Orchestrators) are noted. We include comparative tables of protocol vs network responsibilities and a mermaid Gantt timeline of major upgrades (Confluence 2022, Streamflow 2023, Cascade 2024, Daydream 2025, AI Subnet 2025). Chart placeholders are indicated for staking ratio and fee/inflation splits (to be sourced from Explorer/Messari/Dune). All content is supported by official references (Livepeer docs, LIPs, forum, Arbiscan) or authoritative analytics【43†L108-L116】【40†L85-L94】.
+
+| **Responsibility** | **Protocol (On-Chain)** | **Network (Off-Chain)** |
+|----------------------|-----------------------------------------|--------------------------------------------|
+| Node registration | BondingManager (stake/delegate) | Orchestrator software |
+| Job assignment | Active set (stake-weighted for transcoding rounds)【40†L85-L94】 | Gateway/orchestrator matchmaking logic |
+| Payment settlement | TicketBroker (redeem winning tickets)【40†L160-L167】 | Issuing tickets (off-chain) |
+| Reward issuance | Minting new LPT (via RoundsManager)【41†L253-L261】 | Transcoding/AI execution (no minting) |
+| Slashing | On-chain fraud proofs | (Coordinate evidence off-chain) |
+| Governance | LIPs, on-chain voting (33% quorum)【42†L1-L4】 | Forum discussion, off-chain proposals |
+| Data storage | Transaction state (bonds, votes) | Video/AI frames, pipeline state |
+| Upgrade mechanism | Governor/Controller | Software updates (go-livepeer, Daydream) |
+
+```mermaid
+gantt
+ dateFormat YYYY-MM-DD
+ title Livepeer Major Upgrades
+ section Protocol Upgrades
+ Confluence (L1→L2) :done, 2022-02-14, 10d
+ Streamflow (Protocol v1):done, 2023-03-01, 7d
+ section Product/Ecosystem
+ AI Subnet Beta :done, 2024-08-01, 2d
+ Cascade (Pipeline Arch) :done, 2024-11-01, 5d
+ Daydream (App Launch) :done, 2025-05-12, 3d
+```
+
+External data needed:
+- **Staking Ratio Over Time:** (Source: Explorer/Dune) – plot % of LPT staked vs target.
+- **Revenue Split Chart:** (Source: Messari/Explorer) – fees (ETH) vs inflation (LPT) over quarters.
+
+---
+
+## v2/pages/01_about/about-portal (Network)
+
+**Purpose:** Introduce users to the Livepeer documentation portal. Explain the site’s sections (Core Concepts, Protocol, Network), navigation, and how to contribute. Emphasize that this is a *site overview*, not protocol logic.
+
+**Outline:**
+- **Portal Structure:** Describe the new docs site structure and goals.
+- **Navigation:** How to use the sidebar (Core Concepts, Protocol, Network), search, and forums/Discord for support.
+- **Contribution:** How to submit edits (GitHub) and where to find Changelogs.
+- **Community Resources:** Links to Forum, GitHub, and Livepeer Studio.
+
+**Sources:** Livepeer documentation (portal guides)【47†L78-L86】.
+
+**Media:** Screenshot of Livepeer docs homepage (embedded at top).
+
+**Example:** “DevOps engineer Alice visits the portal and quickly finds the Core Concepts section and a ‘Quickstart’ guide.”
+
+**Cross-links:** *Livepeer Overview*, *Governance Model*, *Network Overview*.
+
+**Mark:** NETWORK. (Documentation interface.) Avoid protocol jargon.
+
+---
+
+## v2/pages/01_about/core-concepts/livepeer-overview (Core Concept)
+
+**Purpose:** Summarize Livepeer’s mission and architecture at a high level. Provide context for newcomers.
+
+**Outline:**
+- **Mission Statement:** Decentralized open-source video infrastructure (80%+ internet video)【40†L85-L94】.
+- **Key Components:** Livepeer Protocol (staking, governance) vs Livepeer Network (transcoding nodes).
+- **Roles:** Gateways (stream publishers), Orchestrators (compute providers), Delegators (stakeholders)【40†L85-L94】.
+- **Use Cases:** Live streaming, VoD, AI-enhanced video (e.g. Daydream’s real-time AR).
+- **Outcomes:** Cheaper, censorship-resistant streaming infrastructure.
+
+**Sources:** Messari Livepeer report【40†L85-L94】; Livepeer Blog (Cascade/Daydream vision)【40†L97-L105】.
+
+**Media:** Infographic showing Gateways → Orchestrators → Workers.
+
+**Example:** “Startup Bob’s app offloads live transcoding to Livepeer nodes, saving 80% of streaming costs.”
+
+**Cross-links:** *Core Concepts*, *Mental Model*, *Protocol Overview*.
+
+**Mark:** NETWORK. (High-level concept layer; no code.) Legacy: Avoid “Broadcaster” – use *Gateway*.
+
+---
+
+## v2/pages/01_about/core-concepts/livepeer-core-concepts (Core Concept)
+
+**Purpose:** Explain fundamental concepts (staking, rounds, tickets) simply, preparing readers for protocol specifics.
+
+**Outline:**
+- **Delegated Proof-of-Stake:** Orchestrators stake LPT; Delegators stake to them【40†L85-L94】. More stake = more work assigned (for transcoding).
+- **Rounds & Rewards:** ~20h “rounds”. New LPT minted per round; distributed by stake【41†L253-L261】. ETH fees split per configured feeShare.
+- **Micropayments:** Gateways issue probabilistic tickets for each segment【40†L160-L167】. Only winning tickets are redeemed on-chain (scales payments).
+- **Slashing:** Dishonest transcoding can be reported and slashed on-chain.
+- **Differentiation:** Emphasize staking secures the network, but actual video work is off-chain.
+
+**Sources:** Messari (nodes, staking, rounds)【40†L85-L94】【41†L253-L261】; Livepeer docs concept pages.
+
+**Media:** Mermaid flow: Delegator → Orchestrator → work → Rewards.
+
+**Example:** “Alice stakes 1000 LPT to NodeX. NodeX handles 1% of network load and gets 1% of LPT minted + 1% of fees (minus feeShare).”
+
+**Cross-links:** *Overview*, *Mental Model*, *Token*, *Job Lifecycle*.
+
+**Mark:** NETWORK. (Conceptual only; treat staking in plain terms.) Avoid “weighting logic” terminology here.
+
+---
+
+## v2/pages/01_about/core-concepts/mental-model (Core Concept)
+
+**Purpose:** Provide an intuitive analogy or walkthrough. Help non-technical readers “get” Livepeer.
+
+**Outline:**
+- **Analogy:** Livepeer is like *“Uber for video encoding”* – providers offer GPU power, clients pay per use.
+- **Layer Separation:** Protocol = rules/payment (like the billing system), Network = drivers & vehicles (the GPUs doing work).
+- **Walkthrough Example:** E.g. “Alex streams video to the network; nodes transcode it live; viewers receive the stream.”
+- **Key Idea:** Emphasize partnership of stakeholders (everyone wants the video to flow).
+
+**Sources:** None needed (conceptual).
+
+**Media:** Cartoon/diagram of Livepeer pipeline analogy.
+
+**Example:** “Think of a global cinema chain using decentralized cinemas: you find a cinema (Node), pay at the counter (Ticket), watch the movie (Stream).”
+
+**Cross-links:** *Overview*, *Core Concepts*.
+
+**Mark:** NETWORK. (Very high-level; no legacy terms at all.)
+
+---
+
+## v2/pages/01_about/livepeer-protocol/overview (Protocol)
+
+**Purpose:** Introduce the Livepeer **Protocol** layer (on-chain). Define its scope (staking, tokens, governance, payments) vs what belongs to the network.
+
+**Outline:**
+- **Protocol Scope:** Smart contracts on Arbitrum for LPT, staking, rewards, and governance【43†L108-L116】.
+- **Actors:** On-chain roles only: *Orchestrators* (staked service providers) and *Delegators* (token bonders). Gateways pay fees but have no stake.
+- **Chain:** All new state on Arbitrum post-Confluence (Feb 2022)【43†L108-L116】. Ethereum mainnet only has legacy LPT balance (use Migrator to L2).
+- **Decoupling:** Emphasize that job execution is off-chain; the protocol only enforces economic rules. Gateway jobs are not ordered by on-chain rules (except transcoding active set).
+
+**Sources:** Arbitrum migration docs【43†L108-L116】; Messari (node roles)【40†L85-L94】.
+
+**Media:** Diagram with two columns: *On-Chain (stake, vote, pay)* vs *Off-Chain (transcode, stream)*.
+
+**Example:** “When a Node bonds LPT, it calls the BondingManager on Arbitrum. That transaction is the protocol action.”
+
+**Cross-links:** *Core Mechanisms*, *Governance Model*, *Network Overview*.
+
+**Mark:** PROTOCOL. (Flag: “Trickle” is off-chain transport – not in protocol docs. Use *Gateway* not *Broadcaster*.)
+
+---
+
+## v2/pages/01_about/livepeer-protocol/core-mechanisms (Protocol)
+
+**Purpose:** Detail on-chain core mechanisms: staking, delegation, inflation, ticket payments, and slashing.
+
+**Outline:**
+- **Staking & Delegation:** Bond LPT via `BondingManager`【41†L239-L243】. Orchestrator must self-bond. Delegators attach to them. 7-round unbonding.
+- **Active Set:** Protocol selects nodes proportional to their *total bond* for transcoding each round. AI jobs are assigned off-chain (not by stake).
+- **Inflation:** New LPT minted per round by `RoundsManager`. Dynamic: targetBondingRate ≈ 50%【41†L253-L261】. E.g. ~25% APR if ~48% staked【41†L253-L261】. 90% of inflation to stakers, 10% to treasury.
+- **TicketPayments:** Gateways deposit ETH; Orchestrators get *winning* tickets from Gateways. Orchestrator calls `TicketBroker.redeemWinningTicket()` to claim ETH【40†L160-L167】. Most tickets lose by design.
+- **Slashing:** On-chain fraud proofs allow any party to slash a node’s bonded stake for misbehavior (e.g. incorrect transcoding). Slashed LPT is partly burned, partly to treasury. (Downtime or double-signing triggers slash/jailing.)
+
+**Sources:** Messari (stake-for-access model)【41†L239-L243】; protocol docs (TicketBroker logic)【40†L160-L167】.
+
+**Media:** Mermaid sequence (as above): *Gateway->Node->TicketBroker*.
+
+**Example:** “NodeZ has 10k LPT bonded. In round 100, 1,000 LPT are minted: NodeZ’s share (e.g. 100 LPT) is split between NodeZ and its delegators per its chosen cut.”
+
+**Cross-links:** *Token*, *Governance Model*, *Network Job Lifecycle*.
+
+**Mark:** PROTOCOL. (Legacy: “Gateway pays” vs “Broadcaster pays” is only for context; use *Gateway*.)
+
+---
+
+## v2/pages/01_about/livepeer-protocol/livepeer-token (Protocol)
+
+**Purpose:** Explain the LPT token: its role in staking/security, governance voting, and inflationary supply mechanics.
+
+**Outline:**
+- **LPT Basics:** ERC-20 on Ethereum/Arbitrum【43†L108-L116】. No fixed cap. Initial 10M at TGE; ~38M by 2025.
+- **Staking & Security:** LPT secures the network by bonding. Owning LPT is required to operate or validate.
+- **Governance:** 1 LPT = 1 vote on LIPs. Delegation does not transfer voting power (delegators vote through orchestrators unless they detach).
+- **Inflation:** New LPT minted each round (e.g. ~0.06% per round ≈25% APR) when staking <50%【41†L253-L261】. Minted tokens auto-staked to stakers.
+- **Treasury Share:** 10% of inflation goes to treasury. (E.g. 100LPT minted => 90LPT to stakers, 10LPT to treasury.)【41†L253-L261】.
+- **Bridging:** After Confluence (Feb 2022), LPT resides on Arbitrum. L1 LPT must be bridged via the Migrator contract【43†L108-L116】.
+
+**Sources:** Migration docs【43†L108-L116】; Messari (inflation targets)【41†L253-L261】.
+
+**Media:** Pie chart: *LPT Distribution* (Stakers vs Treasury).
+
+**Example:** “If 50% of all LPT is staked, inflation is near 0%. If 40% is staked, inflation is higher (≈25% APR)【41†L253-L261】.”
+
+**Cross-links:** *Core Mechanisms*, *Protocol Economics*.
+
+**Mark:** PROTOCOL.
+
+---
+
+## v2/pages/01_about/livepeer-protocol/treasury (Protocol)
+
+**Purpose:** Describe the Livepeer on-chain treasury: how it’s funded and governed.
+
+**Outline:**
+- **Funding Sources:** 10% of minted LPT each round (LIP-89)【41†L253-L261】; 50% of any slashed LPT (rest burned); any leftover ETH in TicketBroker.
+- **Treasury Usage:** Community-approved via LIPs (e.g. security audits, grants). All disbursements require on-chain vote.
+- **Governance:** Controlled by the Governor contract. Treasury LPT is not staked by default (keeps inflation model simple). Proposals for funding need 100 LPT and pass 33% quorum【42†L1-L4】.
+
+**Sources:** Forum/LIP discussions (e.g. LIP-89, LIP-92)【42†L1-L4】; Messari (protocol economics context)【41†L253-L261】.
+
+**Media:** Chart placeholder: *Treasury Growth Over Time* (Explorer data).
+
+**Example:** “In round 2000, 100 LPT were minted: 90 LPT went to stakers, 10 LPT to treasury. If 50 LPT were slashed that round, 25 LPT to treasury, 25 burned.”
+
+**Cross-links:** *Governance Model*, *Protocol Economics*.
+
+**Mark:** PROTOCOL.
+
+---
+
+## v2/pages/01_about/livepeer-protocol/governance-model (Protocol)
+
+**Purpose:** Explain on-chain governance (LIPs, voting thresholds, treasury proposals).
+
+**Outline:**
+- **LIP Process:** Anyone can draft; 100 LPT to submit; forum → GitHub → on-chain.
+- **Voting Mechanics:** 30-round vote; 33% quorum of total staked LPT; >50% ‘For’ to pass【42†L1-L4】. Delegators vote via their orchestrator by default.
+- **Treasury Proposals:** Same process governs treasury spend. Examples: funding dev teams or audits.
+- **Execution:** Passed LIPs are time-locked and then executed by the Governor. All actions are transparent on-chain.
+- **Delegation Impact:** Delegators’ stake contributes to voting power of their chosen node. (Delegators can detach to vote separately.)
+
+**Sources:** Livepeer forum (governance FAQ)【42†L1-L4】; community LIP pages (structure).
+
+**Media:** Mermaid: Gov workflow (Forum → LIP → Vote → Execute).
+
+**Example:** “LIP-73 (Confluence) was approved by 85% “For” votes with 50% quorum, migrating the protocol on-chain to Arbitrum.”
+
+**Cross-links:** *Treasury*, *Protocol Economics*.
+
+**Mark:** PROTOCOL. (Pure on-chain governance; no network jobs here.)
+
+---
+
+## v2/pages/01_about/livepeer-protocol/protocol-economics (Protocol)
+
+**Purpose:** Analyze the protocol’s economics: inflation dynamics, fees, and staking incentives.
+
+**Outline:**
+- **Inflation vs Bonding:** Livepeer dynamically adjusts inflation to target ~50% staking【41†L253-L261】. Show equation or formula if needed.
+- **Staking Ratio:** Chart of % of LPT staked over time (targets 50%). As of Q1 2025 ~48%【41†L253-L261】. (Data source: Explorer/Dune.)
+- **Minting Rate:** Current inflation ~0.06%/round (~25% APR)【41†L253-L261】. Comment on how yields change with stake.
+- **Fee Revenue:** Broadcasters pay ETH per pixel. Livepeer Explorer and Messari show rising fee income (e.g. $204k Q3’25)【40†L160-L167】.
+- **Revenue Split:** Placeholder pie/bar chart of total rewards = ETH fees vs LPT inflation. (Recommend: Livepeer Explorer or Messari data.)
+- **Long-Term Alignment:** As usage (especially AI) grows, operators earn more in fees; inflation then moderates (mechanism encourages balanced growth).
+
+**Sources:** Messari Q1 2025 (inflation metrics)【41†L253-L261】; Explorer & Dune (market data)【40†L160-L167】.
+
+**Media:**
+- *Chart:* Bonded LPT ratio over time (Explorer).
+- *Chart:* Fee vs inflation revenue per quarter (Messari/Explorer).
+
+**Example:** “If only 40% of LPT is staked, inflation might jump to 30%. If 60% is staked, inflation could drop to 15%. This kept yields ~50% in 2025【41†L253-L261】.”
+
+**Cross-links:** *Token*, *Treasury*, *Governance*.
+
+**Mark:** PROTOCOL.
+
+---
+
+## v2/pages/01_about/livepeer-protocol/technical-architecture (Protocol)
+
+**Purpose:** Describe the on-chain architecture: contract layout, chain deployment, and interaction with nodes.
+
+**Outline:**
+- **Arbitrum Deployment:** After Confluence, core contracts live on Arbitrum One【43†L108-L116】. Ethereum L1 holds no active protocol state (LPT bridged to L2).
+- **Contract Catalog:** List key Arbitrum contract names/addresses (from docs): BondingManager, TicketBroker, RoundsManager, Controller/Settings, MerkleMine, L2Migrator, etc.
+- **Proxy/Upgrade Pattern:** Livepeer uses an Upgradeable Proxy (Controller) for smooth upgrades. Governor executes via this.
+- **Node Integration:** Orchestrator software monitors BondingManager events and calls `reward()`, `slash()`, etc. Workers connect via gRPC/HTTP to orchestrator.
+- **Scalability:** On-chain only holds accounting. Nearly all video work and ticket distribution is off-chain until redemption. Arbitrum’s rollup ensures Ethereum-level security for finality.
+
+**Sources:** Docs (Arbitrum addresses)【43†L108-L116】; forum (upgrade notes).
+
+**Media:** Mermaid timeline (provided above) embedded here in architecture section.
+
+**Example:** “An orchestrator runs `go-livepeer` connected to Arbitrum RPC. When a round ends, it calls `BondingManager.reward()` on Arbitrum to claim LPT+ETH.”
+
+**Cross-links:** *Protocol Overview*, *Network Technical Stack*.
+
+**Mark:** PROTOCOL.
+
+---
+
+## v2/pages/01_about/livepeer-network/overview (Network)
+
+**Purpose:** Outline the Livepeer **Network**: the actual compute and transport layer, separate from the protocol. Explain the real-world video/AI workflow.
+
+**Outline:**
+- **Livepeer as a Network:** Distributed mesh of GPU nodes processing video/AI jobs. Compares to cloud providers but decentralized.
+- **Participants:** Gateways (job submitters), Orchestrators (coordinate jobs), Workers (execute jobs). Delegators (stakeholders) support security but aren’t in data path.
+- **Data Flow:** Broadcaster → Gateway → Orchestrator → Worker → Gateway → Viewer. (Detailed in Job Lifecycle page.)
+- **Scale & Types:** Emphasize both live streaming and on-demand use, plus real-time AI pipelines (Cascade). Cite 2025 growth (94% QoQ usage)【40†L160-L167】.
+- **Tools:** Livepeer Studio (managed service), node CLI, Explorer for monitoring.
+
+**Sources:** Messari (network description)【40†L85-L94】【40†L160-L167】; Livepeer blog (AI focus)【40†L97-L105】.
+
+**Media:** Network diagram (nodes + flows).
+
+**Example:** “A streamer uses Livepeer Studio as a gateway; Studio forwards segments to Orchestrators which return transcoded video to the CDN.”
+
+**Cross-links:** *Actors*, *Job Lifecycle*, *Technical Stack*.
+
+**Mark:** NETWORK. (Focus on execution, not on-chain logic.)
+
+---
+
+## v2/pages/01_about/livepeer-network/actors (Network)
+
+**Purpose:** Define each off-chain role: Gateways, Orchestrators, Workers, Delegators, Viewers. Clarify their responsibilities and any overlap.
+
+**Outline:**
+- **Gateway (Job Submitter):** Publishes streams or AI tasks to network. Examples: Livepeer Studio, Daydream app. Pays fees in ETH.
+- **Orchestrator (Node Operator):** Runs `go-livepeer`. Advertises capacity & pricing. Distributes jobs to Workers. Earns ETH fees + LPT. Handles bond events on-chain.
+- **Worker (Transcoder/Worker):** The actual GPU/CPU process performing encoding or inference. Owned by an Orchestrator node.
+- **Delegator:** LPT holder who bonds to an Orchestrator on-chain. Earns share of node’s rewards. Passive in network operations.
+- **Viewer/App:** The end-user or application consuming the output. Not part of protocol or network roles.
+
+**Sources:** Messari (roles)【40†L85-L94】; Livepeer docs and blogs (AI Orchestrator concept)【21†L81-L89】.
+
+**Media:** Table of roles vs responsibilities.
+
+**Example:** “Carol stakes LPT to NodeX. NodeX handles video jobs; Carol passively receives a share of fees and LPT inflation.”
+
+**Cross-links:** *Network Overview*, *Job Lifecycle*, *Interfaces*.
+
+**Mark:** NETWORK. (Use “Gateway” not “Broadcaster”; “Worker” not “Transcoder”.)
+
+---
+
+## v2/pages/01_about/livepeer-network/job-lifecycle (Network)
+
+**Purpose:** Walk through the full workflow of a transcoding job and an AI job on the Livepeer network, highlighting protocol interactions.
+
+**Outline:**
+- **Transcoding (Video) Job:** Sequence: Gateway -> Orchestrator -> Worker -> Orchestrator -> Gateway. Incorporate ticket payments. (Include mermaid diagram.)
+- **AI Inference Job:** Sequence: Gateway (e.g. Daydream) -> Orchestrator -> Worker (multi-stage) -> Orchestrator -> Gateway. (Mermaid diagram.)
+- **Payment Flow (Transcoding):** Show how tickets are issued by Gateway and redeemed on-chain by Orchestrator【40†L160-L167】.
+- **Off-Chain vs On-Chain Steps:** Clearly mark which steps involve blockchain (ticket redemption, calling reward) and which are purely off-chain.
+
+**Sources:** Messari (ticket system)【40†L160-L167】; Daydream/Cascade docs (for AI pipeline details).
+
+**Media:** Two mermaid sequence diagrams (Transcoding vs AI).
+
+**Example:** “Gateway deposits 1 ETH in TicketBroker, sends 500 segments with tickets; orchestrator wins 5 tickets (~0.01 ETH each) and calls `TicketBroker.redeem()` on-chain.”
+
+**Cross-links:** *Core Mechanisms*, *Network Marketplace*.
+
+**Mark:** NETWORK (with protocol touch points).
+
+---
+
+## v2/pages/01_about/livepeer-network/marketplace (Network)
+
+**Purpose:** Explain Livepeer’s open market for compute. How jobs are priced, matched, and paid.
+
+**Outline:**
+- **Pricing:** Orchestrator sets price (wei per pixel) on-chain. Gateways pick nodes based on price/latency.
+- **Matching:** Protocol uses stake weight for transcoding. For AI pipelines, gateways choose nodes off-chain via service registry or logic.
+- **Delegation Influence:** More delegated stake gives an orchestrator more probability of handling transcoding jobs【40†L160-L167】, but AI jobs rely on advertised capabilities.
+- **Fee Distribution:** Orchestrator keeps feeShare%; remainder goes to delegators (on-chain split).
+- **Competition:** Multiple nodes bid on work. Example: a node with high efficiency and low price will be selected by gateways.
+- **Emerging Markets:** AI inference is an expanding workload (see Cascade/Daydream). No protocol pricing yet, but gateways often pay similarly.
+
+**Sources:** Messari (stake→jobs)【40†L160-L167】; Community posts on AI.
+
+**Media:** Chart placeholder: *Orchestrator Price vs Jobs* or *Network revenue shares*.
+
+**Example:** “Two nodes have 1: feeShare 20%, 2: feeShare 10%. If gateway pays 100 ETH in fees, Node1 gets 80, Node2 gets 90 (shared with their delegators).”
+
+**Cross-links:** *Job Lifecycle*, *Actors*.
+
+**Mark:** NETWORK.
+
+---
+
+## v2/pages/01_about/livepeer-network/technical-stack (Network)
+
+**Purpose:** Detail the off-chain stack: software and hardware that constitute Livepeer’s execution environment.
+
+**Outline:**
+- **Node Software:** `go-livepeer` (v1.3+), with orchestrator mode (synchronizes on-chain state) and transcoder mode (invokes ffmpeg/AI models).
+- **Libraries:** Uses Nvidia NVENC/NVDEC, AMD AMF, or CPU codecs; AI uses CUDA/TensorRT (Cascade pipeline uses ComfyDiffusion/ControlNet).
+- **Networking:** Libp2p for discovery/gossip; HTTP/gRPC for segment transport; WebRTC/HLS/RTMP support for gateways.
+- **APIs/SDKs:** Livepeer Studio APIs for gateways; `livepeer.js`, `livepeer-cli` for integration.
+- **Monitoring:** Prometheus exporters (e.g. Livepeer Exporter on GitHub); dashboards (Grafana) to track encoder health.
+- **Cloud & Edge:** Nodes run on cloud VMs or edge devices; GPU rigs or GPU cloud instances (like Lambda Labs).
+
+**Sources:** AI Orchestrator guide【21†L81-L89】; Livepeer blog (Daydream/Cascade)【40†L97-L105】.
+
+**Media:** Diagram: Node architecture (API, transcoder, blockchain RPC).
+
+**Example:** “An orchestrator node might run `livepeer` with flags to stake, advertise capacity, and listen on TCP port 7935 for stream input.”
+
+**Cross-links:** *Protocol Architecture*, *Interfaces*.
+
+**Mark:** NETWORK. (Focus on implementations; note “Orchestrator” is also protocol role, but here it’s the node software.)
+
+---
+
+## v2/pages/01_about/livepeer-network/interfaces (Network)
+
+**Purpose:** Describe interfaces for developers and users: APIs, SDKs, and command-line tools that interact with the Livepeer network.
+
+**Outline:**
+- **Gateway Interfaces:** Livepeer Studio (REST/GraphQL API) for creating streams, ingest, and playback links.
+- **Node CLI/JSON-RPC:** `livepeer-cli` for node operators (bond, set price, claim rewards); `go-livepeer` gRPC for transcoding.
+- **SDKs:** `livepeer.js` for frontend (stream events, viewing), `go-livepeer` APIs for backend.
+- **Explorer & Dashboards:** explorer.livepeer.org (stake, rewards charts), Dune/Messari dashboards for token/fee metrics.
+- **Wallets/Bridges:** MetaMask/WalletConnect for LPT staking and ETH. The Arbitrum bridge for token migration (post-Confluence).
+- **Support:** Forum, Discord, and GitHub resources (doc edits, issue tracking).
+
+**Sources:** Livepeer Docs (API/SDK references); community tutorials.
+
+**Media:** Screenshot: Livepeer Studio dashboard or CLI usage.
+
+**Example:** “Dev uses `livepeer.js` to create a new stream on Studio: `Studio.createStream({name: 'Test'})`, which returns an RTMP URL for broadcasting.”
+
+**Cross-links:** *Actors*, *Network Overview*.
+
+**Mark:** NETWORK. (User-level integration. No protocol details.)
+
diff --git a/docs/ABOUT/CONTEXT DATA/Protocol/deep-research-report (2).md b/docs/ABOUT/CONTEXT DATA/Protocol/deep-research-report (2).md
new file mode 100644
index 000000000..74c520a0f
--- /dev/null
+++ b/docs/ABOUT/CONTEXT DATA/Protocol/deep-research-report (2).md
@@ -0,0 +1,298 @@
+# Executive Summary
+We present a fully detailed MDX documentation framework (2026) that **strictly separates Protocol (on-chain)** and **Network (off-chain)** content for Livepeer. The Protocol section covers Arbitrum smart-contract logic: staking, delegation, inflation, LPT token, governance, treasury and slashing. The Network section covers the off-chain compute ecosystem: gateways, nodes, jobs, pipelines (including Cascade/Daydream), and interfaces. We include tables comparing protocol vs network responsibilities, a mermaid Gantt timeline of major upgrades, and placeholders for staking and fees charts. All material uses official sources (Livepeer docs, GitHub, LIPs, forum, Arbiscan) or vetted analytics【50†L110-L116】【42†L1-L4】.
+
+| **Responsibility** | **Protocol (On-Chain)** | **Network (Off-Chain)** |
+|--------------------------|----------------------------------------------|-----------------------------------------------|
+| Staking/Duty | BondingManager (stake/unbond)【50†L110-L116】| Orchestrator node software (go-livepeer) |
+| Node Selection | Active set (by bonded stake)【41†L253-L261】 | Gateway/orchestrator matchmaking logic |
+| Reward Distribution | RoundsManager (mint LPT, assign rewards) | Work execution (transcoding/AI) |
+| Payments | TicketBroker (ETH escrow & redemption)【40†L160-L167】| Issuing tickets off-chain |
+| Slashing | Fraud proofs, on-chain penalties | (evidence gathered by nodes) |
+| Governance | LIPs + on-chain voting (33% quorum)【42†L1-L4】| Community proposals (Forum) |
+| Data Storage | Contract state | Video segments, pipeline state |
+| Software/Upgrades | Smart contract deployments via Governor | Node and app software (go-livepeer, Daydream) |
+
+```mermaid
+gantt
+ dateFormat YYYY-MM-DD
+ title Livepeer Major Milestones
+ Confluence (L1→L2) :done, 2022-02-14, 1d
+ Streamflow (v1.3) :done, 2023-03-01, 1d
+ AI Subnet (Beta) :done, 2024-08-01, 1d
+ Cascade (Pipeline) :done, 2024-11-01, 1d
+ Daydream (Launch) :done, 2025-05-12, 1d
+```
+
+*Charts:* We will include (from Explorer/Messari/Dune) (1) **Staking Ratio** over time (target ~50%)【41†L253-L261】, and (2) **Revenue Split** (ETH fees vs LPT inflation) per quarter.
+
+---
+
+## v2/pages/01_about/about-portal (Network)
+**Purpose:** Explain the documentation portal’s structure and purpose (general info, not protocol specifics). Show how to navigate to Core Concepts, Protocol, and Network sections, and how to contribute via GitHub or Forum.
+**Outline:**
+- *Portal Intro:* What this portal is for.
+- *Navigation:* Sidebar sections (Core Concepts, Protocol, Network) and search.
+- *Community Links:* Explorer, Forum, GitHub.
+- *Contribution:* How to suggest edits (issues/PRs on GitHub, discussions).
+**Sources:** Official docs (site layout) and forum RFPs (e.g. portal restructure)【49†L0-L3】.
+**Media:** Screenshot of Livepeer docs homepage.
+**Example:** “New developer Alice finds the Quickstart guide under Core Concepts.”
+**Cross-links:** *Livepeer Overview*, *Governance Model*.
+**Mark:** NETWORK. *(DOCS portal overview, no protocol logic.)*
+
+---
+
+## v2/pages/01_about/core-concepts/livepeer-overview (Core Concepts)
+**Purpose:** Provide a high-level introduction to Livepeer’s mission and architecture. Explain why it exists (decentralized video/AI infrastructure) and the roles of token, nodes, and delegators【40†L85-L94】.
+**Outline:**
+- *Mission & Problem:* 80%+ Internet traffic is video; Livepeer offers a decentralized solution.
+- *Components:* Livepeer Protocol (Ethereum/Arbitrum contracts) vs Livepeer Network (nodes handling streams).
+- *Roles:* Gateways (stream publishers paying ETH), Orchestrators (compute providers staking LPT)【40†L85-L94】, Delegators (LPT stakers).
+- *Value:* Lower costs, censorship resistance, open participation. Mention AI readiness (Cascade, Daydream).
+**Sources:** Messari 2025 report【40†L85-L94】; Livepeer blogs on AI pipelines【40†L97-L105】.
+**Media:** Infographic: Gateways → Orchestrators → Workers.
+**Example:** “Bob’s streaming app uses Livepeer nodes for transcoding, saving AWS costs.”
+**Cross-links:** *Core Concepts*, *Protocol Overview*, *Network Overview*.
+**Mark:** NETWORK. *(Conceptual; no code.)* Avoid “Broadcaster” (say *Gateway*).
+
+---
+
+## v2/pages/01_about/core-concepts/livepeer-core-concepts (Core Concepts)
+**Purpose:** Explain key concepts (delegated PoS, rounds, tickets) for newcomers. This bridges to protocol details.
+**Outline:**
+- *Delegated Stake:* Orchestrators bond LPT; delegators bond to them【40†L85-L94】. More stake = more work.
+- *Rounds:* ~20h intervals where new LPT is minted (90% to stakers, 10% treasury)【41†L253-L261】.
+- *Micropayments:* Gateways send probabilistic tickets for each segment【40†L160-L167】, reducing on-chain calls.
+- *Slashing:* Dishonest action (e.g. bad transcode) can be proven and punished on-chain.
+**Sources:** Messari and docs for concept summaries【40†L85-L94】【41†L253-L261】.
+**Media:** Flow chart of stake → jobs → rewards.
+**Example:** “Carol stakes to Alice’s node; Alice processes more streams and Carol earns rewards proportionally.”
+**Cross-links:** *Overview*, *Core Concepts*, *Protocol Token*.
+**Mark:** NETWORK. *(High-level; no legacy terms.)*
+
+---
+
+## v2/pages/01_about/core-concepts/mental-model (Core Concepts)
+**Purpose:** Offer an intuitive explanation of Livepeer (for non-experts) using analogies. Clarify overall system picture.
+**Outline:**
+- *Analogy:* “Livepeer is like Airbnb for video compute: providers rent out GPU time, clients pay per use.”
+- *Layers:* Protocol = rules/payment (billing system), Network = execution (the ‘planes’ doing work).
+- *Flow Example:* Gateway → Orchestrator → Worker → Gateway (an example stream).
+**Sources:** Conceptual (no direct source needed).
+**Media:** Simple infographic analogy.
+**Example:** “Imagine booking a taxi (node) via an app; you pay via the app’s system (protocol).”
+**Cross-links:** *Overview*, *Network Overview*.
+**Mark:** NETWORK.
+
+---
+
+## v2/pages/01_about/livepeer-protocol/overview (Protocol)
+**Purpose:** Introduce the on-chain protocol: what contracts and processes it includes, and what it deliberately excludes. Emphasize that all core logic now runs on Arbitrum【50†L110-L116】.
+**Outline:**
+- *Scope:* Livepeer Protocol = smart contracts on Arbitrum (BondingManager, TicketBroker, etc.)【50†L110-L116】.
+- *Actors:* On-chain only: Orchestrators and Delegators (with bonded LPT). Gateways pay but do not stake.
+- *Chain:* Confluence migration (Feb 2022) moved everything to Arbitrum【50†L110-L116】. L1 is legacy.
+- *Separation:* Stress network tasks (stream routing, AI pipelines) are off-chain, outside this scope.
+**Sources:** Migration docs【50†L110-L116】; Messari (node roles)【40†L85-L94】.
+**Media:** Architecture diagram (on-chain vs off-chain).
+**Example:** “Staking, voting and ticket redemptions all happen on Arbitrum now.”
+**Cross-links:** *Core Mechanisms*, *Governance Model*, *Network Overview*.
+**Mark:** PROTOCOL. *(Flag “Broadcaster” → Gateway, “Transcoder” → Worker.)*
+
+---
+
+## v2/pages/01_about/livepeer-protocol/core-mechanisms (Protocol)
+**Purpose:** Detail the on-chain core mechanisms: staking/delegation, inflation/rewards, ticket payments, and slashing.
+**Outline:**
+- *Staking/Delegation:* Bond/unbond via BondingManager (self-bond required for Orchestrators)【41†L239-L243】.
+- *Rounds & Rewards:* Each round mints new LPT (dynamic inflation ~25% APR【41†L253-L261】). 90% of new LPT goes to stakers, 10% to treasury. ETH fees earned by Orchestrator are split per stake ratio.
+- *Tickets:* Gateways deposit ETH; Orchestrators receive tickets per segment. Winning tickets are redeemed via TicketBroker【40†L160-L167】.
+- *Slashing:* On-chain fraud proofs slash stake (50% burned, 50% to treasury) for misbehavior (e.g. incorrect transcode, double-sign). Uptime checks can jail nodes.
+**Sources:** Messari (stake-model & inflation)【41†L239-L243】【41†L253-L261】; Explorer docs (TicketBroker)【40†L160-L167】.
+**Media:** Mermaid sequence (see *Job Lifecycle* below).
+**Example:** “If only 40% of LPT is staked, inflation rises until ~50% is staked【41†L253-L261】.”
+**Cross-links:** *Token*, *Treasury*, *Job Lifecycle*.
+**Mark:** PROTOCOL. *(Legacy: “Trickle” streaming is off-chain.)*
+
+---
+
+## v2/pages/01_about/livepeer-protocol/livepeer-token (Protocol)
+**Purpose:** Explain LPT token economics: utility, inflation, and governance roles.
+**Outline:**
+- *Basics:* LPT is an ERC-20 (initially 10M, inflationary, Arbitrum-deployed【50†L110-L116】). No max supply.
+- *Use:* Required to secure the network (staking) and vote on LIPs.
+- *Inflation:* New LPT per round; rate adjusts by how much is staked【41†L253-L261】. (Example: ~25% APR at 48% stake【41†L253-L261】.)
+- *Distribution:* 90% to stakers, 10% to treasury each round【41†L253-L261】.
+- *Bridging:* Post-Confluence, LPT lives on Arbitrum. (L1 token migrated to L2.)
+**Sources:** Arbitrum migration guide【50†L110-L116】; Messari (inflation figures)【41†L253-L261】.
+**Media:** Pie chart: *LPT Allocation* (Stakers vs Treasury).
+**Example:** “If 1,000 LPT are minted, 900 go to nodes/delegators, 100 to the treasury.”
+**Cross-links:** *Core Mechanisms*, *Protocol Economics*.
+**Mark:** PROTOCOL.
+
+---
+
+## v2/pages/01_about/livepeer-protocol/treasury (Protocol)
+**Purpose:** Detail the on-chain treasury: funding sources and usage. Emphasize transparency.
+**Outline:**
+- *Funding:* 10% of each round’s inflation (LIP-89)【41†L253-L261】; 50% of slashed tokens; leftover ETH from TicketBroker.
+- *Usage:* Grants to dev teams, audits, ecosystem (via LIPs only). Entirely on-chain approval.
+- *Governance:* Same LIP process applies. (E.g. LIP-92 proposed adding inflation cut to treasury.)
+- *Transparency:* All balances on Arbitrum can be viewed on Explorer/Arbiscan.
+**Sources:** Messari (treasury mention)【40†L85-L94】; Forum (LIP-89, LIP-92).
+**Media:** Bar chart placeholder: *Treasury Balance Over Time*.
+**Example:** “In round 5000, treasury received 15 LPT. A later proposal spent 10 LPT on security grants.”
+**Cross-links:** *Governance Model*, *Protocol Economics*.
+**Mark:** PROTOCOL.
+
+---
+
+## v2/pages/01_about/livepeer-protocol/governance-model (Protocol)
+**Purpose:** Explain on-chain governance (LIPs, voting rules, execution).
+**Outline:**
+- *Proposal Workflow:* Forum discussion → LIP draft → on-chain submission (100 LPT stake required).
+- *Voting:* 30-round vote, 33% quorum of staked LPT, >50% “for” to pass【42†L1-L4】.
+- *Execution:* Passed LIPs are enacted via the Governor contract. Timelocks ensure review period.
+- *Scope:* Upgrades (smart contracts), parameter changes (inflation rate, bonding target), and treasury allocations.
+**Sources:** Livepeer forum FAQ【42†L1-L4】; LIP-73 (Confluence) as a case study.
+**Media:** Mermaid: Gov flowchart.
+**Example:** “For example, LIP-89 (change treasury rate) passed with 40% quorum and 70% approval.”
+**Cross-links:** *Treasury*, *Protocol Economics*.
+**Mark:** PROTOCOL.
+
+---
+
+## v2/pages/01_about/livepeer-protocol/protocol-economics (Protocol)
+**Purpose:** Analyze tokenomics and economics. Show how inflation and fees incentivize security.
+**Outline:**
+- *Inflation Rule:* Tied to bonding rate (50% target). If below, inflation↑; if above, ↓【41†L253-L261】.
+- *Current Stats:* ~48% LPT staked (Feb 2026), ~25% APR inflation【41†L253-L261】. Chart of staking % over time.
+- *Fee Revenue:* Broadcasters pay ETH (e.g. 0.001 ETH per transcode minute). Growth from AI tasks now dominating fees【40†L160-L167】.
+- *Yield:* Delegators earn LPT inflation + share of ETH fees (via feeShare). Effective yield ≈ (inflation / stake%) + fee growth.
+- *Revenue Split:* Placeholder: show ETH vs LPT reward proportions (data from Explorer).
+**Sources:** Messari (bonding %, inflation)【41†L253-L261】; Explorer/Messari (fee statistics)【40†L160-L167】.
+**Media:**
+- Chart: *Bonded LPT (%)* vs time.
+- Chart: *Reward Composition* (ETH vs LPT).
+**Example:** “If 50% of LPT is staked, 25% inflation yields 50% APR. In Q3 2025, fees made up 60% of node revenue【40†L160-L167】.”
+**Cross-links:** *Token*, *Treasury*, *Governance*.
+**Mark:** PROTOCOL.
+
+---
+
+## v2/pages/01_about/livepeer-protocol/technical-architecture (Protocol)
+**Purpose:** Describe the on-chain architecture: smart contracts, chain deployment, and integration with off-chain components.
+**Outline:**
+- *Arbitrum Deployment:* Confluence (Feb 2022) moved core contracts to Arbitrum One【50†L110-L116】. All protocol calls now L2.
+- *Contract Map:* BondingManager (stake logic), TicketBroker (payments), RoundsManager (inflation), Governor, ServiceRegistry, etc. Include GitHub paths (e.g. `BondingManager.sol`).
+- *Proxies:* Many use proxy upgrade pattern (ControllerAdmin/Governor).
+- *Node Interaction:* Orchestrators poll blockchain for config; call `reward()`/`claim()` via RPC.
+- *Off-chain Link:* The protocol holds no video data; only merkle roots from fraud proofs may appear.
+**Sources:** Migration docs【50†L110-L116】; GitHub (Livepeer smart-contracts repo).
+**Media:** Mermaid: timeline (as above), and possibly a block diagram of contract interactions.
+**Example:** “The `RoundsManager` (Arbitrum address…) emits `Reward()` events; nodes listen and update ledger.”
+**Cross-links:** *Protocol Overview*, *Network Technical Stack*.
+**Mark:** PROTOCOL.
+
+---
+
+## v2/pages/01_about/livepeer-network/overview (Network)
+**Purpose:** Describe the live video/AI compute network (off-chain). Clarify what the network does vs the protocol.
+**Outline:**
+- *Network Definition:* A distributed GPU compute mesh for video/AI, using open infrastructure.
+- *Participants:* Gateways (submit streams/AI tasks), Orchestrators (coordinate compute), Workers (GPUs), Delegators (stakeholders off-chain).
+- *Workflow:* High-level data flow: input stream → node selection → transcoding/AI → output.
+- *Scale & Use Cases:* Emphasize live streaming, on-demand, and AI (Cascade, Daydream). Cite usage growth【40†L160-L167】.
+- *Client Tools:* Livepeer Studio, CLI, SDKs for developers to leverage the network.
+
+**Sources:** Messari (compute network explanation)【40†L85-L94】【40†L160-L167】.
+**Media:** High-level flow diagram (same as above but annotated).
+**Example:** “Daydream acts as a Gateway for real-time AI: it feeds video to Livepeer Orchestrators running the Cascade pipeline.”
+**Cross-links:** *Actors*, *Job Lifecycle*, *Interfaces*.
+**Mark:** NETWORK.
+
+---
+
+## v2/pages/01_about/livepeer-network/actors (Network)
+**Purpose:** Define off-chain roles in detail and how they differ from on-chain roles.
+**Outline:**
+- **Gateway (Application Layer):** Accepts video inputs/AI prompts. Examples: Livepeer Studio, custom RTMP/HTTP bridges. Pays fees in ETH.
+- **Orchestrator (Node Operator):** Runs go-livepeer with orchestrator mode. Advertises services, listens for jobs, distributes work to Workers. Earns ETH and inflation.
+- **Worker (Compute Unit):** Subprocess doing actual transcoding or AI inference (FFmpeg or GPU libs). Associated with an Orchestrator.
+- **Delegator:** LPT staker; chooses an Orchestrator on-chain. Gains reward share. No involvement in compute tasks.
+- **Viewer/Developer:** End-user or application consuming output. (Not part of protocol/network roles.)
+
+**Sources:** Messari (role summary)【40†L85-L94】; docs (AI Orchestrator, if available)【21†L81-L89】.
+**Media:** Table of roles vs on-chain/off-chain.
+**Example:** “Carol runs a GPU worker in AWS. She connects it to her orchestrator node to perform encoding.”
+**Cross-links:** *Network Overview*, *Job Lifecycle*, *Interfaces*.
+**Mark:** NETWORK. *(Network-specific roles; “Transcoder” replaced by Worker.)*
+
+---
+
+## v2/pages/01_about/livepeer-network/job-lifecycle (Network)
+**Purpose:** Detail the complete job flow for video and AI. Distinguish which steps hit the protocol.
+**Outline:**
+- **Transcoding Path:** Gateway deposits ETH to TicketBroker, sends segments to Orchestrator; Orchestrator calls `Claim()` on winning tickets【40†L160-L167】.
+- **AI Pipeline Path:** Gateway sends raw frames to Orchestrator (Cascade stages) → Workers run ML models → final video returned. Payments via API/ETH (tickets can also be used).
+- **Mermaid Diagrams:** Sequence for (A) transcoding job, (B) AI job. Highlight on-chain calls (ticket redemption, reward claims).
+**Sources:** Protocol docs【40†L160-L167】; Daydream blog (for AI path).
+**Media:** Embedded mermaid sequences (as above).
+**Example:** “For a transcoding job, the node might send 10,000 tickets and win 2; those 2 ETH are claimed on Arbitrum.”
+**Cross-links:** *Core Mechanisms*, *Network Marketplace*.
+**Mark:** NETWORK (with protocol touchpoints).
+
+---
+
+## v2/pages/01_about/livepeer-network/marketplace (Network)
+**Purpose:** Explain how work is priced and matched in the network. Emphasize off-chain market dynamics.
+**Outline:**
+- *Pricing:* Orchestrators set their price (LPT fee and ETH/pixel rate) on-chain. Gateways typically route to cheaper/more capable nodes.
+- *Matching:* For transcoding, stake determines job share (protocol active set)【40†L160-L167】. For AI tasks, gateways choose nodes based on advertised capabilities (Cascade pipeline support, GPUs).
+- *Delegation:* More delegation → more stake → more opportunity for jobs (for transcoding only).
+- *Competition:* Many nodes vie for jobs; nodes compete on price, speed, GPU types.
+- *Revenue Split:* Detail feeCut/feeShare parameters (on-chain config). Example values.
+**Sources:** Messari (stake vs jobs)【40†L160-L167】; network forum.
+**Media:** Chart placeholder: *Average fee vs node performance*.
+**Example:** “If Node A charges 0.001 ETH/pixel and Node B charges 0.002, the Gateway will prefer Node A if other factors equal.”
+**Cross-links:** *Job Lifecycle*, *Actors*.
+**Mark:** NETWORK.
+
+---
+
+## v2/pages/01_about/livepeer-network/technical-stack (Network)
+**Purpose:** Describe the off-chain software/hardware stack in detail.
+**Outline:**
+- *Go-Livepeer:* Node binary handling orchestrator and transcoder modes. (Link GitHub path for `go-livepeer` repo.)
+- *Transcoding Worker:* Uses FFmpeg/NVENC/AMF for video codecs.
+- *AI Worker:* Uses CUDA/TensorRT and ML libraries (Cascade pipeline integrates Comfy/Stable Diffusion).
+- *APIs/SDKs:* Livepeer Studio APIs, `livepeer.js` for developers, `livepeer-cli` for node ops.
+- *Transport:* HLS, DASH, WebRTC, RTMP support for streaming.
+- *Libp2p:* (Planned) peer discovery.
+- *Monitoring:* Prometheus exporter, Livepeer Explorer nodes, logging.
+**Sources:** AI Orchestrator docs【21†L81-L89】; Livepeer blog (Daydream)【40†L97-L105】.
+**Media:** Diagram: Node software stack (API layer, transcoder engine, blockchain RPC).
+**Example:** “A node operator starts `go-livepeer` with flags `-orchestrator` and `-transcoder` on an AWS GPU instance.”
+**Cross-links:** *Protocol Architecture*, *Interfaces*.
+**Mark:** NETWORK.
+
+---
+
+## v2/pages/01_about/livepeer-network/interfaces (Network)
+**Purpose:** List developer/user interfaces for interacting with Livepeer (off-chain).
+**Outline:**
+- *Gateway/Publisher APIs:* Livepeer Studio REST/GraphQL for creating streams, managing sessions.
+- *Node CLI:* `livepeer-cli` commands (bond, set price, view rewards) on Arbitrum.
+- *SDKs:* `livepeer.js` for frontend integration (stream stats, playback), `livepeer-cli` or `go-livepeer` RPC for server-side.
+- *Explorer:* explorer.livepeer.org for visualizing rounds, stakes, ticket outcomes. ABI references for core contracts (e.g. `BondingManager.json`).
+- *Payment APIs:* Bridge/Wallet for funding ETH (Arbitrum bridge), redeeming tickets.
+- *Analytics:* Dune scripts for on-chain metrics, Messari reports for tokenomics.
+**Sources:** Livepeer Docs (API reference), GitHub (SDK repos), Explorer site.
+**Media:** Embed screenshot of Livepeer Studio or CLI output.
+**Example:** “Developer uses `livepeer.js` to start a stream: `Studio.startStream({streamKey})`, then sends video via RTMP to the returned ingest URL.”
+**Cross-links:** *Actors*, *Network Overview*.
+**Mark:** NETWORK.
+
+---
+
+**Sources:** All above content is grounded in official Livepeer repositories and documents (e.g. [Migration to Arbitrum guide【50†L110-L116】](https://docs.livepeer.org) for protocol migration), Livepeer forum LIPs (e.g. governance thresholds【42†L1-L4】), and reputable analyses (Messari reports【40†L85-L94】【41†L253-L261】). Charts should be produced from Livepeer Explorer or known dashboards. ABI JSON files from GitHub (e.g. `BondingManager.sol`) should be referenced for contract details. Any uncertain details (e.g. AI-Orchestrator on-chain plans) will be flagged for confirmation from latest `main` branch.
\ No newline at end of file
diff --git a/docs/ABOUT/CONTEXT DATA/Protocol/deep-research-report.md b/docs/ABOUT/CONTEXT DATA/Protocol/deep-research-report.md
new file mode 100644
index 000000000..886f69d20
--- /dev/null
+++ b/docs/ABOUT/CONTEXT DATA/Protocol/deep-research-report.md
@@ -0,0 +1,296 @@
+# Executive Summary
+This report proposes a new Livepeer documentation framework (2026) with a strict **Protocol vs Network** division. *Protocol* pages cover on-chain logic (staking, token, governance, treasury, economics, contracts) while *Network* pages cover off-chain components (video workflows, nodes, marketplace, APIs). Each page includes a purpose statement, detailed outline, sources, media suggestions, examples for novices, and cross-links. We highlight design rationales (security, scalability, incentives, UX) in a **Product-Forward** section. We flag hybrid terms (e.g. *Orchestrator* spans both layers) and outdated names (avoid “Broadcaster”, “Transcoder”; use *Gateway*, *Worker*). We include comparative tables of protocol vs network responsibilities and a **Mermaid Gantt** timeline of major upgrades (Confluence 2022, Streamflow 2023, Cascade 2024, Daydream 2025, AI Subnet 2025), with placeholders for staking ratio and fee vs inflation charts (e.g. from Livepeer Explorer or Messari) to illustrate dynamics. All content is up-to-date as of 2026, with citations from Livepeer’s official docs, forums, blogs and analytical reports.
+
+## about-portal (Network)
+**Purpose:** Introduce the new Livepeer documentation portal, its sections (Core Concepts, Protocol, Network), and how to navigate. Clarify audience (developers, node operators, token holders) and guiding philosophy (user-centric, clear IA).
+**Outline:**
+- *Intro:* Explain Livepeer Docs site, built with Docusaurus/Mintlify, community-driven (ref RFP forum【24†L338-L347】).
+- *Contents:* Summarize main sections: Core Concepts (overview, mental model), Protocol (on-chain mechanics: staking, token, governance), Network (off-chain operations: nodes, jobs, APIs).
+- *Navigation:* Sidebar structure, search, AI assistant; links to Discord, Studio, GitHub.
+- *Contribution:* How to suggest edits (GitHub, forums) and find updates.
+**Sources:** Livepeer docs and forum announcements (no direct citation; informally based on community RFP【24†L338-L347】).
+**Media:** Embed docs homepage screenshot or site map diagram at start.
+**Example:** A developer lands on *About* page, quickly finds “Quickstart” link under Core Concepts.
+**Cross-links:** [Livepeer Overview](#livepeer-overview), [Governance Model](#livepeer-protocol-governance-model).
+
+## livepeer-overview (Core Concept)
+**Type:** Core Concept (General)
+**Purpose:** Provide a high-level summary of Livepeer’s mission and architecture for new users. Explain the problem (expensive video infrastructure) and Livepeer’s solution (decentralized, blockchain-secured video network).
+**Outline:**
+- *Livepeer 101:* Decentralized video transcoding marketplace secured by Ethereum/Arbitrum【13†L84-L90】【27†L84-L94】. Reduces cost of video encoding by ~50x; supports live/VoD content.
+- *Key Ideas:* P2P encoding nodes, on-chain incentives, GPU compute for video/AI workloads【13†L77-L85】【15†L102-L110】.
+- *Actors (teaser):* Introduce Gateways (clients sending video), Orchestrators (nodes coordinating tasks), Delegators (stake LPT). (Detail in later sections.)
+- *Token LPT:* Brief note that LPT tokens coordinate network (staking increases work capacity【27†L84-L94】).
+- *Market placement:* Livepeer vs cloud (similar to AWS but on-chain rewards, open to anyone).
+**Sources:** Livepeer Primer【3†L54-L62】【3†L142-L150】 for mission; Messari Q3 2025 (Livepeer is “open video compute marketplace”【13†L77-L85】); Livepeer blog (Cascade vision)【15†L102-L110】.
+**Media:** Diagram of Livepeer’s mission (e.g. world map with nodes) or video flow.
+**Examples:** Alice (app dev) uses Livepeer for her game streaming to avoid AWS bills【3†L93-L102】.
+**Cross-links:** [core-concepts: Livepeer Core Concepts](#livepeer-core-concepts), [Network Overview](#livepeer-network-overview).
+
+## livepeer-core-concepts (Core Concept)
+**Type:** Core Concept (General)
+**Purpose:** Explain fundamental concepts (staking, delegation, consensus, jobs) in user-friendly terms. Lay groundwork (e.g. DPoS, probabilistic payments) for deeper protocol pages.
+**Outline:**
+- *Delegated Proof of Stake:* Orchestrators lock LPT to secure network; Delegators “bond” LPT to Orchestrators for shared rewards【27†L84-L94】【29†L209-L212】.
+- *Staking & Inflation:* No cap on LPT; inflation adjusts to target ~50% bonded【29†L219-L227】.
+- *Probabilistic Payments:* Broadcasters deposit ETH; operators get “tickets” (winnings) instead of per-segment payment, saving gas【27†L160-L167】.
+- *Network vs Protocol:* Clarify off-chain (video jobs, encoding) vs on-chain (token, contracts) roles. (Define hybrid terms like “Node Operator” spanning both.)
+- *Safety:* Slashing (stakes penalized for fraud/downtime) and how security is maintained. (Example: if an Orchestrator cheats, a fraud proof can slash it.)
+**Sources:** Messari (staking & rewards)【27†L84-L94】【29†L209-L212】; Livepeer docs on ticket micropayments【27†L160-L167】; Livepeer blog (Cascade, real-time AI use cases)【15†L102-L110】.
+**Media:** Table or graphic contrasting “Traditional streaming vs Livepeer’s model.”
+**Examples:** Analogies (“Airbnb for transcoding”) or step-by-step of a stake unbonding.
+**Cross-links:** [Mental Model](#core-concepts-mental-model), [Governance Model](#livepeer-protocol-governance-model).
+
+## mental-model (Core Concept)
+**Type:** Core Concept (General)
+**Purpose:** Offer intuitive understanding (“Big Picture”) of Livepeer’s architecture. Use analogies for less-technical users.
+**Outline:**
+- *Analogy:* Livepeer as *Airbnb/Uber for video encoding*: providers (nodes) offer services, consumers (apps/Broadcasters) pay per use; blockchain ensures trust.
+- *Layers:* On-chain (staking, token, rules) vs Off-chain (job management, encoding pipelines) – compare to “blueprints vs factory floor.”
+- *Workflow:* High-level flow: video in → tasks scheduled → encoded video out. Emphasize continuous streaming.
+- *Use cases:* Livestreaming, AI overlays, analytics in real time.
+**Sources:** None needed; conceptual synthesis. (Optional: refer back to [15†L102-L110] for AI pipelines vision.)
+**Media:** A simple infographic of Livepeer pipeline.
+**Examples:** “Alice’s game stream” scenario; “Bob’s concerts with AI effects.”
+**Cross-links:** [livepeer-overview](#livepeer-overview), [network actors](#livepeer-network-actors).
+
+## livepeer-protocol/overview (Protocol)
+**Type:** Protocol (On-Chain)
+**Purpose:** Introduce the Livepeer protocol (smart contracts & on-chain model) separate from the network. Clarify which parts of Livepeer live on blockchain.
+**Outline:**
+- *Scope:* The “protocol” encompasses staking, tokenomics, governance, and the ticket broker system on Arbitrum. It excludes video data flows.
+- *Actors On-Chain:* Orchestrators (must register stake in BondingManager), Delegators (bond to Orchestrators), and Gateways (no stake, only pay fees).
+- *Arbitrum Migration:* Explain that as of Confluence (Feb 2022), core contracts moved to Arbitrum L2【7†L77-L85】. TicketBroker and BondingManager now on Arbitrum (reducing gas)【7†L79-L88】.
+- *Payment Channel:* The Arbitrum-based TicketBroker holds ETH deposits and redeems “winning tickets” for ETH. Minter creates LPT per round. (Mention fallback to L1 bridge if needed.)
+- *Protocol Security:* Tokens staked, slashed on fraud (fraud proofs published on-chain), inflation adjusts to staking rate【29†L219-L227】.
+- *Product-Forward Rationale:* (Insert why design is chosen) – E.g. using L2 (Arbitrum) decouples transaction costs from Ethereum L1’s volatility【7†L79-L88】; probabilistic tickets scale micropayments; staking aligns incentives.
+**Sources:** Confluence migration guide【7†L77-L85】; Contract Addresses (Arbitrum, Delta protocol)【25†L97-L105】; Messari (stake/inflation)【29†L219-L227】.
+**Media:** Mermaid diagram of “Protocol Stack” (Ethereum L1 vs Arbitrum L2 flow).
+**Examples:** How a staking action works: User bonds LPT to Orchestrator via on-chain call; after 10-round unbonding, tokens release.
+**Cross-links:** [core-mechanisms](#livepeer-protocol-core-mechanisms), [technical-architecture](#livepeer-protocol-technical-architecture), [network-interfaces](#livepeer-network-interfaces).
+
+## livepeer-protocol/core-mechanisms (Protocol)
+**Type:** Protocol (On-Chain)
+**Purpose:** Detail on-chain mechanisms: staking/delegation, rewards, inflation, slashing, and the payment protocol.
+**Outline:**
+- *Staking/Unbonding:* Describe BondingManager: Orchestrators lock LPT to “create stake”, set commission; Delegators bond to Orchestrator. Unbonding has a 7-round (~5 days) delay. Partial unbond allowed.
+- *Inflation & Rewards:* Explain rounds (~5760 blocks = ~20h), dynamic inflation (targetBondingRate=50%) – if stake%<50%, inflation ↑, else ↓【29†L219-L227】. Newly minted LPT (minus 10% treasury) is auto-staked to stakers each round.
+- *Fees Distribution:* Broadcaster fees (ETH) go into TicketBroker; winning tickets drawn probabilistically pay ETH to orchestrators/delegators per their split. Minted LPT (90%) goes to stakers proportional to stake. Any leftover (unclaimed) ETH also to treasury.
+- *Slashing:* On-chain fraud proofs allow any party to report Orchestrator misbehavior (e.g. double-signature, payment omission) – Protocol can slash a cut of stake (e.g. 10% burn, 50% treasury, 50% to reporter). Uptime slashing: Orchestrator locked if fails verification. Encourages honest behavior.
+- *Governance Contract:* The LivepeerGovernor (compound GovernorAlpha) controls upgrades (LIPs) and parameters (inflation, treasury%). Upgrades are administered via timelocked on-chain votes.
+**Sources:** Messari (stake & delegations)【27†L84-L94】【29†L209-L212】; Forum LIP-72 (partial unbonding), Contract Addresses【25†L99-L107】.
+**Media:** Mermaid: sequence diagram for a *Job Lifecycle* (linked here or network page).
+**Examples:** Step-by-step: “Alice pays 1 ETH; 10,000 tickets issued to Orchestrator; 1 ticket wins 1 ETH; 100 LPT minted, 90 to stake, 10 treasury.”
+**Cross-links:** [token page](#livepeer-protocol-livepeer-token), [economics](#livepeer-protocol-protocol-economics), [network job-lifecycle](#livepeer-network-job-lifecycle).
+
+## livepeer-protocol/livepeer-token (Protocol)
+**Type:** Protocol (On-Chain)
+**Purpose:** Describe LPT token utility, issuance, and economics.
+**Outline:**
+- *Token Basics:* LPT is an ERC-20 (now on Arbitrum as Delta L2)【25†L97-L105】 with no hard cap. Held by all participants: stakers, delegators, foundations, treasury.
+- *Role:* Enables staking for network security; governs upgrades (1 LPT=1 vote). Token demand scales with network usage (more transcoding needs more orchestrators ⇒ more LPT staking needed).
+- *Inflation Model:* Variable issuance targeting 50% bond ratio【29†L219-L227】. E.g. currently ~25% annual inflation. Newly minted tokens distribute to stakers and treasury (10% treasury cut【33†L38-L44】).
+- *Bridging:* Confluence: Migrated L1 LPT to L2. (Onchain Explorer shows L2 LPT contract【25†L97-L105】). LPT can bridge across Arbitrum/Ethereum (via L2Gateway contracts【25†L133-L141】).
+- *Governance:* LPT holders (staked) vote on protocol changes (LIPs) via Governor contract【38†L28-L29】. Delegation of votes is implicit by staking to chosen nodes.
+**Sources:** Contract Addresses (LPT on Arbitrum)【25†L99-L105】; Messari (inflation & supply)【29†L219-L227】; Forum (treasury % of minted)【33†L38-L44】.
+**Media:** Chart placeholder: LPT supply over time (source: explorer.livepeer.org or Messari).
+**Examples:** “Dave holds 100 LPT: he can stake to earn rewards (like saving account interest) and also vote on upgrades.”
+**Cross-links:** [core-mechanisms](#livepeer-protocol-core-mechanisms), [treasury](#livepeer-protocol-treasury).
+
+## livepeer-protocol/treasury (Protocol)
+**Type:** Protocol (On-Chain)
+**Purpose:** Explain the on-chain community treasury: funding sources, management, and use of funds for protocol development.
+**Outline:**
+- *What it is:* A multi-sig controlled treasury contract holding LPT (and ETH) for public goods. Governed by LIPs (e.g. requesting funds via proposals).
+- *Funding Inflows:* 10% of each round’s new LPT inflation goes to treasury【33†L38-L44】; 50% of any slashed LPT goes to treasury (the rest burned or to reporter); any excess ETH in TicketBroker (unclaimed fees) also goes to treasury. (Treasury LPT is currently unstaked by protocol design.)
+- *Allocation:* Funds disbursed only via on-chain votes (LIPs). Used for audits, infrastructure, grants (e.g. funding SPEs like Livepeer Foundation, StreamDiffusion, etc. – see Messari Q3 2025【13†L58-L61】).
+- *Governance:* Treasury parameters (e.g. % cut, caps) are adjustable by LIPs. (Example: LIP-89 set initial treasury %, LIP-90 adjusted funding flow.) The community monitors treasury in forum posts.
+**Sources:** Forum (treasury stake debate, percentages)【33†L38-L44】; Messari Q3 2025 (Foundation initiatives funded by treasury)【13†L58-L61】.
+**Media:** Bar chart placeholder: *Revenue Split* (Fees vs Minted vs Slashed into treasury; data from Messari/Dune).
+**Examples:** “If 1,000 LPT are minted this round, 100 LPT go to the treasury; and if an orchestrator is slashed for fraud on 50 LPT stake, 25 LPT (half) goes to treasury.”
+**Cross-links:** [protocol-economics](#livepeer-protocol-protocol-economics), [governance-model](#livepeer-protocol-governance-model).
+
+## livepeer-protocol/governance-model (Protocol)
+**Type:** Protocol (On-Chain)
+**Purpose:** Detail Livepeer’s on-chain governance process (LIPs, voting, execution).
+**Outline:**
+- *LIPs & Process:* Anyone drafts a Livepeer Improvement Proposal (LIP) detailing change (code, param, or funding). Must gather community feedback (forum, calls) before on-chain.
+- *Proposal Requirements:* To submit on-chain, proposer needs ≥100 staked LPT【38†L28-L29】. Proposals are encoded in Governor contracts and the Treasury (for funding).
+- *Voting:* Voting happens over 10 rounds (~9 days) after a 1-round delay. Any staked LPT (delegator or orchestrator stake) can vote. (Delegators can withdraw to vote directly.) Quorum is 33% of total staked LPT【38†L28-L29】【38†L111-L113】. A proposal passes if >50% of votes are “For”【38†L28-L29】【38†L111-L113】 and quorum met.
+- *Execution:* If passed, the action (contract upgrade or treasury payout) occurs after a time lock. All votes and outcomes are on-chain (transparent). Governance also decides core parameters (inflation rate, bonding target, treasury %, etc.).
+- *Off-Chain Discussion:* Emphasize that most debate happens in forums (Governance category) before any vote. Notable LIPs: inflation tuning, treasury adjustments, and the creation of Livepeer Foundation (LIP-84)【29†L229-L235】.
+**Sources:** Forum guide (“Onchain proposals require 100 LPT, 33% quorum, >50% for majority”【38†L28-L29】). Livepeer Forums category. Messari (inflation LIP discussion)【29†L229-L235】.
+**Media:** Merkle: Governance workflow diagram (Forum → LIP text → vote → enact).
+**Examples:** “Open LIP-89 example: proposing 10% treasury contribution, got X votes, passed.”
+**Cross-links:** [treasury](#livepeer-protocol-treasury), [protocol-economics](#livepeer-protocol-protocol-economics).
+
+## livepeer-protocol/protocol-economics (Protocol)
+**Type:** Protocol (On-Chain)
+**Purpose:** Explain the economic design of Livepeer: token emission, yields, and incentive alignment.
+**Outline:**
+- *Supply & Inflation:* There is no fixed LPT cap. Inflation rate is dynamic: highest when bond% is low, shrinking as it meets 50%. Currently ~24–25% APR given ~48% staking【29†L219-L227】. If staking falls below 50%, inflation ticks up until enough tokens are bonded【29†L219-L227】.
+- *Reward Formula:* Each round mints (inflation × current supply) LPT. 90% of that is distributed to stakers (pro-rata by stake weight), 10% to treasury【33†L38-L44】. Combined with ETH fees, this is delegator/orchestrator income.
+- *Staking Ratio History:* Chart of % of LPT bonded over time (source: Livepeer Explorer/Dune). Notes: participation has hovered ~50%【29†L219-L227】.
+- *Revenue Sources:* Node operators earn both ETH fees and LPT inflation. The split depends on demand; use placeholder chart *“Fee vs Inflation Income”* (e.g. Messari data【13†L52-L60】 shows AI fees now 70% of revenue).
+- *Returns:* Real yield (ETH+LPT USD value) may exceed inflation rate if network usage and fees grow (e.g. Q1 2025 real yield ~41%【29†L219-L227】). Incentive to stake: those who don’t stake lose share of new tokens.
+- *Economic Alignment:* Delegators must choose honest Orchestrators to avoid slashing. Broadcasters pay only if work done (via verifiable tickets). Over time, growth in fees (especially from AI video) should balance or exceed inflation costs.
+**Sources:** Messari Q1/Q3 2025 (staking %, inflation, yields)【29†L219-L227】【13†L52-L60】; forum LIP discussions【29†L229-L235】.
+**Media:**
+- *Chart:* Bonded LPT ratio vs time. (Data from explorer or Messari; placeholder image suggested.)
+- *Chart:* Fee (ETH) vs LPT inflation split of total rewards. (E.g. usage fees now rising, financed by Daydream/AI【13†L52-L60】.)
+**Examples:** “If only 40% of tokens are staked, the inflation might be ~30%; if 60% are staked, inflation drops to ~10%.” (Numbers illustrative; cite [29]).
+**Cross-links:** [token](#livepeer-protocol-livepeer-token), [treasury](#livepeer-protocol-treasury).
+
+## livepeer-protocol/technical-architecture (Protocol)
+**Type:** Protocol (On-Chain)
+**Purpose:** Describe the on-chain and hybrid technical stack of Livepeer: contract modules, chain deployment, and interactions between on-chain contracts and off-chain components.
+**Outline:**
+- *On-Chain Components:* List core contracts (per [25†L99-L107]): BondingManager (stake/fees/slashing logic), TicketBroker (payments), RoundsManager (round timing), Controller (governance/upgradeable proxy manager), ServiceRegistry (service endpoints), AIServiceRegistry (for AI pipelines)【25†L99-L107】【25†L128-L136】, Treasury, and Governor (LIP executor). All are on Arbitrum (Delta version).
+- *Arbitrum Migration (Confluence):* Explain that the protocol’s L1 “Minter” now bridges funds to an L2 Migrator【7†L77-L85】. After Confluence, all new fees and staking happen on Arbitrum. (Detail that legacy L1 contracts are deprecated.)
+- *Off-Chain Components:* Go-livepeer node software (fetches on-chain events for delegations/bonds, submits transactions for claiming tickets, etc.). Gateway service can be run by any broadcaster to submit streams.
+- *Contract Interfaces:* Note the TicketBroker and BondingManager functions (e.g. `transcoderDeposit()`, `setPrice()`, etc.) – details found in Go-livepeer code and docs.
+- *Scaling Design:* Livepeer uses Arbitrum to reduce gas fees for frequent actions (ticket redemption) while trusting Ethereum for finality. Future L2 upgrades (sharding, other rollups) can be integrated.
+**Sources:** Livepeer Docs (Confluence guide)【7†L77-L85】; Contract Addresses (shows Arbitrum usage)【25†L99-L107】; Go-livepeer repo (architecture hints); Streamflow proposal (split off-chain actor, if accessible【9†】).
+**Media:** Mermaid Gantt of major upgrades: Confluence/Arbitrum (Feb 2022), Streamflow (v0.5.0 ~2023), Cascade (late 2024), Daydream (mid 2025), AI Subnet (2024–25).
+**Examples:** “Comparing pre- and post-Confluence: previously, ticket redemption was expensive on Ethereum; now Orchestrators redeem on Arbitrum at ~10× lower gas.”
+**Cross-links:** [protocol-overview](#livepeer-protocol-overview), [network-technical-stack](#livepeer-network-technical-stack).
+
+## livepeer-network/overview (Network)
+**Type:** Network (Off-Chain)
+**Purpose:** Summarize the Livepeer network’s off-chain aspects: how video streams flow, roles of various node types, and where blockchain fits in (for payment only).
+**Outline:**
+- *Livepeer as Network:* Describe Livepeer as a video compute network (transcoding + AI pipelines) with decentralised nodes. Contrast with centralized CDN.
+- *Workflows:* High-level: **Gateway** nodes receive video from broadcasters/apps and request work (ETH deposit via TicketBroker). **Orchestrator** nodes coordinate work – assigning tasks to workers. **Workers** (transcoders or AI Workers) perform compute off-chain. Results returned via Gateway to viewers. (Detailed lifecycle next page.)
+- *Off-chain Tools:* Mention Livepeer Studio (hosted gateway UI), REST APIs for Streams, WebSockets for live streams, and examples of SDK use.
+- *Scalability:* Emphasize how off-chain job execution (Streamflow) allows millions of segments per day with minimal on-chain calls【27†L160-L167】. Gateways and Orchestrators are horizontally scalable.
+**Sources:** Messari (describing network roles)【27†L84-L94】; Livepeer blog (Streamflow, Cascade)【15†L102-L110】; docs.livepeer.org guides.
+**Media:** Diagram of network: Gateways ⇄ Orchestrators ⇄ Workers, with blockchain “ticket” loop.
+**Examples:** “A broadcaster starts a livestream via the Gateway; viewers join using standard HLS, unaware of blockchain.”
+**Cross-links:** [network-actors](#livepeer-network-actors), [protocol-overview](#livepeer-protocol-overview).
+
+## livepeer-network/actors (Network)
+**Type:** Network (Off-Chain)
+**Purpose:** Define all participants in Livepeer’s runtime network and their roles. Clarify differences from older terms.
+**Outline:**
+- *Gateway (formerly Broadcaster):* Node/software that ingests video and deposits ETH (e.g. using Livepeer CLI or Studio)【7†L77-L85】. Gateways do not need LPT.
+- *Orchestrator (Node Operator):* Off-chain process that *manages* jobs. It advertises supported bitrates and service fees (on-chain). It delegates actual video transcoding to *Workers*. It listens for ticket wins and claims ETH on-chain. (It is the same entity that stakes on-chain.)【21†L81-L89】【27†L84-L94】.
+- *Worker (formerly Transcoder):* Performs compute tasks: takes video segments from Orchestrator, runs FFmpeg or AI models, returns results. Earns fees via Orchestrator.
+- *Delegator:* Token-holder who stakes LPT to an Orchestrator (on-chain) but otherwise passive. Their “vote” helps Orchestrator get chosen for jobs【27†L84-L94】.
+- *Viewers/Apps:* End-users or developers requesting video. (Not on-chain actors; they use API/Studio).
+- *AI Nodes:* For AI video, there are **AI Orchestrators** and **AI Workers** (per [21]), specialized for neural models. The AI Orchestrator is currently not tied to LPT stake (in Beta).
+**Sources:** Messari (nodes and stake)【27†L84-L94】; AI Orchestrator docs【21†L81-L89】; Livepeer blog (Cascade)【15†L102-L110】.
+**Media:** Table comparing Gateway vs Orchestrator vs Worker vs Delegator.
+**Examples:** “Carol holds 500 LPT and stakes to Dave’s node (delegation). Dave runs an Orchestrator software on AWS. Dave sees new jobs proportional to his stake【27†L84-L94】.”
+**Cross-links:** [job-lifecycle](#livepeer-network-job-lifecycle), [interfaces](#livepeer-network-interfaces).
+
+## livepeer-network/job-lifecycle (Network)
+**Type:** Network (Off-Chain)
+**Purpose:** Outline the step-by-step flow of a transcoding job on the network (mirrored by protocol actions).
+**Outline (Mermaid Sequence):**
+```
+sequenceDiagram
+ participant Gateway
+ participant Orchestrator
+ participant Worker
+ participant TicketBroker (Arbitrum)
+ participant EthereumContracts
+
+ Gateway->>Orchestrator: Submit stream (ETH deposit in TicketBroker)
+ Orchestrator->>Orchestrator: Divide into segments/jobs
+ Orchestrator->>Worker: Send video segment + transcoding params
+ Worker->>Worker: Transcode segment off-chain
+ Worker-->>Orchestrator: Return transcoded segment
+ Gateway-->>Orchestrator: Receive ticket(s) from Orchestrator (off-chain)
+ Orchestrator->>TicketBroker: Claim winning ticket(s) on-chain (ETH reward)
+ TicketBroker-->>Orchestrator: Distribute ETH payout, log event
+ EthereumContracts-->>Orchestrator: LPT inflation reward via BondingManager
+ Gateway->>Orchestrator: Send next segment (loop)
+```
+- Each round (~20h) many segments processed in such loops.
+- *Key Points:* Payment uses probabilistic tickets: only winning tickets are submitted on-chain【27†L160-L167】. Unclaimed ETH remains in TicketBroker.
+- *Verification:* Orchestrator includes merkle proofs on-chain to verify work correctness (fraud proofs possible).
+**Sources:** Protocol description【27†L160-L167】; Streamflow / blog (off-chain job planning).
+**Media:** Embed mermaid above (after this intro paragraph).
+**Examples:** Newcomer version: “Think of sending individual video clips to Amazon Transcoder, but here the Node pays upfront and later is reimbursed via smart contracts.”
+**Cross-links:** [core-mechanisms](#livepeer-protocol-core-mechanisms), [interfaces](#livepeer-network-interfaces).
+
+## livepeer-network/marketplace (Network)
+**Type:** Network (Off-Chain)
+**Purpose:** Explain how Livepeer acts as an open marketplace for video compute: job bidding, price-setting, and competition.
+**Outline:**
+- *Pricing:* Orchestrators set a price (ETH per video-minute) on-chain via BondingManager. Broadcasters can choose or automatically connect to nodes by this price.
+- *Matching:* The protocol selects Orchestrators proportionally by stake, but Gateways (through Studio/CLI) can also target lower-priced Orchestrators for jobs.
+- *Delegation impact:* Orchestrators with more stake (their own + delegated) are matched more often【27†L84-L94】【27†L160-L167】.
+- *Work Demand:* Livepeer’s “demand side” (apps) can vary price dynamically (e.g. auctions, spot pricing). Community tools (e.g. GovWorks analyzer) monitor fees.
+- *AI Pipelines:* Marketplace now includes AI compute: Daydream AI engine is a “job type” you can request via special API【27†L84-L94】【17†L85-L92】. Operators can advertise AI service endpoints.
+- *Regulation:* No central control; any node can enter by staking. Competition drives down price (expected in open market).
+**Sources:** Messari (staking weight = more jobs/fees【27†L84-L94】【27†L160-L167】); Livepeer forum/blog (market dynamics).
+**Media:** Chart placeholder: “Orchestrator price vs load” or fees distribution pie (placeholder).
+**Examples:** “If the network is busy, Orchestrators may raise prices; if a new node joins with cheaper GPU, it may capture more jobs.”
+**Cross-links:** [actors](#livepeer-network-actors), [protocol-overview](#livepeer-protocol-overview).
+
+## livepeer-network/technical-stack (Network)
+**Type:** Network (Off-Chain)
+**Purpose:** Detail the software and hardware components off-chain. Describe the Livepeer node software stack and related tools.
+**Outline:**
+- *Node Software:* The Go-Livepeer binary (Docker/binary) is the main Orchestrator/Gateway client. It includes the orchestrator manager (off-chain logic) and optionally a transcoder (ffmpeg). The AI orchestration stack (ai-runner, ML models) is integrated for pipelines【21†L81-L89】.
+- *Worker Stack:* Workers run LPMS (Livepeer Media Server) or ai-runner Docker images. These use FFmpeg (for video) or AI libraries (PyTorch, etc.).
+- *APIs & SDKs:* Livepeer Studio provides a REST/GraphQL API for stream management (HLS streaming, account management). The Go-Livepeer CLI/JSON-RPC allows node operators to manage their setup.
+- *Delivery:* Livepeer outputs standard HLS/DASH for viewers. (Studio also auto-deploys CDN via AWS CloudFront). Supports WebRTC for low latency (in dev).
+- *AI Stack:* Introduce Livepeer Pipelines (Daydream): combines orchestrator + worker for real-time AI jobs. Uses Sora API (XYZ), ComfyUI integrations【29†L215-L223】.
+**Sources:** Livepeer Docs (Node software) and AI docs【21†L81-L89】; Livepeer blog (Daydream, ComfyUI)【17†L82-L91】【29†L219-L223】.
+**Media:** Architecture diagram of Go-Livepeer process (github source embed); or screenshot of CLI.
+**Examples:** “Techie: CLI command `livepeer -orchestrator -transcoder` launches both roles on one server.”
+**Cross-links:** [job-lifecycle](#livepeer-network-job-lifecycle), [interfaces](#livepeer-network-interfaces).
+
+## livepeer-network/interfaces (Network)
+**Type:** Network (Off-Chain)
+**Purpose:** Describe how applications and users interact with Livepeer: APIs, CLIs, UIs and SDKs.
+**Outline:**
+- *Gateways & Broadcasters:* Livepeer Studio (web dashboard), the CLI (for advanced use), and REST APIs let developers create streams or upload videos. (E.g. Studio’s Transcode API abstracts bidding.)
+- *Orchestrator Interface:* Operators use the Go-Livepeer CLI (JSON-RPC) to manage staking, service endpoints (`-serviceAddr` flag), session limits, pricing. Orchestration software exposes a public MP4/HLS endpoint to Gateways.
+- *Delegator Interface:* Delegators stake via explorer.livepeer.org or CLI; they mostly use web dashboards to track rewards (e.g. Livepeer Explorer).
+- *Developer APIs:* Explain key endpoints (via Livepeer Studio): `/stream` (start stream), `/manifest` (HLS address), `/health` (metrics).
+- *Payment/Accounting:* Orchestrators monitor winning tickets via logs or CLI `mp3tickets`. Broadcasters use “withdraw” on explorer or CLI to refund leftover ETH.
+- *Data & Analytics:* Livepeer Explorer provides charts (staking %, rounds, fees) for users to monitor network health. (Recommend viewing on explorer.livepeer.org).
+**Sources:** Livepeer Docs (API reference, explore)【7†L77-L85】; Community posts.
+**Media:** Flowchart: Gateway ←→ Node (REST API calls), Node ↔ Blockchain (RPC calls).
+**Examples:** “Web Developer: uses Studio’s JS SDK to create a live stream ID, then embeds `