@pagenary/publisher 2026.5.0

package/src/manifest.js

@@ -0,0 +1,246 @@
+import { getSectionMetadata } from './sections/section-templates.js';
+
+function sectionEntry(input) {
+  const sectionId = typeof input === 'string' ? input : input.id;
+  const overrides = typeof input === 'string' ? {} : { title: input.title, summary: input.summary };
+  const meta = getSectionMetadata(sectionId, overrides);
+  return {
+    id: sectionId,
+    title: meta.title,
+    summary: meta.summary,
+    module: `./sections/${sectionId}.js`
+  };
+}
+
+function groupEntry({ id, title, summary, sections }) {
+  return {
+    id,
+    title,
+    summary,
+    subsections: sections.map(sectionEntry)
+  };
+}
+
+export const MANIFEST = [
+  sectionEntry({ id: 'welcome-overview', title: 'Welcome', summary: 'Landing hub for introducing each tenant experience.' }),
+  groupEntry({
+    id: 'getting-started',
+    title: 'Getting Started',
+    summary: 'Orientation guides that prepare new teams to launch quickly.',
+    sections: [
+      { id: 'getting-started-introduction', title: 'Introduction' },
+      { id: 'getting-started-architecture-basics', title: 'Platform Fundamentals' },
+      { id: 'getting-started-performance-overview', title: 'Why Precision Matters' }
+    ]
+  }),
+  groupEntry({
+    id: 'core-technology',
+    title: 'Core Systems',
+    summary: 'Reference templates describing foundational infrastructure and consensus patterns.',
+    sections: [
+      { id: 'core-technology-overview', title: 'Overview' },
+      'core-technology-system-foundation',
+      'core-technology-compliance-frameworks',
+      'core-technology-synchronization-strategy',
+      'core-technology-hardware-integration',
+      'core-technology-data-definitions',
+      'core-technology-coordination-model',
+      'core-technology-service-interfaces',
+      'core-technology-integrity-controls',
+      'core-technology-network-topology',
+      'core-technology-operator-requirements'
+    ]
+  }),
+  groupEntry({
+    id: 'technical',
+    title: 'Technical Papers',
+    summary: 'Deep dives and formal descriptions ready for adaptation.',
+    sections: [
+      'technical-architecture',
+      'technical-whitepaper'
+    ]
+  }),
+  groupEntry({
+    id: 'developers',
+    title: 'Developers',
+    summary: 'SDKs, APIs, and engineering workflows captured as reusable templates.',
+    sections: [
+      { id: 'developers-overview', title: 'Developer Hub' },
+      'developers-sdks',
+      'developers-sdk-javascript',
+      'developers-sdk-python',
+      'developers-sdk-rust',
+      'developers-sdk-go',
+      'developers-api-reference',
+      'developers-api-operations',
+      'developers-api-websocket',
+      'developers-api-credentials',
+      'developers-solution-examples',
+      'developers-automation-blueprints',
+      'developers-automation-modules',
+      'developers-automation-patterns',
+      'developers-scheduling-patterns',
+      'developers-testing-framework',
+      'developers-deployment-playbook'
+    ]
+  }),
+  groupEntry({
+    id: 'tutorials',
+    title: 'Tutorials',
+    summary: 'Hands-on walkthroughs that demonstrate end-to-end tenant scenarios.',
+    sections: [
+      'tutorials-overview',
+      'tutorial-build-first-integration',
+      'tutorial-deploy-automation',
+      'tutorial-event-driven-experience',
+      'tutorial-systems-integration',
+      'tutorial-automation-bot',
+      'tutorial-operations-onboarding'
+    ]
+  }),
+  groupEntry({
+    id: 'use-cases',
+    title: 'Use Cases',
+    summary: 'Story-driven templates that connect personas, workflows, and measurable impact.',
+    sections: [
+      'use-cases-overview',
+      'use-case-digital-auctions',
+      'use-case-financial-automation',
+      'use-case-interactive-media',
+      'use-case-realtime-execution',
+      'use-case-connected-devices',
+      'use-case-research-analytics',
+      'use-case-supply-operations'
+    ]
+  }),
+  groupEntry({
+    id: 'products',
+    title: 'Products',
+    summary: 'Packaging and positioning templates for offerings built on the platform.',
+    sections: [
+      'products-solution-library',
+      'products-flagship-solution'
+    ]
+  }),
+  groupEntry({
+    id: 'governance',
+    title: 'Governance',
+    summary: 'Policy and decision-making templates that scale across tenants.',
+    sections: [
+      'governance-overview',
+      'governance-structure',
+      'governance-dao-overview',
+      'governance-proposal-process',
+      'governance-proposals',
+      'governance-token-distribution',
+      'governance-treasury',
+      'governance-community-initiatives',
+      'governance-multi-token'
+    ]
+  }),
+  groupEntry({
+    id: 'resources',
+    title: 'Resources',
+    summary: 'Reference libraries, glossaries, and asset collections ready for reuse.',
+    sections: [
+      'resources-faq',
+      'resources-glossary',
+      'resources-brand-assets',
+      'resources-research-papers'
+    ]
+  }),
+  groupEntry({
+    id: 'security',
+    title: 'Security',
+    summary: 'Risk management templates spanning posture, controls, and incident response.',
+    sections: [
+      'security-overview',
+      'security-best-practices',
+      'security-incident-response',
+      'security-bug-bounty',
+      'security-audits'
+    ]
+  }),
+  groupEntry({
+    id: 'operations',
+    title: 'Operations',
+    summary: 'Runbooks and checklists for service operators and tenant teams.',
+    sections: [
+      'operations-overview',
+      'operations-getting-started',
+      'operations-setup-guide',
+      'operations-environment-prep',
+      'operations-infrastructure',
+      'operations-sync-setup',
+      'operations-power-infrastructure',
+      'operations-monitoring',
+      'operations-performance',
+      'operations-incentives',
+      'operations-incentives-guide',
+      'operations-incentives-strategies'
+    ]
+  }),
+  groupEntry({
+    id: 'archive',
+    title: 'Archive',
+    summary: 'Historical timelines and context for major initiatives.',
+    sections: [
+      'archive-timeline-overview',
+      'archive-milestone-records',
+      'archive-initiative-alpha',
+      'archive-future-roadmap'
+    ]
+  })
+];
+
+export const DEFAULT_SECTION = 'welcome-overview';
+
+const SECTION_INDEX = new Map();
+
+function registerEntry(entry, parentId = null) {
+  if (parentId) entry.parentId = parentId;
+  SECTION_INDEX.set(entry.id, entry);
+  if (Array.isArray(entry.subsections)) {
+    entry.subsections.forEach((subsection) => registerEntry(subsection, entry.id));
+  }
+}
+
+MANIFEST.forEach((entry) => registerEntry(entry));
+
+export function findSection(id) {
+  return SECTION_INDEX.get(id) || null;
+}
+
+// Build flat list of navigable sections for prev/next navigation
+function buildFlatNav() {
+  const flat = [];
+  MANIFEST.forEach((entry) => {
+    if (entry.subsections && entry.subsections.length) {
+      entry.subsections.forEach((sub) => flat.push(sub));
+    } else {
+      flat.push(entry);
+    }
+  });
+  return flat;
+}
+
+const FLAT_NAV = buildFlatNav();
+
+/**
+ * Get previous and next sections for bottom navigation
+ * @param {string} currentId - Current section ID
+ * @returns {{ prev: object|null, next: object|null }}
+ */
+export function getAdjacentSections(currentId) {
+  const index = FLAT_NAV.findIndex((s) => s.id === currentId);
+  if (index === -1) return { prev: null, next: null };
+  return {
+    prev: index > 0 ? FLAT_NAV[index - 1] : null,
+    next: index < FLAT_NAV.length - 1 ? FLAT_NAV[index + 1] : null
+  };
+}
+
+// Site configuration (can be overridden by tenant manifest)
+export const SITE_CONFIG = {
+  bottomNav: 'mobile' // 'always' | 'mobile' | 'never'
+};

package/src/mermaid-init.js

@@ -0,0 +1,207 @@
+/**
+ * Mermaid.js lazy-loading and rendering module
+ * Only loads mermaid when diagrams are detected on the page
+ */
+
+let mermaidPromise = null;
+
+/**
+ * Lazily load mermaid.js from CDN
+ * @returns {Promise<object>} The mermaid module
+ */
+async function loadMermaid() {
+  if (mermaidPromise) return mermaidPromise;
+
+  mermaidPromise = (async () => {
+    const { default: mermaid } = await import('https://esm.sh/mermaid@10/dist/mermaid.esm.min.mjs');
+    mermaid.initialize({
+      startOnLoad: false,
+      theme: 'neutral',
+      securityLevel: 'strict',
+      flowchart: {
+        htmlLabels: true,
+        curve: 'basis',
+        nodeSpacing: 30,
+        rankSpacing: 50,
+        padding: 15,
+        useMaxWidth: true
+      },
+      themeVariables: {
+        fontFamily: 'system-ui, -apple-system, sans-serif',
+        fontSize: '14px'
+      }
+    });
+    return mermaid;
+  })();
+
+  return mermaidPromise;
+}
+
+/**
+ * Generate a unique ID for mermaid diagrams
+ * @returns {string} A unique identifier
+ */
+function generateId() {
+  return 'mermaid-' + Math.random().toString(36).slice(2, 10);
+}
+
+/**
+ * Render all mermaid code blocks within a container
+ * @param {HTMLElement} container - The container to search for mermaid blocks
+ */
+export async function renderMermaidBlocks(container) {
+  const codeBlocks = container.querySelectorAll('code.language-mermaid');
+  if (codeBlocks.length === 0) return;
+
+  const mermaid = await loadMermaid();
+
+  for (const codeBlock of codeBlocks) {
+    const pre = codeBlock.parentElement;
+    const definition = codeBlock.textContent;
+    const id = generateId();
+
+    try {
+      const { svg } = await mermaid.render(id, definition);
+      const wrapper = document.createElement('div');
+      wrapper.className = 'mermaid-diagram';
+
+      // Create controls
+      const controls = document.createElement('div');
+      controls.className = 'mermaid-controls';
+      controls.innerHTML = `
+        <button type="button" class="mermaid-btn mermaid-zoom-out" aria-label="Zoom out">−</button>
+        <button type="button" class="mermaid-btn mermaid-zoom-reset" aria-label="Reset zoom">⊙</button>
+        <button type="button" class="mermaid-btn mermaid-zoom-in" aria-label="Zoom in">+</button>
+      `;
+
+      // Create scrollable content area
+      const content = document.createElement('div');
+      content.className = 'mermaid-content';
+      content.innerHTML = svg;
+
+      wrapper.appendChild(controls);
+      wrapper.appendChild(content);
+
+      // Initialize zoom and pan state
+      let scale = 1;
+      const svgEl = content.querySelector('svg');
+      let isDragging = false;
+      let startX, startY, scrollLeft, scrollTop;
+
+      const updateZoom = () => {
+        if (svgEl) {
+          svgEl.style.transform = `scale(${scale})`;
+          svgEl.style.transformOrigin = 'top left';
+        }
+      };
+
+      // Zoom controls
+      controls.querySelector('.mermaid-zoom-in').addEventListener('click', () => {
+        scale = Math.min(scale + 0.25, 3);
+        updateZoom();
+      });
+
+      controls.querySelector('.mermaid-zoom-out').addEventListener('click', () => {
+        scale = Math.max(scale - 0.25, 0.5);
+        updateZoom();
+      });
+
+      controls.querySelector('.mermaid-zoom-reset').addEventListener('click', () => {
+        scale = 1;
+        updateZoom();
+        content.scrollLeft = 0;
+        content.scrollTop = 0;
+      });
+
+      // Click and drag to pan
+      content.addEventListener('mousedown', (e) => {
+        isDragging = true;
+        content.style.cursor = 'grabbing';
+        startX = e.pageX - content.offsetLeft;
+        startY = e.pageY - content.offsetTop;
+        scrollLeft = content.scrollLeft;
+        scrollTop = content.scrollTop;
+      });
+
+      content.addEventListener('mouseleave', () => {
+        isDragging = false;
+        content.style.cursor = 'grab';
+      });
+
+      content.addEventListener('mouseup', () => {
+        isDragging = false;
+        content.style.cursor = 'grab';
+      });
+
+      content.addEventListener('mousemove', (e) => {
+        if (!isDragging) return;
+        e.preventDefault();
+        const x = e.pageX - content.offsetLeft;
+        const y = e.pageY - content.offsetTop;
+        content.scrollLeft = scrollLeft - (x - startX);
+        content.scrollTop = scrollTop - (y - startY);
+      });
+
+      // Touch gesture support
+      let lastTouchDistance = 0;
+
+      content.addEventListener('touchstart', (e) => {
+        if (e.touches.length === 1) {
+          isDragging = true;
+          startX = e.touches[0].pageX - content.offsetLeft;
+          startY = e.touches[0].pageY - content.offsetTop;
+          scrollLeft = content.scrollLeft;
+          scrollTop = content.scrollTop;
+        } else if (e.touches.length === 2) {
+          // Pinch zoom start
+          lastTouchDistance = Math.hypot(
+            e.touches[0].pageX - e.touches[1].pageX,
+            e.touches[0].pageY - e.touches[1].pageY
+          );
+        }
+      }, { passive: true });
+
+      content.addEventListener('touchmove', (e) => {
+        if (e.touches.length === 1 && isDragging) {
+          const x = e.touches[0].pageX - content.offsetLeft;
+          const y = e.touches[0].pageY - content.offsetTop;
+          content.scrollLeft = scrollLeft - (x - startX);
+          content.scrollTop = scrollTop - (y - startY);
+        } else if (e.touches.length === 2) {
+          // Pinch zoom
+          const distance = Math.hypot(
+            e.touches[0].pageX - e.touches[1].pageX,
+            e.touches[0].pageY - e.touches[1].pageY
+          );
+          if (lastTouchDistance > 0) {
+            const delta = distance - lastTouchDistance;
+            if (Math.abs(delta) > 10) {
+              scale = Math.max(0.5, Math.min(3, scale + (delta > 0 ? 0.1 : -0.1)));
+              updateZoom();
+              lastTouchDistance = distance;
+            }
+          }
+        }
+      }, { passive: true });
+
+      content.addEventListener('touchend', () => {
+        isDragging = false;
+        lastTouchDistance = 0;
+      }, { passive: true });
+
+      // Set initial cursor
+      content.style.cursor = 'grab';
+
+      pre.replaceWith(wrapper);
+    } catch (err) {
+      console.error('Mermaid render error:', err);
+      // Add error class but keep original code visible for debugging
+      pre.classList.add('mermaid-error');
+      // Add error message before the code block
+      const errorMsg = document.createElement('div');
+      errorMsg.className = 'mermaid-error-message';
+      errorMsg.textContent = 'Diagram failed to render: ' + err.message;
+      pre.insertAdjacentElement('beforebegin', errorMsg);
+    }
+  }
+}

package/src/sections/archive-future-roadmap.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'archive-future-roadmap';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/archive-initiative-alpha.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'archive-initiative-alpha';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/archive-milestone-records.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'archive-milestone-records';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/archive-timeline-overview.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'archive-timeline-overview';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/core-technology-compliance-frameworks.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'core-technology-compliance-frameworks';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/core-technology-coordination-model.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'core-technology-coordination-model';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/core-technology-data-definitions.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'core-technology-data-definitions';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/core-technology-hardware-integration.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'core-technology-hardware-integration';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/core-technology-integrity-controls.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'core-technology-integrity-controls';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/core-technology-network-topology.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'core-technology-network-topology';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/core-technology-operator-requirements.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'core-technology-operator-requirements';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/core-technology-overview.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'core-technology-overview';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/core-technology-service-interfaces.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'core-technology-service-interfaces';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/core-technology-synchronization-strategy.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'core-technology-synchronization-strategy';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/core-technology-system-foundation.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'core-technology-system-foundation';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/developers-api-credentials.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'developers-api-credentials';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/developers-api-operations.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'developers-api-operations';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/developers-api-reference.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'developers-api-reference';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/developers-api-websocket.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'developers-api-websocket';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/developers-automation-blueprints.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'developers-automation-blueprints';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/developers-automation-modules.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'developers-automation-modules';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/developers-automation-patterns.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'developers-automation-patterns';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/developers-deployment-playbook.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'developers-deployment-playbook';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/developers-overview.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'developers-overview';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}

package/src/sections/developers-scheduling-patterns.js

@@ -0,0 +1,7 @@
+import { renderSectionTemplate } from './section-templates.js';
+
+const SECTION_ID = 'developers-scheduling-patterns';
+
+export async function load() {
+  return { html: renderSectionTemplate({ id: SECTION_ID }) };
+}