@invisibleloop/pulse 0.1.23 → 0.1.29

package/docs/public/dist/home.boot-BVQXRH32.js

@@ -1,383 +0,0 @@
-import{b as n}from"./runtime-VMJA3Z4N.js";import{a as o}from"./runtime-QFURDKA2.js";import{a as i,b as r}from"./runtime-B73WLANC.js";var l={current:null};var c=o(`export default {
-  route: '/dashboard',
-  meta: {
-    title: 'Dashboard \u2014 My App',
-    styles: ['/app.css'],
-  },
-  server: {
-    data: async (ctx) => {
-      const user = await db.users.find(ctx.cookies.userId)
-      return { user, stats: await db.stats.forUser(user.id) }
-    },
-  },
-  state: { filter: 'all' },
-  mutations: {
-    setFilter: (state, event) => ({ filter: event.target.value }),
-  },
-  view: (state, server) => \`
-    <main id="main-content">
-      <h1>Hello, \${server.data.user.name}</h1>
-      <select data-event="change:setFilter">
-        <option value="all">All time</option>
-        <option value="week">This week</option>
-      </select>
-      <p>\${server.data.stats[state.filter].total} requests</p>
-    </main>
-  \`,
-}`,"js"),a={route:"/",meta:{title:"Pulse \u2014 The spec-first web framework",description:"Pulse is a server-first web framework with streaming SSR, zero client JS by default, and Lighthouse 100 built into the architecture. One spec format. One way to build. Production quality by design.",styles:["/pulse-ui.css","/docs.css"]},state:{},server:{metrics:()=>l.current},view:(d,t)=>`
-    <div class="home">
-      <nav class="home-nav" aria-label="Site navigation">
-        <a href="/" class="logo-link">
-          <svg width="22" height="22" viewBox="0 0 24 24" fill="none" aria-hidden="true">
-            <path d="M13 2L4.5 13.5H11L10 22L19.5 10.5H13L13 2Z" fill="var(--accent)" stroke="var(--accent)" stroke-width="1" stroke-linejoin="round"/>
-          </svg>
-          Pulse
-        </a>
-        <div class="home-nav-links">
-          <a href="/getting-started">Docs</a>
-          <a href="https://github.com/invisibleloop/pulse" target="_blank" rel="noopener">GitHub</a>
-        </div>
-      </nav>
-
-      <main id="main-content">
-      <section class="hero">
-        <div class="hero-icon" aria-hidden="true">
-          <svg width="48" height="48" viewBox="0 0 24 24" fill="none">
-            <path d="M13 2L4.5 13.5H11L10 22L19.5 10.5H13L13 2Z" fill="var(--accent)" stroke="var(--accent)" stroke-width="1" stroke-linejoin="round"/>
-          </svg>
-        </div>
-        <div class="hero-badge">v0.1 \u2014 EARLY ACCESS</div>
-        <h1 class="hero-title">Describe the outcome. Pulse guarantees it.</h1>
-        <p class="hero-subtitle">One spec object per page \u2014 server data, state, mutations, and view, co-located in plain JS. Streaming SSR, security headers, and production caching are enforced by the framework, not left to configuration.<br><br>Designed for AI agents. Production-quality architecture.</p>
-        <div class="hero-ctas">
-          <a href="/getting-started" class="btn-primary">Get Started</a>
-          <a href="/spec" class="btn-secondary">Read the Spec</a>
-        </div>
-      </section>
-
-      <section class="home-stats">
-        <div class="home-stat">
-          <span class="home-stat-value">Fast LCP</span>
-          <span class="home-stat-label">SSR-first architecture</span>
-        </div>
-        <div class="home-stat-divider"></div>
-        <div class="home-stat">
-          <span class="home-stat-value">3.5 kB</span>
-          <span class="home-stat-label">Runtime JS, first visit (brotli)</span>
-        </div>
-        <div class="home-stat-divider"></div>
-        <div class="home-stat">
-          <span class="home-stat-value">0.00</span>
-          <span class="home-stat-label">Cumulative Layout Shift</span>
-        </div>
-        <div class="home-stat-divider"></div>
-        <div class="home-stat">
-          <span class="home-stat-value">100</span>
-          <span class="home-stat-label">Lighthouse score</span>
-        </div>
-      </section>
-
-      <section class="how">
-        <div class="how-inner">
-        <h2 class="section-label">How it works</h2>
-        <div class="how-steps">
-          <div class="how-step">
-            <div class="how-step-num">1</div>
-            <h3>Write a spec</h3>
-            <p>Everything for a page lives in one object: server data, state, mutations, view. One format, no conventions to learn.</p>
-          </div>
-          <div class="how-connector" aria-hidden="true"></div>
-          <div class="how-step">
-            <div class="how-step-num">2</div>
-            <h3>Validate automatically</h3>
-            <p>The schema enforces a single, correct structure. Either the spec is valid, or it\u2019s rejected \u2014 no ambiguity, no runtime surprises.</p>
-          </div>
-          <div class="how-connector" aria-hidden="true"></div>
-          <div class="how-step">
-            <div class="how-step-num">3</div>
-            <h3>Ship with it built in</h3>
-            <p>Streaming SSR, security headers, and immutable caching come from the framework \u2014 not your config. Follow the spec, and the results follow.</p>
-          </div>
-        </div>
-        </div>
-      </section>
-
-      <section class="home-code">
-        <div class="home-code-inner">
-          <div class="home-code-header">
-            <h2>Everything in one object</h2>
-            <p>Server data, state, mutations, and view are co-located. No split files. No hidden conventions. The spec <strong>is</strong> the page.</p>
-          </div>
-          <div class="home-code-block">
-            ${n({content:c,filename:"src/pages/dashboard.js",lang:"JavaScript"})}
-          </div>
-        </div>
-      </section>
-
-      <section class="ai-first">
-        <div class="section-label">Why Pulse + AI</div>
-        <h2 class="ai-first-title">Designed for AI agents. Enforced by the framework.</h2>
-        <p class="ai-first-lead"><strong>Traditional frameworks</strong> were built for humans \u2014 multiple valid patterns, optional decisions, enough surface area for output to drift. Pulse is different.</p>
-        <div class="ai-cols">
-          <div class="ai-col">
-            <h3 class="ai-col-title ai-col-title--bad">AI + existing frameworks</h3>
-            <ul class="ai-col-list">
-              <li>Multiple valid patterns per page \u2014 the agent picks one, the next picks another.</li>
-              <li>Security headers, SSR config, and caching are optional decisions the agent can miss.</li>
-              <li>Output drifts over time as different agents make different choices.</li>
-              <li>Reviewing AI output requires knowing every pattern it could have used.</li>
-            </ul>
-          </div>
-          <div class="ai-col ai-col--pulse">
-            <h3 class="ai-col-title ai-col-title--good">Pulse + AI enforces structure</h3>
-            <ul class="ai-col-list">
-              <li>One spec format per page.</li>
-              <li>Architecture enforces SSR, security, and caching.</li>
-              <li>Agents fill in the contract, never off-pattern.</li>
-              <li>Reading AI output means reading one JS object \u2014 nothing hidden.</li>
-            </ul>
-          </div>
-        </div>
-      </section>
-
-      <section class="versus">
-        <div class="section-label">How Pulse compares</div>
-        <h2 class="versus-title">Constraints enforced. Not recommended.</h2>
-        <p class="versus-sub">Pulse enforces constraints and correctness out of the box; other frameworks leave it to the developer.</p>
-        <div class="versus-table-wrap table-sticky-col">
-          <table class="versus-table">
-            <thead>
-              <tr>
-                <th></th>
-                <th>
-                  <svg width="14" height="14" viewBox="0 0 24 24" fill="none" aria-hidden="true" style="vertical-align:middle;margin-right:.35rem">
-                    <path d="M13 2L4.5 13.5H11L10 22L19.5 10.5H13L13 2Z" fill="var(--accent)" stroke="var(--accent)" stroke-width="1" stroke-linejoin="round"/>
-                  </svg>Pulse
-                </th>
-                <th>Next.js / Remix</th>
-                <th>SvelteKit</th>
-              </tr>
-            </thead>
-            <tbody>
-              <tr>
-                <th scope="row">Ways to write a page</th>
-                <td class="v-yes">One \u2014 the spec schema</td>
-                <td class="v-no">App Router, Pages Router, RSC, client components, loaders\u2026</td>
-                <td class="v-no">+page.svelte, +page.server.js, load(), form actions\u2026</td>
-              </tr>
-              <tr>
-                <th scope="row">Agent-readable structure</th>
-                <td class="v-yes">One JS object per page</td>
-                <td class="v-no">Files, folders, magic exports spread across dirs</td>
-                <td class="v-no">Files, folders, Svelte syntax</td>
-              </tr>
-              <tr>
-                <th scope="row">SSR out of the box</th>
-                <td class="v-yes">Streaming SSR, zero config</td>
-                <td class="v-partial">Yes, but client hydration adds JS overhead on every page</td>
-                <td class="v-partial">Yes, but requires an adapter and client runtime on every page</td>
-              </tr>
-              <tr>
-                <th scope="row">Client JS shipped</th>
-                <td class="v-yes">3.5 kB brotli (shared runtime, first visit)</td>
-                <td class="v-no">50-200 kB+ depending on features</td>
-                <td class="v-partial">~15 kB brotli</td>
-              </tr>
-              <tr>
-                <th scope="row">Security headers</th>
-                <td class="v-yes">On every response, built in</td>
-                <td class="v-no">Manual middleware or plugin</td>
-                <td class="v-no">Manual hooks setup</td>
-              </tr>
-              <tr>
-                <th scope="row">CLS</th>
-                <td class="v-yes">Targets 0.00 \u2014 shell renders before data arrives</td>
-                <td class="v-partial">Depends on implementation</td>
-                <td class="v-partial">Depends on implementation</td>
-              </tr>
-              <tr>
-                <th scope="row">Runtime dependencies</th>
-                <td class="v-yes">Zero \u2014 pure Node.js HTTP</td>
-                <td class="v-no">React, 50+ transitive packages</td>
-                <td class="v-no">Svelte runtime + adapters</td>
-              </tr>
-              <tr>
-                <th scope="row">Production build step</th>
-                <td class="v-yes">None \u2014 <code>node server.js</code> is production</td>
-                <td class="v-no">Required \u2014 <code>next build</code></td>
-                <td class="v-no">Required \u2014 <code>vite build</code></td>
-              </tr>
-            </tbody>
-          </table>
-        </div>
-      </section>
-
-      <section class="usp-blocks">
-
-        <div class="usp-block">
-          <div class="usp-block-aside">
-            <div class="usp-icon">
-              <svg width="28" height="28" viewBox="0 0 24 24" fill="none" aria-hidden="true">
-                <path d="M13 2L4.5 13.5H11L10 22L19.5 10.5H13L13 2Z" fill="var(--accent)" stroke="var(--accent)" stroke-width="1.5" stroke-linejoin="round"/>
-              </svg>
-            </div>
-            <h2>Performance by design</h2>
-            <p>Pulse does not offer performance as an option \u2014 it enforces it structurally. A high Lighthouse score is the baseline. There is nothing to configure because there is nothing to get wrong.</p>
-          </div>
-          <ul class="usp-points">
-            <li>
-              <strong>Fast LCP by design.</strong>
-              The shell renders and streams instantly. Deferred segments arrive as data resolves \u2014 no blocking, no flash.
-            </li>
-            <li>
-              <strong>3.5 kB of JS on first visit.</strong>
-              The shared runtime is brotli-compressed and cached across all navigations. Subsequent pages cost 0.35\u20130.5 kB.
-            </li>
-            <li>
-              <strong>Zero CLS.</strong>
-              The shell occupies the correct layout before data arrives. No placeholder juggling, no layout shift.
-            </li>
-            <li>
-              <strong>Immutable bundle caching.</strong>
-              Production bundles are content-hashed and served with <code>immutable, max-age=31536000</code>. Browsers cache them forever \u2014 deploys are instant for returning visitors.
-            </li>
-          </ul>
-        </div>
-
-        <div class="usp-block usp-block-alt">
-          <div class="usp-block-aside">
-            <div class="usp-icon">
-              <svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="var(--accent)" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
-                <rect x="3" y="11" width="18" height="11" rx="2"/>
-                <path d="M7 11V7a5 5 0 0 1 10 0v4"/>
-              </svg>
-            </div>
-            <h2>Safe by design</h2>
-            <p>Security is not a plugin or a checklist in Pulse \u2014 it is part of the response pipeline. Every page ships the headers most frameworks leave to the developer to remember.</p>
-          </div>
-          <ul class="usp-points">
-            <li>
-              <strong>Security headers on every response.</strong>
-              <code>X-Frame-Options</code>, <code>X-Content-Type-Options</code>, <code>Referrer-Policy</code>, <code>Permissions-Policy</code>, <code>Cross-Origin-Opener-Policy</code> \u2014 all set automatically, including on 404 and 500 pages.
-            </li>
-            <li>
-              <strong>Declarative state constraints.</strong>
-              <code>constraints</code> enforce min/max bounds on state after every mutation. The value can never go out of range regardless of what the client sends.
-            </li>
-            <li>
-              <strong>Co-located validation.</strong>
-              Validation rules live next to the state they guard. The agent can see what is being validated and why, in one place.
-            </li>
-            <li>
-              <strong>Guard before data.</strong>
-              The <code>guard</code> function runs before any server fetcher executes \u2014 authentication and authorisation checks cannot be accidentally bypassed.
-            </li>
-          </ul>
-        </div>
-
-        <div class="usp-block">
-          <div class="usp-block-aside">
-            <div class="usp-icon">
-              <svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="var(--accent)" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
-                <circle cx="12" cy="12" r="10"/>
-                <line x1="12" y1="8" x2="12" y2="12"/>
-                <line x1="12" y1="16" x2="12.01" y2="16"/>
-              </svg>
-            </div>
-            <h2>Nothing to configure</h2>
-            <p>No bundler config. No framework boilerplate. No runtime dependencies to install, audit, or upgrade. Pulse eliminates the category of problems that come from misconfiguration.</p>
-          </div>
-          <ul class="usp-points">
-            <li>
-              <strong>Zero runtime dependencies.</strong>
-              The server is pure Node.js HTTP. No Express, no Fastify, no React. Nothing to add to <code>package.json</code> to run a production server.
-            </li>
-            <li>
-              <strong>No production build step.</strong>
-              <code>node server.js</code> is production. The build step is only needed to generate content-hashed client bundles \u2014 the server runs without it in dev.
-            </li>
-            <li>
-              <strong>esbuild only in development.</strong>
-              The one dev dependency that compiles client bundles is esbuild. Fast, no plugins to configure, never part of the production runtime.
-            </li>
-            <li>
-              <strong>No framework upgrades breaking your app.</strong>
-              Because the spec is a plain JS object with no framework imports in page files, there is no framework API surface to break across versions.
-            </li>
-          </ul>
-        </div>
-
-      </section>
-
-      ${t.metrics?`<section class="metrics-report" aria-labelledby="metrics-title">
-        <div class="metrics-header">
-          <div class="section-label">By the numbers</div>
-          <h2 id="metrics-title" class="metrics-title">Performance you can measure.</h2>
-          <p class="metrics-generated">Report generated ${t.metrics.generatedAt} \xB7 measured from a real Pulse build</p>
-        </div>
-        <div class="metrics-groups">
-          <div class="metrics-group">
-            <div class="metrics-group-label">Lighthouse</div>
-            <div class="metrics-items">
-              ${t.metrics.lighthouse.map(e=>`
-                <div class="metric-item">
-                  <span class="metric-val metric-val--green">${e.value}</span>
-                  <span class="metric-label">${e.label}</span>
-                </div>`).join("")}
-            </div>
-          </div>
-          <div class="metrics-group">
-            <div class="metrics-group-label">Bundle sizes</div>
-            <div class="metrics-items">
-              ${t.metrics.bundles.map(e=>`
-                <div class="metric-item">
-                  <span class="metric-val">${e.value}</span>
-                  <span class="metric-label">${e.label}</span>
-                </div>`).join("")}
-            </div>
-          </div>
-          <div class="metrics-group">
-            <div class="metrics-group-label">Web Vitals</div>
-            <div class="metrics-items">
-              ${t.metrics.vitals.map(e=>`
-                <div class="metric-item">
-                  <span class="metric-val metric-val--green">${e.value}</span>
-                  <span class="metric-label">${e.label}</span>
-                </div>`).join("")}
-            </div>
-          </div>
-          <div class="metrics-group">
-            <div class="metrics-group-label">Architecture</div>
-            <div class="metrics-items">
-              ${t.metrics.architecture.map(e=>`
-                <div class="metric-item">
-                  <span class="metric-val metric-val--accent">${e.value}</span>
-                  <span class="metric-label">${e.label}</span>
-                </div>`).join("")}
-            </div>
-          </div>
-        </div>
-      </section>`:""}
-
-      <section class="home-cta">
-        <h2>The spec is the contract.<br>Your agent fills it in.</h2>
-        <ul class="home-cta-checks">
-          <li>Writes the spec</li>
-          <li>Validates against the schema</li>
-          <li>Checks Lighthouse \u2014 desktop and mobile</li>
-          <li>Runs the tests</li>
-          <li>Ships production quality</li>
-        </ul>
-        <p>MIT licensed and available now. Production quality is not the goal. It is the starting point.</p>
-        <div class="home-cta-actions">
-          <a href="/getting-started" class="btn-primary">Get Started</a>
-          <a href="/spec" class="btn-secondary">Read the Spec</a>
-        </div>
-      </section>
-
-      </main>
-      <footer class="home-footer">
-        <p>MIT License \xB7 <a href="https://github.com/invisibleloop/pulse" target="_blank" rel="noopener">GitHub</a> \xB7 <a href="/getting-started">Get started in 2 minutes</a></p>
-      </footer>
-    </div>
-  `};var s=document.getElementById("pulse-root");s&&!s.dataset.pulseMounted&&(s.dataset.pulseMounted="1",i(a,s,window.__PULSE_SERVER__||{},{ssr:!0}),r(s,i));var w=a;export{w as default};

package/docs/public/dist/how-it-works.boot-LTWAKWKW.js

@@ -1,104 +0,0 @@
-import{ab as u,c as e}from"./runtime-UVPXO4IR.js";import"./runtime-VMJA3Z4N.js";import{a,b as n,c as d,d as i,e as t,i as c}from"./runtime-L2HNXIHW.js";import{a as s,b as l}from"./runtime-B73WLANC.js";var{prev:h,next:p}=a("/how-it-works"),g=u({items:[{dot:"1",dotColor:"accent",label:"Understand",content:e({content:'<strong style="color:var(--ui-text)">Read the guide and inspect the project</strong><p style="color:var(--ui-muted);margin:.25rem 0 0">The agent fetches <code>pulse://workflow</code> and the relevant <code>pulse://guide/*</code> sections, then calls <code>pulse_list_structure</code> to see every existing page, component, and store. Ambiguities are surfaced before any files are touched.</p>'})},{dot:"2",dotColor:"accent",label:"Plan",content:e({content:'<strong style="color:var(--ui-text)">Present a plan \u2014 wait for confirmation</strong><p style="color:var(--ui-muted);margin:.25rem 0 0">Before writing anything the agent describes what it intends to build: the route, state shape, server data, interactions, and any components or integrations it will use. The task does not proceed until you confirm.</p>'})},{dot:"3",dotColor:"accent",label:"Build",content:e({content:'<strong style="color:var(--ui-text)">Write the spec and any supporting files</strong><p style="color:var(--ui-muted);margin:.25rem 0 0">The spec is written as a plain JS object: route, state, server data, mutations, actions, view. The guide constrains every decision \u2014 where state lives, how validation is wired, how the view is structured.</p>'})},{dot:"4",dotColor:"accent",label:"Validate",content:e({content:'<strong style="color:var(--ui-text)">Call <code>pulse_validate</code> \u2014 fix all errors and warnings</strong><p style="color:var(--ui-muted);margin:.25rem 0 0">The spec is checked against the Pulse schema. Every error and warning is resolved before moving on \u2014 missing hydrate, heading order violations, missing escaping, structural mistakes. A clean output is the gate to the next phase.</p>'})},{dot:"5",dotColor:"accent",label:"Browser",content:e({content:'<strong style="color:var(--ui-text)">Screenshot + Lighthouse \u2014 desktop and mobile</strong><p style="color:var(--ui-muted);margin:.25rem 0 0">The agent navigates to the route, takes a screenshot to confirm the rendered output, then runs Lighthouse on both desktop and mobile. Accessibility, Best Practices, and SEO must all be 100. Any failure is fixed and re-verified before continuing.</p>'})},{dot:"6",dotColor:"accent",label:"Tests",content:e({content:'<strong style="color:var(--ui-text)">Write tests, run them, fix failures</strong><p style="color:var(--ui-muted);margin:.25rem 0 0">Unit tests cover any pure logic extracted from the spec. View tests use <code>renderSync</code> / <code>render</code> to assert HTML output. All tests must pass. When fixing a bug, a failing test is written first to pin the behaviour.</p>'})},{dot:"7",dotColor:"accent",label:"Review",content:e({content:'<strong style="color:var(--ui-text)">Call <code>pulse_review</code> \u2014 only after phases 4\u20136 all pass</strong><p style="color:var(--ui-muted);margin:.25rem 0 0">The agent switches into reviewer mode \u2014 reading the source and rendered output against the full spec checklist. Accessibility, empty states, error handling, component usage, and security are all checked. The review agent is always last.</p>'})},{dot:"8",dotColor:"accent",label:"Fix and re-verify",content:e({content:'<strong style="color:var(--ui-text)">Fix every review issue \u2014 re-run affected gates</strong><p style="color:var(--ui-muted);margin:.25rem 0 0">Every issue raised in review is resolved. Validate, Lighthouse, and tests are re-run to confirm all gates still pass. The task is complete only when every phase clears cleanly.</p>'})},{dot:"\u2713",dotColor:"success",label:"Done",content:e({content:'<strong style="color:var(--ui-text)">The spec is the source of truth</strong><p style="color:var(--ui-muted);margin:.25rem 0 0">Validate clean. Lighthouse 100. Tests passing. Review clear. When all four gates pass, the page is done.</p>'})}]}),r={route:"/how-it-works",meta:{title:"How It Works \u2014 Pulse Docs",description:"How the Pulse MCP server gives an AI agent the knowledge and tools to build Pulse apps correctly.",styles:["/pulse-ui.css","/docs.css"]},state:{},view:()=>n({currentHref:"/how-it-works",prev:h,next:p,content:`
-      ${d("How It Works")}
-      ${i("When you run <code>pulse</code> in a project directory, a Model Context Protocol (MCP) server starts alongside the dev server. That MCP server is what gives your AI agent the knowledge, tools, and guardrails to build Pulse pages correctly \u2014 without you having to explain the framework in every prompt.")}
-
-      ${t("mcp","The Pulse MCP server")}
-      <p>MCP is a standard protocol that connects AI agents to external tools and knowledge. When Claude (or any MCP-compatible agent) opens a Pulse project, the MCP server is automatically detected and two things happen:</p>
-      <ul>
-        <li>The agent gains access to <strong>resources</strong> \u2014 read-only documents it can fetch at any time</li>
-        <li>The agent gains access to <strong>tools</strong> \u2014 functions it can call to inspect and modify the project</li>
-      </ul>
-      <p>Together these replace the need to paste documentation into a system prompt or rely on the agent's training data to know how Pulse works.</p>
-
-      ${t("resources","Resources: what the agent knows")}
-      <p>The MCP server exposes two resources the agent reads before doing any work:</p>
-      <ul>
-        <li><strong><code>pulse://guide</code></strong> \u2014 the complete framework reference, split into focused sections so each fits comfortably in a single read. The agent fetches whichever sections are relevant to the task at hand.</li>
-        <li><strong><code>pulse://persona</code></strong> \u2014 the quality bar the agent holds itself to: always write correct SSR, always handle errors, never skip empty states, never hardcode colours, never use <code>data-event</code> on text inputs. The persona defines what "done" means.</li>
-      </ul>
-
-      <p>The guide sections are:</p>
-      <dl class="definition-list">
-        <dt><code>pulse://guide/spec</code></dt>
-        <dd>Spec format \u2014 state, mutations, actions, streaming SSR, validation, key rules, and form layout.</dd>
-
-        <dt><code>pulse://guide/server</code></dt>
-        <dd>Server data fetchers, global store, persist, cookies, redirects, and POST handling.</dd>
-
-        <dt><code>pulse://guide/styles</code></dt>
-        <dd>CSS tokens, theming, custom fonts, and utility classes.</dd>
-
-        <dt><code>pulse://guide/routing</code></dt>
-        <dd>Client-side navigation, page discovery, and dynamic routes.</dd>
-
-        <dt><code>pulse://guide/components</code></dt>
-        <dd>All UI components and their props, icons, charts, and composition patterns.</dd>
-
-        <dt><code>pulse://guide/examples</code></dt>
-        <dd>Complete working page examples covering common patterns.</dd>
-      </dl>
-
-      ${c("note","The guide is authoritative. When there is a question about how something should be structured \u2014 where state lives, how validation is wired, how streaming works \u2014 the guide answers it. The agent does not guess.")}
-
-      ${t("tools","Tools: what the agent can do")}
-      <p>The MCP server provides tools across four categories:</p>
-
-      <h3 class="doc-h3">Scaffolding</h3>
-      <dl class="definition-list">
-        <dt><code>pulse_create_page</code></dt>
-        <dd>Creates a new page spec file from a correct template. The filename determines the route \u2014 <code>about.js</code> becomes <code>/about</code>, <code>posts/[slug].js</code> becomes <code>/posts/:slug</code>. The file is written to <code>src/pages/</code> and picked up by the server automatically.</dd>
-
-        <dt><code>pulse_create_component</code></dt>
-        <dd>Creates a reusable view component in <code>src/components/</code>. Components export named functions that return HTML strings \u2014 no classes, no JSX, no lifecycle hooks.</dd>
-
-        <dt><code>pulse_create_store</code></dt>
-        <dd>Creates a global store module in <code>src/store/</code>. Stores hold shared state (cart, user session, theme) that multiple pages can subscribe to and mutate.</dd>
-
-        <dt><code>pulse_create_action</code></dt>
-        <dd>Scaffolds a reusable server action \u2014 useful for shared form submission logic, API calls, or mutations that appear on more than one page.</dd>
-      </dl>
-
-      <h3 class="doc-h3">Inspection</h3>
-      <dl class="definition-list">
-        <dt><code>pulse_list_structure</code></dt>
-        <dd>Lists every page, component, and store that already exists in the project. The agent calls this before creating anything \u2014 to avoid duplication and to understand what the codebase already provides.</dd>
-
-        <dt><code>pulse_fetch_page</code></dt>
-        <dd>Reads the full source of an existing spec file. Used when the agent needs to understand an existing page before editing it, or when a review of the current state is needed.</dd>
-      </dl>
-
-      <h3 class="doc-h3">Validation &amp; review</h3>
-      <dl class="definition-list">
-        <dt><code>pulse_validate</code></dt>
-        <dd>Validates a spec against the Pulse schema. Returns errors (which block progress) and warnings (which must also be resolved). The agent calls this after writing or editing every spec file.</dd>
-
-        <dt><code>pulse_review</code></dt>
-        <dd>Switches the agent into reviewer mode. Returns the spec source, the rendered HTML output, and a structured checklist covering accessibility, empty states, error handling, component usage, security, and correctness. The agent reads its own output critically and fixes every issue before continuing.</dd>
-      </dl>
-
-      <h3 class="doc-h3">Server</h3>
-      <dl class="definition-list">
-        <dt><code>pulse_restart_server</code></dt>
-        <dd>Restarts the Pulse dev server. Called after structural changes \u2014 adding a new page, modifying the server entry \u2014 to reload all specs and re-register routes.</dd>
-
-        <dt><code>pulse_build</code></dt>
-        <dd>Builds the project for production. Bundles specs, hashes assets, and writes the manifest. Called when the agent needs to verify the production build or prepare a release.</dd>
-      </dl>
-
-      <h3 class="doc-h3">Maintenance</h3>
-      <dl class="definition-list">
-        <dt><code>pulse_check_version</code></dt>
-        <dd>Reports the installed Pulse version and whether an update is available.</dd>
-
-        <dt><code>pulse_update</code></dt>
-        <dd>Updates the Pulse package to the latest version.</dd>
-      </dl>
-
-      ${t("flow","What happens when you ask for something")}
-
-      ${g}
-
-      ${t("why-mcp","Why MCP instead of a system prompt")}
-      <p>A system prompt is static \u2014 it cannot see your project, cannot validate your code, and cannot guarantee the agent uses the right version of the framework. The MCP server is dynamic: it reads the guide from the installed version of Pulse, inspects the actual files in your project, and calls real validation on the spec the agent just wrote.</p>
-      <p>The result is that the agent builds correctly on the first attempt far more often \u2014 not because it is smarter, but because the feedback loop is tighter and the knowledge is always current.</p>
-    `})};var o=document.getElementById("pulse-root");o&&!o.dataset.pulseMounted&&(o.dataset.pulseMounted="1",s(r,o,window.__PULSE_SERVER__||{},{ssr:!0}),l(o,s));var T=r;export{T as default};

package/docs/public/dist/hydration.boot-JRM6IPJL.js

@@ -1,78 +0,0 @@
-import{a as o}from"./runtime-QFURDKA2.js";import{a,b as d,c,d as p,e,g as t,i as r}from"./runtime-L2HNXIHW.js";import{a as i,b as u}from"./runtime-B73WLANC.js";var{prev:l,next:h}=a("/hydration"),s={route:"/hydration",meta:{title:"Hydration \u2014 Pulse Docs",description:"How Pulse hydrates server-rendered HTML on the client \u2014 the hydrate field, mount(), and production bundles.",styles:["/docs.css"]},state:{},view:()=>d({currentHref:"/hydration",prev:l,next:h,content:`
-      ${c("Hydration")}
-      ${p("Hydration in Pulse is opt-in and minimal. Omit <code>hydrate</code> and zero JavaScript is sent to the browser. Add it and Pulse binds events to the server-rendered HTML without re-rendering it \u2014 the SSR-painted content is preserved exactly as the server sent it.")}
-
-      ${e("enabling","Enabling hydration")}
-      <p>Set the <code>hydrate</code> field to a browser-importable path to your spec file. Pulse uses this to generate the bootstrap script that mounts the client runtime:</p>
-      ${t(o(`export default {
-  route: '/counter',
-  hydrate: '/src/pages/counter.js',   // browser path to this file
-  state: { count: 0 },
-  mutations: {
-    increment: (state) => ({ count: state.count + 1 }),
-    decrement: (state) => ({ count: state.count - 1 }),
-  },
-  view: (state) => \`
-    <div>
-      <button data-event="decrement">-</button>
-      <span>\${state.count}</span>
-      <button data-event="increment">+</button>
-    </div>
-  \`,
-}`,"js"))}
-
-      ${e("dev-bootstrap","Development bootstrap")}
-      <p>In development (when <code>hydrate</code> is a source file path, not a <code>/dist/</code> bundle), Pulse emits an inline bootstrap script:</p>
-      ${t(o(`<script type="module">
-  import spec from '/src/pages/counter.js'
-  import { mount } from '/src/runtime/index.js'
-  import { initNavigation } from '/src/runtime/navigate.js'
-  mount(spec, root, window.__PULSE_SERVER__ || {}, { ssr: true })
-  initNavigation(root, mount)
-<\/script>`,"html"))}
-      <p>This imports the spec and runtime source files directly \u2014 no build step required for development.</p>
-
-      ${e("production","Production bundles")}
-      <p>Run <code>npm run build</code> to generate production bundles. This creates content-hashed files in <code>public/dist/</code> and a <code>manifest.json</code> mapping spec hydrate paths to bundle paths.</p>
-      ${t(o(`# Generated by npm run build
-public/dist/
-  runtime-abc123.js          # shared runtime (~2.1 kB brotli)
-  counter.boot-def456.js     # per-page spec bundle (~0.5 kB brotli)
-  manifest.json              # { '/src/pages/counter.js': '/dist/counter.boot-def456.js' }`,"bash"))}
-      <p>When Pulse detects a manifest (via <code>staticDir</code> auto-detection or explicit <code>manifest</code> option), it resolves the <code>hydrate</code> path to the bundle path and emits a single <code>&lt;script src&gt;</code> tag instead of the inline bootstrap:</p>
-      ${t(o('<script type="module" src="/dist/counter.boot-def456.js"><\/script>',"html"))}
-
-      ${e("ssr-true","The { ssr: true } option")}
-      <p>The bootstrap script calls <code>mount(spec, root, serverState, { ssr: true })</code>. This tells the runtime to skip the initial re-render and bind event listeners to the existing DOM only.</p>
-      <p>This is what keeps LCP fast. The server-painted HTML is the LCP element. The JavaScript binds events without touching the DOM \u2014 no flash, no layout shift, no JS-rendered replacement.</p>
-      ${r("warning","Never set <code>{ ssr: false }</code> on a server-rendered page. It re-renders the entire DOM on mount, replacing the server-painted HTML \u2014 causing a visible flash and pushing LCP to 400\u2013600ms.")}
-
-      ${e("mount","mount()")}
-      <p>The <code>mount</code> function attaches the Pulse runtime to a DOM element:</p>
-      ${t(o(`import { mount } from '@invisibleloop/pulse/runtime'
-
-mount(
-  spec,          // the page spec
-  rootEl,        // the DOM element to mount into
-  serverState,   // window.__PULSE_SERVER__ (server data from SSR)
-  { ssr: true }  // skip re-render on first mount
-)`,"js"))}
-      <p>After mount, all <code>data-event</code> and <code>data-action</code> attributes in the DOM are wired to the spec's mutations and actions. State updates trigger a full view re-render via <code>innerHTML</code> replacement.</p>
-
-      ${e("no-hydrate","Pages without hydration")}
-      <p>Omit <code>hydrate</code> and Pulse sends zero JavaScript to the browser \u2014 no runtime overhead, no hydration cost. This is the correct default for:</p>
-      <ul>
-        <li>Documentation pages</li>
-        <li>Marketing/landing pages</li>
-        <li>Blog posts and articles</li>
-        <li>Any page with no client-side interactivity</li>
-      </ul>
-      ${r("tip",'Start without <code>hydrate</code> and only add it when actual client interactivity is needed. Many pages that appear to need JavaScript can be handled server-side with <a href="/routing">routing</a> and <a href="/server-data">server data</a>.')}
-
-      ${e("server-state","Passing server state to the client")}
-      <p>Server data fetched via <code>server.data()</code> is serialised into the page HTML as <code>window.__PULSE_SERVER__</code>. The client runtime reads this on mount, making server data available to the view during client re-renders without an additional network request.</p>
-      ${t(o(`// Emitted in the page HTML
-<script id="__PULSE_SERVER__" type="application/json">
-  {"product":{"id":1,"name":"Widget","price":9.99}}
-<\/script>`,"html"))}
-    `})};var n=document.getElementById("pulse-root");n&&!n.dataset.pulseMounted&&(n.dataset.pulseMounted="1",i(s,n,window.__PULSE_SERVER__||{},{ssr:!0}),u(n,i));var P=s;export{P as default};