@invisibleloop/pulse 0.1.21

package/docs/public/dist/accessibility.boot-5DVTARJU.js

@@ -0,0 +1,115 @@
+import{a}from"./runtime-QFURDKA2.js";import{a as r,b as c,c as l,d,e,g as t,h as i,i as u}from"./runtime-L2HNXIHW.js";import{a as s,b as m}from"./runtime-B73WLANC.js";var{prev:p,next:g}=r("/accessibility"),n={route:"/accessibility",meta:{title:"Accessibility \u2014 Pulse Docs",description:"Keyboard navigation, focus management, semantic HTML, and ARIA patterns in Pulse.",styles:["/docs.css"]},state:{},view:()=>c({currentHref:"/accessibility",prev:p,next:g,content:`
+      ${l("Accessibility")}
+      ${d("Pulse enforces a 100 Lighthouse Accessibility score as the baseline. The foundations \u2014 skip link, focus styles, and focus management on navigation \u2014 are provided by the framework on every page. There is nothing to configure and nothing to forget.")}
+
+      ${e("built-in","What the framework provides")}
+      ${i(["Feature","How"],[["Skip link","Injected on every page as the first focusable element. Targets <code>#main-content</code>. Visible only on focus."],["Focus styles","<code>:focus-visible</code> outline applied globally \u2014 purple, 3px, offset 2px. Suppressed for mouse users via <code>:focus:not(:focus-visible)</code>."],["Navigation focus","After client-side navigation, focus moves to <code>#main-content</code>, <code>&lt;main&gt;</code>, or <code>&lt;h1&gt;</code> \u2014 whichever is found first. Screen reader users hear the new page heading without a full reload."]])}
+      ${u("note",'The skip link targets <code>#main-content</code>. Pages use <code>&lt;main id="main-content"&gt;</code> as the content wrapper so the link resolves correctly.')}
+
+      ${e("structure","Page structure")}
+      <p>Each page view is wrapped in <code>&lt;main id="main-content"&gt;</code> with a single <code>&lt;h1&gt;</code> that describes the current page. Landmark elements communicate structure to assistive technology:</p>
+      ${t(a(`view: (state) => \`
+  <main id="main-content">
+    <h1>Page title</h1>
+    <!-- page content -->
+  </main>
+\``,"js"))}
+      ${i(["Element","Purpose"],[["<code>&lt;header&gt;</code>","Site header, logo, primary nav"],["<code>&lt;nav&gt;</code>","Navigation links \u2014 <code>aria-label</code> distinguishes multiple navs"],['<code>&lt;main id="main-content"&gt;</code>',"Primary page content \u2014 one per page"],["<code>&lt;aside&gt;</code>","Supplementary content (sidebars, related links)"],["<code>&lt;footer&gt;</code>","Site footer"]])}
+
+      ${e("interactive","Interactive elements")}
+      <p>Actions are expressed as <code>&lt;button&gt;</code> elements, navigation as <code>&lt;a href&gt;</code> links. Both are keyboard-accessible by default. <code>&lt;div&gt;</code> and <code>&lt;span&gt;</code> elements with click handlers are not reachable by keyboard:</p>
+      ${t(a(`<!-- Keyboard accessible -->
+<button data-event="toggle">Open menu</button>
+<a href="/about">About</a>
+
+<!-- Not keyboard accessible \u2014 avoid -->
+<div data-event="toggle">Open menu</div>
+<span onclick="...">About</span>`,"html"))}
+      <p>Buttons that toggle state carry <code>aria-expanded</code> or <code>aria-pressed</code> to communicate the current state to screen readers:</p>
+      ${t(a(`view: (state) => \`
+  <button data-event="toggleMenu" aria-expanded="\${state.menuOpen}">
+    Menu
+  </button>
+  \${state.menuOpen ? \`<nav>...</nav>\` : ''}
+\``,"js"))}
+
+      ${e("focus","Focus management")}
+      <p>When a modal or dialog opens, focus moves inside it. When it closes, focus returns to the element that opened it. Since Pulse updates the DOM via morphing rather than a full replacement, the triggering element stays in the DOM and receives focus back naturally.</p>
+      <p>The <code>autofocus</code> attribute on the first interactive element inside newly revealed content moves focus there after the DOM update \u2014 no JavaScript required:</p>
+      ${t(a(`view: (state) => \`
+  <button data-event="openDialog">Delete item</button>
+
+  \${state.dialogOpen ? \`
+    <div role="dialog" aria-modal="true" aria-labelledby="dialog-title">
+      <h2 id="dialog-title">Confirm deletion</h2>
+      <p>This cannot be undone.</p>
+      <button autofocus data-event="confirmDelete">Delete</button>
+      <button data-event="closeDialog">Cancel</button>
+    </div>
+  \` : ''}
+\``,"js"))}
+
+      ${e("live-regions","Dynamic content announcements")}
+      <p>State changes that produce status messages \u2014 loading indicators, confirmations, validation errors \u2014 are wrapped in live regions so screen readers announce them without a page reload:</p>
+      ${i(["Role","Politeness","Used for"],[['<code>role="status"</code>',"Polite \u2014 waits for the user to finish","Loading states, success messages, counts"],['<code>role="alert"</code>',"Assertive \u2014 interrupts immediately","Validation errors, destructive confirmations"]])}
+      ${t(a(`view: (state) => \`
+  <form data-action="submit">
+    <!-- fields -->
+    <button type="submit" \${state.status === 'loading' ? 'disabled' : ''}>
+      \${state.status === 'loading' ? 'Saving\u2026' : 'Save'}
+    </button>
+  </form>
+
+  \${state.status === 'loading' ? \`
+    <p role="status">Saving\u2026</p>
+  \` : ''}
+
+  \${state.errors.length ? \`
+    <div role="alert">
+      \${state.errors.map(e => \`<p>\${e.message}</p>\`).join('')}
+    </div>
+  \` : ''}
+\``,"js"))}
+
+      ${e("forms","Forms")}
+      <p>Form controls are paired with <code>&lt;label&gt;</code> elements. Error messages are linked to their input via <code>aria-describedby</code> so screen readers announce them when the field receives focus:</p>
+      ${t(a(`<form data-action="submit">
+  <div class="field">
+    <label for="email">Email</label>
+    <input
+      id="email"
+      name="email"
+      type="email"
+      required
+      aria-describedby="\${state.emailError ? 'email-error' : ''}"
+    >
+    \${state.emailError
+      ? \`<p id="email-error" role="alert">\${state.emailError}</p>\`
+      : ''}
+  </div>
+
+  <fieldset>
+    <legend>Notification preferences</legend>
+    <label><input type="checkbox" name="email-notifs"> Email</label>
+    <label><input type="checkbox" name="sms-notifs"> SMS</label>
+  </fieldset>
+
+  <button type="submit">Submit</button>
+</form>`,"html"))}
+
+      ${e("images","Images")}
+      <p>Decorative images carry <code>alt=""</code> so screen readers skip them. Informative images have descriptive alt text. Icon-only buttons are labelled with <code>aria-label</code>, with the icon marked <code>aria-hidden="true"</code>:</p>
+      ${t(a(`<!-- Informative image -->
+<img src="/team.jpg" alt="The Pulse team at the 2025 offsite" width="800" height="450">
+
+<!-- Decorative image -->
+<img src="/divider.svg" alt="" width="600" height="4">
+
+<!-- Icon-only button -->
+<button aria-label="Close">
+  <svg aria-hidden="true" focusable="false">...</svg>
+</button>`,"html"))}
+
+      ${e("lighthouse","Lighthouse score")}
+      <p>Every page is expected to score 100 on Lighthouse Accessibility. Run <code>/pulse-report</code> after every new page or significant change. Regressions \u2014 contrast failures, missing labels, unreachable controls \u2014 are caught before they reach users.</p>
+    `})};var o=document.getElementById("pulse-root");o&&!o.dataset.pulseMounted&&(o.dataset.pulseMounted="1",s(n,o,window.__PULSE_SERVER__||{},{ssr:!0}),m(o,s));var k=n;export{k as default};

package/docs/public/dist/actions.boot-P66HKQEM.js

@@ -0,0 +1,164 @@
+import{a as o}from"./runtime-QFURDKA2.js";import{a as i,b as d,c,d as l,e,g as t,h as u,i as a}from"./runtime-L2HNXIHW.js";import{a as s,b as m}from"./runtime-B73WLANC.js";var{prev:p,next:f}=i("/actions"),n={route:"/actions",meta:{title:"Actions \u2014 Pulse Docs",description:"Async operations in Pulse \u2014 lifecycle, FormData, error handling.",styles:["/docs.css"]},state:{},view:()=>d({currentHref:"/actions",prev:p,next:f,content:`
+      ${c("Actions")}
+      ${l("Actions handle async operations with an enforced lifecycle. The order of steps \u2014 capture inputs, validate, run, succeed or fail \u2014 is fixed. Skipping validation or running async work before showing a loading state is not possible within the action structure.")}
+
+      ${e("lifecycle","The action lifecycle")}
+      <p>When a form with <code>data-action</code> is submitted, Pulse runs the action through a fixed sequence of steps:</p>
+      ${t(o(`onStart(state, formData)
+  \u2193  (optional) validate \u2014 checks spec.validation rules
+run(state, serverState, formData)
+  \u2193  success           \u2193  error
+onSuccess(state, payload)   onError(state, err)`,"bash"))}
+      <p>Each step triggers a view re-render, so the UI always reflects the current state \u2014 loading, validated, succeeded, or failed. The sequence cannot be reordered.</p>
+
+      ${e("defining","Defining an action")}
+      ${t(o(`export default {
+  route: '/contact',
+  state: {
+    status: 'idle',   // 'idle' | 'loading' | 'success' | 'error'
+    errors: [],
+  },
+  validation: {
+    'fields.name':  { required: true, minLength: 2 },
+    'fields.email': { required: true, format: 'email' },
+    'fields.message': { required: true, minLength: 10 },
+  },
+  actions: {
+    submit: {
+      // 1. Immediately update state \u2014 show loading indicator
+      onStart: (state, formData) => ({
+        status: 'loading',
+        errors: [],
+        // Capture form values into state before validation runs
+        fields: {
+          name:    formData.get('name'),
+          email:   formData.get('email'),
+          message: formData.get('message'),
+        },
+      }),
+
+      // 2. Run spec.validation before proceeding to run()
+      validate: true,
+
+      // 3. Perform the async work
+      run: async (state, serverState, formData) => {
+        const res = await fetch('/api/contact', {
+          method:  'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body:    JSON.stringify(Object.fromEntries(formData)),
+        })
+        if (!res.ok) throw new Error('Request failed')
+        return res.json()
+      },
+
+      // 4a. Success
+      onSuccess: (state, payload) => ({
+        status: 'success',
+        errors: [],
+      }),
+
+      // 4b. Error \u2014 payload may have validation errors
+      onError: (state, err) => ({
+        status: 'error',
+        errors: err?.validation ?? [{ message: err.message }],
+      }),
+    },
+  },
+}`,"js"))}
+
+      ${e("binding","Binding actions to forms")}
+      <p>A <code>data-action</code> attribute on a <code>&lt;form&gt;</code> element binds it to an action. When the form is submitted, Pulse creates a <code>FormData</code> object from the form's inputs and passes it through the action lifecycle:</p>
+      ${t(o(`<form data-action="submit">
+  <input name="name"    type="text"  placeholder="Your name">
+  <input name="email"   type="email" placeholder="Email">
+  <textarea name="message" placeholder="Message"></textarea>
+  <button type="submit">Send</button>
+</form>`,"html"))}
+      ${a("note","Pulse intercepts and prevents the default form submission. The action lifecycle is fully in control of what happens with the data \u2014 no manual <code>event.preventDefault()</code> needed.")}
+
+      ${e("on-start","onStart")}
+      <p><code>onStart(state, formData)</code> runs synchronously as soon as the form is submitted, before any async work begins. It sets a loading state, captures form values into state so validation can check them, and clears previous errors.</p>
+      ${a("warning","<code>onStart</code> runs <strong>before</strong> validation. <code>FormData</code> values are captured into state first, because the HTML re-renders (destroying the form inputs) once validation runs. All form values are captured here so validation can read them from state via dot-paths.")}
+
+      ${e("validate","validate")}
+      <p>Set <code>validate: true</code> to run the spec's <a href="/validation">validation rules</a> after <code>onStart</code>. If validation fails, <code>onError</code> is called immediately \u2014 <code>run</code> is never reached. Async work cannot execute against invalid input.</p>
+      ${t(o(`// Validation error structure
+{
+  message:    'Validation failed',
+  validation: [
+    { field: 'fields.email', rule: 'format', message: 'Must be a valid email' },
+    { field: 'fields.name',  rule: 'required', message: 'Required' },
+  ]
+}`,"js"))}
+      <p>Access the errors in <code>onError</code>:</p>
+      ${t(o(`onError: (state, err) => ({
+  status: 'error',
+  errors: err?.validation ?? [{ message: err.message }],
+})`,"js"))}
+
+      ${e("run","run")}
+      <p><code>run(state, serverState, formData)</code> is where the async work happens. Throw or reject to trigger <code>onError</code>. The return value is passed to <code>onSuccess</code> as <code>payload</code>.</p>
+      ${t(o(`run: async (state, serverState, formData) => {
+  const res = await fetch('/api/submit', {
+    method: 'POST',
+    body:   formData,
+  })
+  if (!res.ok) {
+    const err = await res.json()
+    throw Object.assign(new Error('Server error'), err)
+  }
+  return res.json()   // \u2192 onSuccess payload
+},`,"js"))}
+
+      ${e("on-success","onSuccess")}
+      <p><code>onSuccess(state, payload)</code> receives the current state and whatever <code>run</code> returned. Return a partial state update:</p>
+      ${t(o(`onSuccess: (state, payload) => ({
+  status: 'success',
+  userId: payload.id,
+})`,"js"))}
+
+      ${e("on-error","onError")}
+      <p><code>onError(state, err)</code> receives the current state and the thrown error. Return a partial state update to surface the error in the view:</p>
+      ${t(o(`onError: (state, err) => ({
+  status: 'error',
+  errors: err?.validation ?? [{ message: err.message }],
+})`,"js"))}
+
+      ${e("toast","Toast notifications")}
+      <p>Return <code>_toast</code> from any action hook to show a notification. It is stripped from spec state automatically \u2014 it never appears in <code>getState()</code> or the view.</p>
+      ${t(o(`onSuccess: (state, payload) => ({
+  status:  'success',
+  _toast:  { message: 'Saved successfully', variant: 'success' },
+}),
+
+onError: (state, err) => ({
+  status:  'error',
+  errors:  err?.validation ?? [{ message: err.message }],
+  _toast:  { message: 'Something went wrong', variant: 'error' },
+}),`,"js"))}
+      <p><code>_toast</code> works in <code>onStart</code>, <code>onSuccess</code>, and <code>onError</code>, and also in mutations. The toast container is injected into <code>document.body</code> once and survives client-side navigations.</p>
+      ${u(["Option","Type","Default",""],[["<code>message</code>","string","\u2014","Required. The notification text."],["<code>variant</code>","<code>success | error | warning | info</code>","<code>info</code>",""],["<code>duration</code>","number (ms)","<code>4000</code>","Auto-dismiss delay. <code>0</code> = sticky until dismissed."]])}
+
+      ${e("store-update","Pushing to the global store")}
+      <p>Return <code>_storeUpdate</code> from <code>onSuccess</code> to push a partial update into the <a href="/store">global store</a>. Every mounted page that subscribes to the updated keys re-renders immediately \u2014 no navigation, no polling.</p>
+      ${t(o(`onSuccess: (state, theme) => ({
+  saved:        true,
+  _storeUpdate: { settings: { theme } },   // \u2190 merged into global store state
+}),`,"js"))}
+      <p><code>_storeUpdate</code> is stripped from the page's own state \u2014 only the rest of the return object is merged into local state as usual. See <a href="/store">Global Store</a> for the full store API.</p>
+
+      ${e("rendering-errors","Rendering errors in the view")}
+      ${t(o(`view: (state) => \`
+  <form data-action="submit">
+    \${state.errors.map(e => \`
+      <p class="error">
+        \${e.field ? \`<strong>\${e.field}:</strong> \` : ''}\${e.message}
+      </p>
+    \`).join('')}
+    <!-- ... form fields ... -->
+    <button \${state.status === 'loading' ? 'disabled' : ''}>
+      \${state.status === 'loading' ? 'Sending\u2026' : 'Send'}
+    </button>
+  </form>
+\``,"js"))}
+    `})};var r=document.getElementById("pulse-root");r&&!r.dataset.pulseMounted&&(r.dataset.pulseMounted="1",s(n,r,window.__PULSE_SERVER__||{},{ssr:!0}),m(r,s));var $=n;export{$ as default};

package/docs/public/dist/auth.boot-IMAJAUPH.js

@@ -0,0 +1,140 @@
+import{a as o}from"./runtime-QFURDKA2.js";import{a as i,b as u,c as d,d as h,e,g as t,h as s,i as n}from"./runtime-L2HNXIHW.js";import{a as c,b as l}from"./runtime-B73WLANC.js";var{prev:p,next:A}=i("/auth"),a={route:"/auth",meta:{title:"Auth (Auth0) \u2014 Pulse Docs",description:"Integrating Auth0 OAuth authentication with Pulse using guard functions, ctx.setCookie, and raw response specs.",styles:["/docs.css"]},state:{},view:()=>u({currentHref:"/auth",prev:p,next:A,content:`
+      ${d("Auth (Auth0)")}
+      ${h("Pulse integrates with Auth0 \u2014 and any OAuth 2.0 provider \u2014 using plain HTTP redirects and a token exchange. No client-side auth SDK is required. Protected routes enforce access through <code>guard</code>, which runs before any data fetcher can execute.")}
+
+      ${n("info","No Auth0 SDK required. The OAuth flow is plain HTTP redirects and a token exchange fetch \u2014 no client-side library needed.")}
+
+      ${e("setup","Setup")}
+      <p>Register your application in Auth0 and note your credentials. Store them in environment variables \u2014 never hardcode them in specs.</p>
+      ${t(o(`# .env
+AUTH0_DOMAIN=your-tenant.auth0.com
+AUTH0_CLIENT_ID=your_client_id
+AUTH0_CLIENT_SECRET=your_client_secret
+AUTH0_CALLBACK_URL=http://localhost:3000/auth/callback`,"bash"))}
+
+      ${e("login","Login route")}
+      <p>The login route is a raw response spec that redirects the browser to Auth0's authorization endpoint.</p>
+      ${t(o(`// src/pages/auth/login.js
+const {
+  AUTH0_DOMAIN, AUTH0_CLIENT_ID, AUTH0_CALLBACK_URL
+} = process.env
+
+export default {
+  route: '/auth/login',
+  contentType: 'text/html',
+
+  render: (ctx) => {
+    const params = new URLSearchParams({
+      response_type: 'code',
+      client_id:     AUTH0_CLIENT_ID,
+      redirect_uri:  AUTH0_CALLBACK_URL,
+      scope:         'openid profile email',
+      state:         crypto.randomUUID(),
+    })
+    ctx.setHeader('Location', \`https://\${AUTH0_DOMAIN}/authorize?\${params}\`)
+    return { redirect: \`https://\${AUTH0_DOMAIN}/authorize?\${params}\` }
+  },
+}`,"js"))}
+
+      ${e("callback","Callback route")}
+      <p>Auth0 redirects back to <code>/auth/callback</code> with a <code>code</code> query parameter. The server exchanges it for tokens, sets a session cookie, and redirects to the app.</p>
+      ${t(o(`// src/pages/auth/callback.js
+const {
+  AUTH0_DOMAIN, AUTH0_CLIENT_ID,
+  AUTH0_CLIENT_SECRET, AUTH0_CALLBACK_URL
+} = process.env
+
+export default {
+  route: '/auth/callback',
+  contentType: 'text/html',
+
+  server: {
+    session: async (ctx) => {
+      const { code } = ctx.query
+      if (!code) return null
+
+      // Exchange auth code for tokens
+      const res = await fetch(\`https://\${AUTH0_DOMAIN}/oauth/token\`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          grant_type:    'authorization_code',
+          client_id:     AUTH0_CLIENT_ID,
+          client_secret: AUTH0_CLIENT_SECRET,
+          redirect_uri:  AUTH0_CALLBACK_URL,
+          code,
+        }),
+      })
+
+      if (!res.ok) return null
+      const { access_token, id_token } = await res.json()
+
+      // Set a secure session cookie with the access token
+      ctx.setCookie('session', access_token, {
+        httpOnly: true,
+        secure:   process.env.NODE_ENV === 'production',
+        sameSite: 'Lax',
+        maxAge:   86400, // 24 hours
+      })
+
+      return access_token
+    },
+  },
+
+  render: (ctx, server) => {
+    if (!server.session) return { redirect: '/auth/login' }
+    return { redirect: '/' }
+  },
+}`,"js"))}
+
+      ${e("logout","Logout route")}
+      <p>Clear the session cookie and redirect to Auth0's logout endpoint to invalidate the session there too.</p>
+      ${t(o(`// src/pages/auth/logout.js
+const { AUTH0_DOMAIN, AUTH0_CLIENT_ID } = process.env
+
+export default {
+  route: '/auth/logout',
+  contentType: 'text/html',
+
+  render: (ctx) => {
+    // Expire the session cookie
+    ctx.setCookie('session', '', { maxAge: 0 })
+
+    const returnTo = encodeURIComponent('http://localhost:3000')
+    return { redirect: \`https://\${AUTH0_DOMAIN}/v2/logout?client_id=\${AUTH0_CLIENT_ID}&returnTo=\${returnTo}\` }
+  },
+}`,"js"))}
+
+      ${e("guard","Protecting routes")}
+      <p>Use <code>guard</code> to verify the session token before any server data is fetched. For production, verify the JWT signature locally rather than calling Auth0 on every request.</p>
+      ${t(o(`// src/pages/dashboard.js
+export default {
+  route: '/dashboard',
+
+  guard: async (ctx) => {
+    if (!ctx.cookies.session) return { redirect: '/auth/login' }
+
+    // Optional: verify JWT signature for production
+    // const user = await verifyJwt(ctx.cookies.session)
+    // if (!user) return { redirect: '/auth/login' }
+  },
+
+  server: {
+    profile: async (ctx) => fetchUserProfile(ctx.cookies.session),
+  },
+
+  state: {},
+  view: (state, server) => \`
+    <main id="main-content">
+      <h1>Welcome, \${server.profile.name}</h1>
+    </main>
+  \`,
+}`,"js"))}
+
+      ${n("info","Guard runs before server data fetchers \u2014 if the session is invalid the profile fetch never happens.")}
+
+      ${e("ctx-reference","ctx reference")}
+      ${s(["Method","Description"],[["<code>ctx.cookies.session</code>","Read the session cookie set during OAuth callback"],["<code>ctx.setCookie(name, value, opts)</code>","Set a response cookie \u2014 used in callback and logout routes"],["<code>ctx.setHeader(name, value)</code>","Set an arbitrary response header"]])}
+
+      ${s(["setCookie option","Type","Description"],[["<code>httpOnly</code>","boolean","Prevents JS access \u2014 always use for session cookies"],["<code>secure</code>","boolean","HTTPS only \u2014 set <code>true</code> in production"],["<code>sameSite</code>",'<code>"Lax" | "Strict" | "None"</code>',"<code>Lax</code> works for most OAuth flows"],["<code>maxAge</code>","number","Lifetime in seconds \u2014 omit for session cookie"],["<code>path</code>","string","Defaults to <code>/</code>"],["<code>domain</code>","string","Scope to a domain \u2014 omit for current host"]])}
+    `})};var r=document.getElementById("pulse-root");r&&!r.dataset.pulseMounted&&(r.dataset.pulseMounted="1",c(a,r,window.__PULSE_SERVER__||{},{ssr:!0}),l(r,c));var y=a;export{y as default};

package/docs/public/dist/caching.boot-DVR6KDE7.js

@@ -0,0 +1,53 @@
+import{a as s}from"./runtime-QFURDKA2.js";import{a as i,b as n,c as l,d as h,e,g as c,h as a,i as t}from"./runtime-L2HNXIHW.js";import{a as d,b as u}from"./runtime-B73WLANC.js";var{prev:p,next:m}=i("/caching"),r={route:"/caching",meta:{title:"Caching \u2014 Pulse Docs",description:"HTTP cache headers, in-process server data caching, and asset caching in Pulse.",styles:["/docs.css"]},state:{},view:()=>n({currentHref:"/caching",prev:p,next:m,content:`
+      ${l("Caching")}
+      ${h("Pulse handles asset caching automatically \u2014 production bundles are content-hashed and served with immutable cache headers. Page caching is controlled declaratively in the spec: <code>serverTtl</code> for in-process data, <code>cache</code> for HTTP headers. Nothing is cached by default unless you declare it.")}
+
+      ${e("server-ttl","serverTtl \u2014 in-process data cache")}
+      <p><code>serverTtl</code> is a number of seconds to cache the result of <code>server.data()</code> in memory. Subsequent requests within the TTL window skip the async data fetch entirely and serve the cached result.</p>
+      ${c(s(`export default {
+  route: '/homepage',
+  serverTtl: 60,   // cache server data for 60 seconds
+  server: {
+    data: async () => ({
+      featured: await db.products.getFeatured(),
+      stats:    await analytics.getGlobalStats(),
+    }),
+  },
+}`,"js"))}
+      ${a(["Value","Behaviour"],[["<code>undefined</code> (default)","No caching \u2014 <code>server.data()</code> runs on every request"],["<code>0</code>","No caching (same as undefined)"],["<code>60</code>","Cache for 60 seconds \u2014 at most one database hit per minute"],["<code>3600</code>","Cache for 1 hour"]])}
+      ${t("note","The in-process cache is per-process and per-route. It is not shared across multiple server instances. Use a distributed cache (Redis, etc.) for cross-instance consistency.")}
+      ${t("warning","In development, setting a long <code>serverTtl</code> can mask stale data. Set it to <code>0</code> or omit it during development, and add it when deploying to production.")}
+
+      ${e("http-cache","cache \u2014 HTTP response headers")}
+      <p>The <code>cache</code> field controls the <code>Cache-Control</code> header sent with the page HTML response. This tells browsers and CDNs how to cache the response.</p>
+      ${c(s(`export default {
+  route: '/blog/:slug',
+  cache: {
+    public:               true,    // allow CDN/proxy caching
+    maxAge:               300,     // cache for 5 minutes
+    staleWhileRevalidate: 86400,   // serve stale for up to 24 hours while revalidating
+  },
+  // ...
+}`,"js"))}
+
+      ${e("cache-fields","Cache field reference")}
+      ${a(["Field","Type","Description"],[["<code>public</code>","<code>boolean</code>","If true, emits <code>public</code> \u2014 allows CDN/proxy caching. Default: <code>private</code>."],["<code>maxAge</code>","<code>number</code>","Seconds before the response is considered stale. Emits <code>max-age=N</code>."],["<code>staleWhileRevalidate</code>","<code>number</code>","Seconds to serve stale content while revalidating in the background. Emits <code>stale-while-revalidate=N</code>."]])}
+      ${c(s(`// private page \u2014 user-specific content
+cache: { public: false, maxAge: 0 }
+// \u2192 Cache-Control: private, no-store
+
+// public marketing page \u2014 cached at CDN
+cache: { public: true, maxAge: 3600, staleWhileRevalidate: 86400 }
+// \u2192 Cache-Control: public, max-age=3600, stale-while-revalidate=86400`,"js"))}
+
+      ${e("html-default","Default HTML caching")}
+      <p>By default, Pulse sends <code>Cache-Control: no-store</code> for all HTML responses. Users always see fresh content \u2014 stale HTML is never served from browser or proxy caches unless you explicitly declare a <code>cache</code> policy in the spec.</p>
+
+      ${e("asset-caching","Asset caching")}
+      <p>Static assets in <code>public/</code> receive <code>Cache-Control: max-age=3600</code> (one hour).</p>
+      <p>Production bundles in <code>public/dist/</code> receive <code>Cache-Control: public, max-age=31536000, immutable</code> (one year, immutable). This is guaranteed safe because bundle filenames include a content hash \u2014 code changes produce a new hash, and browsers fetch the updated file automatically. There is nothing to configure.</p>
+
+      ${e("dev-vs-prod","Development vs production")}
+      ${a(["Resource","Development","Production"],[["HTML pages","<code>no-store</code>","<code>no-store</code> (or your <code>cache</code> config)"],["Static assets (<code>/public/*</code>)","<code>max-age=3600</code>","<code>max-age=3600</code>"],["JS bundles (<code>/dist/*</code>)","N/A (source files served directly)","<code>immutable, max-age=31536000</code>"]])}
+      ${t("tip","For maximum performance, combine <code>serverTtl</code> for expensive database queries with a short <code>cache.maxAge</code> and a generous <code>cache.staleWhileRevalidate</code>. Users get fast responses; data stays reasonably fresh.")}
+    `})};var o=document.getElementById("pulse-root");o&&!o.dataset.pulseMounted&&(o.dataset.pulseMounted="1",d(r,o,window.__PULSE_SERVER__||{},{ssr:!0}),u(o,d));var C=r;export{C as default};

package/docs/public/dist/components--accordion.boot-3HVKMNWC.js

@@ -0,0 +1,11 @@
+import{a as i,b as a}from"./runtime-ZJ4FXT5O.js";import{Ka as c}from"./runtime-UVPXO4IR.js";import"./runtime-VMJA3Z4N.js";import"./runtime-QFURDKA2.js";import{a as n,h as r}from"./runtime-L2HNXIHW.js";import{a as o,b as s}from"./runtime-B73WLANC.js";var{prev:d,next:p}=n("/components/accordion"),t={route:"/components/accordion",meta:{title:"Accordion \u2014 Pulse Docs",description:"Accordion component for Pulse UI.",styles:["/pulse-ui.css","/docs.css"]},state:{},view:()=>a({currentHref:"/components/accordion",prev:d,next:p,name:"accordion",description:"Collapsible FAQ items built on native <code>&lt;details&gt;</code>/<code>&lt;summary&gt;</code> \u2014 no JavaScript required. The open/close animation is handled entirely by the browser.",content:`
+      ${i(c({items:[{question:"Is there a free plan?",answer:"Yes \u2014 the free plan includes up to 3 pages and community support, with no credit card required."},{question:"Can I cancel anytime?",answer:"Absolutely. There are no contracts or lock-in periods. Cancel from your account settings at any time."},{question:"Does it work on older devices?",answer:"The app supports iOS 14+ and Android 8+, covering over 97% of active devices."}]}),`accordion({
+  items: [
+    { question: 'Is there a free plan?',     answer: 'Yes \u2014 up to 3 pages, no card required.' },
+    { question: 'Can I cancel anytime?',     answer: 'No contracts. Cancel from your account.' },
+    { question: 'Works on older devices?',   answer: 'iOS 14+ and Android 8+.' },
+  ],
+})`)}
+
+      ${r(["Prop","Type","Default",""],[["<code>items</code>","array","[]","<code>{ question: string, answer: string }[]</code>"]])}
+    `})};var e=document.getElementById("pulse-root");e&&!e.dataset.pulseMounted&&(e.dataset.pulseMounted="1",o(t,e,window.__PULSE_SERVER__||{},{ssr:!0}),s(e,o));var q=t;export{q as default};

package/docs/public/dist/components--alert.boot-GCEXOZAC.js

@@ -0,0 +1,6 @@
+import{a as i,b as c}from"./runtime-ZJ4FXT5O.js";import{Ba as e}from"./runtime-UVPXO4IR.js";import"./runtime-VMJA3Z4N.js";import"./runtime-QFURDKA2.js";import{a as r}from"./runtime-L2HNXIHW.js";import{a as n,b as a}from"./runtime-B73WLANC.js";var{prev:s,next:d}=r("/components/alert"),o={route:"/components/alert",meta:{title:"Alert \u2014 Pulse Docs",description:"Alert component for Pulse UI.",styles:["/pulse-ui.css","/docs.css"]},state:{},view:()=>c({currentHref:"/components/alert",prev:s,next:d,name:"alert",description:'<code>error</code> and <code>warning</code> use <code>role="alert"</code> \u2014 screen readers announce them immediately. <code>info</code> and <code>success</code> use <code>role="status"</code> for a polite announcement.',content:`
+      ${i(e({variant:"info",content:"Your account is pending email verification."})+e({variant:"success",title:"Saved",content:"Your changes have been saved."})+e({variant:"warning",title:"Heads up",content:"This action cannot be undone."})+e({variant:"error",title:"Failed",content:"Something went wrong. Please try again."}),`alert({ variant: 'info',    content: 'Your account is pending email verification.' })
+alert({ variant: 'success', title: 'Saved',    content: 'Your changes have been saved.' })
+alert({ variant: 'warning', title: 'Heads up', content: 'This action cannot be undone.' })
+alert({ variant: 'error',   title: 'Failed',   content: escHtml(server.error) })`,{col:!0})}
+    `})};var t=document.getElementById("pulse-root");t&&!t.dataset.pulseMounted&&(t.dataset.pulseMounted="1",n(o,t,window.__PULSE_SERVER__||{},{ssr:!0}),a(t,n));var h=o;export{h as default};

package/docs/public/dist/components--app-badge.boot-DVT3GCHJ.js

@@ -0,0 +1,6 @@
+import{a as n,b as d}from"./runtime-ZJ4FXT5O.js";import{Ma as t}from"./runtime-UVPXO4IR.js";import"./runtime-VMJA3Z4N.js";import"./runtime-QFURDKA2.js";import{a as r,h as a}from"./runtime-L2HNXIHW.js";import{a as o,b as s}from"./runtime-B73WLANC.js";var{prev:i,next:l}=r("/components/app-badge"),p={route:"/components/app-badge",meta:{title:"App Badge \u2014 Pulse Docs",description:"App Badge component for Pulse UI.",styles:["/pulse-ui.css","/docs.css"]},state:{},view:()=>d({currentHref:"/components/app-badge",prev:i,next:l,name:"appBadge",description:"App Store and Google Play download buttons. Designed to sit in a <code>hero()</code> actions slot, or anywhere a download CTA is needed.",content:`
+      ${n('<div style="display:flex;gap:.75rem;flex-wrap:wrap">'+t({store:"apple",href:"#"})+t({store:"google",href:"#"})+"</div>",`appBadge({ store: 'apple',  href: appStoreUrl })
+appBadge({ store: 'google', href: playStoreUrl })`)}
+
+      ${a(["Prop","Type","Default",""],[["<code>store</code>","string","'apple'","'apple' or 'google'"],["<code>href</code>","string","'#'","Link to the app store listing"]])}
+    `})};var e=document.getElementById("pulse-root");e&&!e.dataset.pulseMounted&&(e.dataset.pulseMounted="1",o(p,e,window.__PULSE_SERVER__||{},{ssr:!0}),s(e,o));var B=p;export{B as default};

package/docs/public/dist/components--avatar.boot-PSW24EVA.js

@@ -0,0 +1,5 @@
+import{a as s,b as n}from"./runtime-ZJ4FXT5O.js";import{Da as e}from"./runtime-UVPXO4IR.js";import"./runtime-VMJA3Z4N.js";import"./runtime-QFURDKA2.js";import{a as r}from"./runtime-L2HNXIHW.js";import{a,b as i}from"./runtime-B73WLANC.js";var{prev:l,next:c}=r("/components/avatar"),o={route:"/components/avatar",meta:{title:"Avatar \u2014 Pulse Docs",description:"Avatar component for Pulse UI.",styles:["/pulse-ui.css","/docs.css"]},state:{},view:()=>n({currentHref:"/components/avatar",prev:l,next:c,name:"avatar",description:'When <code>src</code> is set, renders an <code>&lt;img&gt;</code> with <code>loading="lazy"</code>. Without <code>src</code>, shows initials derived from <code>alt</code>.',content:`
+      ${s('<div style="display:flex;gap:1rem;align-items:center">'+e({alt:"Alice Smith",size:"sm"})+e({alt:"Bob Jones",size:"md"})+e({alt:"Carol White",size:"lg"})+e({alt:"Dan Brown",size:"xl"})+"</div>",`avatar({ src: user.avatarUrl, alt: user.name, size: 'md' })
+avatar({ alt: 'Alice Smith' })          // renders initials "AS"
+avatar({ alt: 'Alice', initials: 'A' }) // explicit initials`)}
+    `})};var t=document.getElementById("pulse-root");t&&!t.dataset.pulseMounted&&(t.dataset.pulseMounted="1",a(o,t,window.__PULSE_SERVER__||{},{ssr:!0}),i(t,a));var h=o;export{h as default};

package/docs/public/dist/components--badge.boot-TYDY2RMK.js

@@ -0,0 +1,7 @@
+import{a as s,b as i}from"./runtime-ZJ4FXT5O.js";import{b as e}from"./runtime-UVPXO4IR.js";import"./runtime-VMJA3Z4N.js";import"./runtime-QFURDKA2.js";import{a as n}from"./runtime-L2HNXIHW.js";import{a as t,b as o}from"./runtime-B73WLANC.js";var{prev:l,next:d}=n("/components/badge"),r={route:"/components/badge",meta:{title:"Badge \u2014 Pulse Docs",description:"Badge component for Pulse UI.",styles:["/pulse-ui.css","/docs.css"]},state:{},view:()=>i({currentHref:"/components/badge",prev:l,next:d,name:"badge",description:"Inline status and label indicator. Five semantic variants cover the most common states.",content:`
+      ${s(e({label:"Default",variant:"default"})+" "+e({label:"Info",variant:"info"})+" "+e({label:"Success",variant:"success"})+" "+e({label:"Warning",variant:"warning"})+" "+e({label:"Error",variant:"error"}),`badge({ label: 'Default', variant: 'default' })
+badge({ label: 'Info',    variant: 'info'    })
+badge({ label: 'Success', variant: 'success' })
+badge({ label: 'Warning', variant: 'warning' })
+badge({ label: 'Error',   variant: 'error'   })`)}
+    `})};var a=document.getElementById("pulse-root");a&&!a.dataset.pulseMounted&&(a.dataset.pulseMounted="1",t(r,a,window.__PULSE_SERVER__||{},{ssr:!0}),o(a,t));var v=r;export{v as default};

package/docs/public/dist/components--banner.boot-EI5PZSZK.js

@@ -0,0 +1,7 @@
+import{a as s,b as c}from"./runtime-ZJ4FXT5O.js";import{Qa as m,Ta as t}from"./runtime-UVPXO4IR.js";import"./runtime-VMJA3Z4N.js";import"./runtime-QFURDKA2.js";import{a as r,h as a}from"./runtime-L2HNXIHW.js";import{a as e,b as i}from"./runtime-B73WLANC.js";var{prev:p,next:d}=r("/components/banner"),o={route:"/components/banner",meta:{title:"Banner \u2014 Pulse Docs",description:"Banner component for Pulse UI.",styles:["/pulse-ui.css","/docs.css"]},state:{},view:()=>c({currentHref:"/components/banner",prev:p,next:d,name:"banner",description:"Full-width announcement bar. Sits above the nav for promotions and launch announcements. The content slot accepts links and formatted text.",content:`
+      ${s(m({gap:"sm",content:t({variant:"promo",content:`\u{1F389} Chippy Bird v2.0 is out \u2014 <a href="#" style="color:inherit;text-decoration:underline">see what's new</a>`})+t({variant:"info",content:'Android support is coming soon. <a href="#" style="color:inherit;text-decoration:underline">Join the waitlist</a>'})+t({variant:"warning",content:"Scheduled maintenance Sunday 2\u20134am UTC."})}),`banner({ variant: 'promo', content:
+  '\u{1F389} v2.0 is out \u2014 ' + button({ label: "See what's new", variant: 'ghost', size: 'sm', href: '/changelog' })
+})`)}
+
+      ${a(["Prop","Type","Default",""],[["<code>content</code>","string (HTML)","\u2014","Raw HTML slot"],["<code>variant</code>","string","'info'","'info' \xB7 'promo' \xB7 'warning'"]])}
+    `})};var n=document.getElementById("pulse-root");n&&!n.dataset.pulseMounted&&(n.dataset.pulseMounted="1",e(o,n,window.__PULSE_SERVER__||{},{ssr:!0}),i(n,e));var x=o;export{x as default};

package/docs/public/dist/components--breadcrumbs.boot-SMA2E2GO.js

@@ -0,0 +1,34 @@
+import{a as r,b as d}from"./runtime-ZJ4FXT5O.js";import{pb as o}from"./runtime-UVPXO4IR.js";import"./runtime-VMJA3Z4N.js";import"./runtime-QFURDKA2.js";import{a as t,h as c}from"./runtime-L2HNXIHW.js";import{a as s,b as l}from"./runtime-B73WLANC.js";var{prev:n,next:m}=t("/components/breadcrumbs"),a={route:"/components/breadcrumbs",meta:{title:"Breadcrumbs \u2014 Pulse Docs",description:"Accessible breadcrumb navigation component for Pulse UI.",styles:["/pulse-ui.css","/docs.css"]},state:{},view:()=>d({currentHref:"/components/breadcrumbs",prev:n,next:m,name:"breadcrumbs",description:'Accessible breadcrumb navigation. The current page item renders as a <code>&lt;span&gt;</code> with <code>aria-current="page"</code>; all preceding items render as links.',content:`
+
+      <h2 class="doc-h2" id="basic">Basic</h2>
+      ${r(o({items:[{label:"Home",href:"/"},{label:"Products",href:"/products"},{label:"Sneakers"}]}),`breadcrumbs({
+  items: [
+    { label: 'Home',     href: '/' },
+    { label: 'Products', href: '/products' },
+    { label: 'Sneakers' },
+  ],
+})`)}
+
+      <h2 class="doc-h2" id="longer">Longer trail</h2>
+      ${r(o({items:[{label:"Home",href:"/"},{label:"Shop",href:"/shop"},{label:"Footwear",href:"/shop/footwear"},{label:"Sneakers",href:"/shop/footwear/sneakers"},{label:"Air Max 90"}]}),`breadcrumbs({
+  items: [
+    { label: 'Home',     href: '/' },
+    { label: 'Shop',     href: '/shop' },
+    { label: 'Footwear', href: '/shop/footwear' },
+    { label: 'Sneakers', href: '/shop/footwear/sneakers' },
+    { label: 'Air Max 90' },
+  ],
+})`)}
+
+      <h2 class="doc-h2" id="separator">Custom separator</h2>
+      ${r(o({separator:"\u203A",items:[{label:"Docs",href:"/docs"},{label:"Components",href:"/docs/components"},{label:"Breadcrumbs"}]}),`breadcrumbs({
+  separator: '\u203A',
+  items: [
+    { label: 'Docs',       href: '/docs' },
+    { label: 'Components', href: '/docs/components' },
+    { label: 'Breadcrumbs' },
+  ],
+})`)}
+
+      ${c(["Prop","Type","Default",""],[["<code>items</code>","array","[]","Array of <code>{ label, href }</code>. The last item should have no <code>href</code> \u2014 it becomes the current page."],["<code>separator</code>","string","'/'","Character rendered between items"],["<code>class</code>","string","\u2014",""]])}
+    `})};var e=document.getElementById("pulse-root");e&&!e.dataset.pulseMounted&&(e.dataset.pulseMounted="1",s(a,e,window.__PULSE_SERVER__||{},{ssr:!0}),l(e,s));var S=a;export{S as default};

package/docs/public/dist/components--button.boot-J54BQM2E.js

@@ -0,0 +1,23 @@
+import{a as t,b as s}from"./runtime-ZJ4FXT5O.js";import{E as b,H as u,a as e,f as d,x as c}from"./runtime-UVPXO4IR.js";import"./runtime-VMJA3Z4N.js";import"./runtime-QFURDKA2.js";import{a as i,h as r}from"./runtime-L2HNXIHW.js";import{a as n,b as l}from"./runtime-B73WLANC.js";var{prev:m,next:p}=i("/components/button"),a={route:"/components/button",meta:{title:"Button \u2014 Pulse Docs",description:"Button component for Pulse UI.",styles:["/pulse-ui.css","/docs.css"]},state:{},view:()=>s({currentHref:"/components/button",prev:m,next:p,name:"button",description:"Renders as <code>&lt;button&gt;</code> by default. Pass <code>href</code> to get an <code>&lt;a&gt;</code> that looks identical. All four variants are shown below.",content:`
+      ${t(e({label:"Primary",variant:"primary"})+e({label:"Secondary",variant:"secondary"})+e({label:"Ghost",variant:"ghost"})+e({label:"Danger",variant:"danger"}),`button({ label: 'Primary',   variant: 'primary'   })
+button({ label: 'Secondary', variant: 'secondary' })
+button({ label: 'Ghost',     variant: 'ghost'     })
+button({ label: 'Danger',    variant: 'danger'    })`)}
+
+      ${t(e({label:"Small",size:"sm"})+e({label:"Medium",size:"md"})+e({label:"Large",size:"lg"}),`button({ label: 'Small',  size: 'sm' })
+button({ label: 'Medium', size: 'md' })
+button({ label: 'Large',  size: 'lg' })`)}
+
+      ${t(e({label:"Download",icon:b({size:14})})+e({label:"New item",icon:c({size:14}),variant:"secondary"})+e({label:"Continue",iconAfter:d({size:14})})+e({label:"Send",iconAfter:u({size:14}),variant:"ghost"}),`import { iconDownload, iconPlus, iconArrowRight, iconSend } from '@invisibleloop/pulse/ui'
+
+button({ label: 'Download', icon: iconDownload({ size: 14 }) })
+button({ label: 'New item', icon: iconPlus({ size: 14 }),           variant: 'secondary' })
+button({ label: 'Continue', iconAfter: iconArrowRight({ size: 14 }) })
+button({ label: 'Send',     iconAfter: iconSend({ size: 14 }),      variant: 'ghost' })`)}
+
+      ${t(e({label:"Disabled",disabled:!0})+e({label:"Link",href:"/docs"})+e({label:"Submit",type:"submit",variant:"primary"}),`button({ label: 'Disabled', disabled: true })
+button({ label: 'Link',    href: '/docs'   })
+button({ label: 'Submit',  type: 'submit', variant: 'primary' })`)}
+
+      ${r(["Prop","Type","Default",""],[["<code>label</code>","string","\u2014","Visible text"],["<code>variant</code>","string","primary","primary \xB7 secondary \xB7 ghost \xB7 danger"],["<code>size</code>","string","md","sm \xB7 md \xB7 lg"],["<code>href</code>","string","\u2014","Renders <code>&lt;a&gt;</code> instead of <code>&lt;button&gt;</code>"],["<code>disabled</code>","boolean","false",""],["<code>type</code>","string","button","button \xB7 submit \xB7 reset"],["<code>icon</code>","string","\u2014","SVG HTML prepended inside"],["<code>iconAfter</code>","string","\u2014","SVG HTML appended inside"],["<code>fullWidth</code>","boolean","false",""],["<code>class</code>","string","\u2014","Extra classes appended to the element"],["<code>attrs</code>","object","{}","Extra HTML attributes (button only)"]])}
+    `})};var o=document.getElementById("pulse-root");o&&!o.dataset.pulseMounted&&(o.dataset.pulseMounted="1",n(a,o,window.__PULSE_SERVER__||{},{ssr:!0}),l(o,n));var P=a;export{P as default};