@invisibleloop/pulse 0.1.28 → 0.1.29

package/docs/public/dist/state.boot-B24GUE3R.js

@@ -1,73 +0,0 @@
-import{a as s}from"./runtime-QFURDKA2.js";import{a as o,b as d,c,d as l,e,g as t,i}from"./runtime-L2HNXIHW.js";import{a as r,b as p}from"./runtime-B73WLANC.js";var{prev:u,next:m}=o("/state"),n={route:"/state",meta:{title:"State \u2014 Pulse Docs",description:"How client state is declared, initialised, and used in Pulse.",styles:["/docs.css"]},state:{},view:()=>d({currentHref:"/state",prev:u,next:m,content:`
-      ${c("State")}
-      ${l("Pulse enforces a strict one-way data flow. State is declared once in the spec, deep-cloned on mount, and changed only through mutations. Direct mutation is not possible \u2014 the framework prevents it by design.")}
-
-      ${e("declaring","Declaring state")}
-      <p>The <code>state</code> field of a spec is the initial value. Always a plain object \u2014 nested objects and arrays are supported:</p>
-      ${t(s(`export default {
-  route: '/checkout',
-  state: {
-    step: 1,
-    customer: {
-      name:  '',
-      email: '',
-    },
-    items:    [],
-    promoCode: null,
-  },
-  // ...
-}`,"js"))}
-      ${i("note","<code>state: {}</code> is always included, even on pages with no interactivity. The spec schema requires it.")}
-
-      ${e("view-receives","The view receives state")}
-      <p>The <code>view</code> function is called with the current state as its first argument. On first render this is the initial state (or state restored from <code>localStorage</code> if <code>persist</code> is set). After mutations it is the updated state:</p>
-      ${t(s("view: (state) => `\n  <div>\n    <p>Step ${state.step} of 3</p>\n    <p>Hello, ${state.customer.name || 'guest'}</p>\n    <ul>\n      ${state.items.map(item => `<li>${item.name}</li>`).join('')}\n    </ul>\n  </div>\n`","js"))}
-
-      ${e("immutability","Immutability")}
-      <p>State is never mutated directly. Mutations are pure functions that return a <em>partial</em> object to merge \u2014 the framework rejects any other pattern:</p>
-      ${t(s(`// CORRECT \u2014 return a partial update
-mutations: {
-  nextStep: (state) => ({ step: state.step + 1 }),
-}
-
-// WRONG \u2014 never mutate state directly
-mutations: {
-  nextStep: (state) => { state.step++ },   // \u2717 do not do this
-}`,"js"))}
-      <p>The runtime performs a shallow merge of the returned partial into the current state. This means top-level keys are replaced, not deep-merged:</p>
-      ${t(s(`// state = { step: 1, customer: { name: 'Alice', email: 'a@b.com' } }
-
-mutations: {
-  // Only updates step \u2014 customer is untouched
-  nextStep: (state) => ({ step: state.step + 1 }),
-
-  // Replaces the entire customer object \u2014 spread to preserve email
-  setName: (state, e) => ({
-    customer: { ...state.customer, name: e.target.value }
-  }),
-}`,"js"))}
-
-      ${e("deep-clone","Deep clone on mount")}
-      <p>When the page mounts, Pulse deep-clones <code>spec.state</code>. This guarantees:</p>
-      <ul>
-        <li>The live state and the spec's initial state are completely independent \u2014 mutations cannot corrupt the spec.</li>
-        <li>Navigating away and back resets state to the spec's initial values (unless <a href="/persist">persisted</a>).</li>
-        <li>Multiple instances of the same spec on the same page each get independent state.</li>
-      </ul>
-
-      ${e("server-state","State vs server state")}
-      <p>Pulse draws a hard boundary between <em>client state</em> (the <code>state</code> field) and <em>server state</em> (from <code>server.data()</code>). Client state lives in the browser and changes in response to mutations. Server state is resolved before render and passed to the view as its second argument \u2014 it is never exposed to the client after hydration:</p>
-      ${t(s(`view: (state, server) => \`
-  <div>
-    <h1>\${server.product.name}</h1>      <!-- server state -->
-    <p>Qty: \${state.quantity}</p>         <!-- client state -->
-  </div>
-\``,"js"))}
-      ${i("note","Server state is read-only and not available on the client after hydration. Anything that needs client interactivity belongs in <code>state</code>.")}
-
-      ${e("ssr-state","State during SSR")}
-      <p>On the server, the view is rendered with the spec's initial state. After hydration, <code>mount()</code> is called with <code>{ ssr: true }</code>, which skips the first client-side re-render and preserves the SSR-painted HTML exactly as the server sent it. This is what enables fast LCP \u2014 the initial HTML arrives from the server and the JS binds events without touching the DOM.</p>
-
-      ${e("persist-link","Persisting state")}
-      <p>State keys listed in the <a href="/persist"><code>persist</code></a> field are saved to <code>localStorage</code> and restored before the view renders on the next visit.</p>
-    `})};var a=document.getElementById("pulse-root");a&&!a.dataset.pulseMounted&&(a.dataset.pulseMounted="1",r(n,a,window.__PULSE_SERVER__||{},{ssr:!0}),p(a,r));var T=n;export{T as default};

package/docs/public/dist/store.boot-TLIB4XHH.js

@@ -1,150 +0,0 @@
-import{a as s}from"./runtime-QFURDKA2.js";import{a as n,b as d,c as l,d as h,e,g as t,h as a,i as o}from"./runtime-L2HNXIHW.js";import{a as c,b as p}from"./runtime-B73WLANC.js";var{prev:u,next:f}=n("/store"),i={route:"/store",meta:{title:"Global Store \u2014 Pulse Docs",description:"Share server-fetched data across pages with a global store in Pulse.",styles:["/docs.css"]},state:{},view:()=>d({currentHref:"/store",prev:u,next:f,content:`
-      ${l("Global Store")}
-      ${h("The global store is a single shared data layer. Declare server fetchers once in <code>pulse.store.js</code> \u2014 user profiles, settings, feature flags \u2014 and any page can access them by name. No prop drilling, no repeated fetches.")}
-
-      ${e("when-to-use","When to use the store")}
-      <p>The store is the right tool when the same server data is needed on multiple pages and it would be wasteful to redeclare the same fetcher in every spec:</p>
-      <ul>
-        <li>Current user / session \u2014 <code>store.user</code></li>
-        <li>App settings or feature flags \u2014 <code>store.settings</code></li>
-        <li>Navigation items that come from a CMS \u2014 <code>store.nav</code></li>
-        <li>Subscription or plan level \u2014 <code>store.plan</code></li>
-      </ul>
-      ${o("note",'The store has no client-side reactivity. Data is fetched on the server per request and is available to the view at mount time. For page-specific data, use <a href="/server-data"><code>spec.server</code></a> instead.')}
-
-      ${e("defining","Defining the store")}
-      <p>Create a <code>pulse.store.js</code> file at the root of your project. Export a plain object with an optional <code>state</code> (default values) and a <code>server</code> map of async fetchers:</p>
-      ${t(s(`// pulse.store.js
-export default {
-  // Default / fallback values used on the server before fetchers resolve
-  state: {
-    user:     null,
-    settings: { theme: 'dark', lang: 'en' },
-    nav:      [],
-  },
-
-  // Server fetchers \u2014 run once per request, results override state defaults
-  server: {
-    user:     async (ctx) => db.users.findByCookie(ctx.cookies.session),
-    settings: async (ctx) => db.settings.forUser(ctx.cookies.userId),
-    nav:      async ()    => cms.getNavItems(),
-  },
-}`,"js"))}
-
-      ${e("registering","Registering the store")}
-      <p>Pass your store to <code>createServer</code> via the <code>store</code> option. The store is validated at startup \u2014 bad fetchers throw before the server accepts connections:</p>
-      ${t(s(`import { createServer } from '@invisibleloop/pulse'
-import store from './pulse.store.js'
-import { dashboardSpec } from './src/pages/dashboard.js'
-import { settingsSpec }  from './src/pages/settings.js'
-
-createServer([dashboardSpec, settingsSpec], {
-  port:      3000,
-  staticDir: 'public',
-  store,                 // \u2190 register the global store
-})`,"js"))}
-
-      ${e("using","Using store data in a page")}
-      <p>Declare which store keys a page needs using the <code>store</code> field. Those keys are merged into the <code>server</code> argument of the view \u2014 alongside any page-level server data:</p>
-      ${t(s(`// src/pages/dashboard.js
-export default {
-  route:    '/dashboard',
-  store:    ['user', 'settings'],   // declare which store keys this page uses
-
-  // Page-level server data still works alongside store data
-  server: {
-    stats: async (ctx) => db.stats.forUser(ctx.store.user?.id),
-  },
-
-  state: { filter: 'week' },
-
-  view: (state, server) => \`
-    <main>
-      <h1>Hello, \${server.user?.name ?? 'there'}</h1>
-      <p>Theme: \${server.settings.theme}</p>
-      <p>Stats: \${server.stats.total} requests this \${state.filter}</p>
-    </main>
-  \`,
-}`,"js"))}
-      <p>Only the keys listed in <code>spec.store</code> are available in the view \u2014 nothing leaks from the store to pages that do not declare a dependency on it. Page-level <code>server</code> keys always win if there is a name collision with the store.</p>
-
-      ${e("ctx-store","Accessing the store in server fetchers")}
-      <p>Store data is resolved before page server fetchers run. The full resolved store state is available as <code>ctx.store</code> in any page's <code>server</code> fetcher, <code>guard</code>, and <code>meta</code> functions:</p>
-      ${t(s(`export default {
-  route: '/account',
-  store: ['user'],
-
-  // Guard can use ctx.store to check auth before fetching page data
-  guard: async (ctx) => {
-    if (!ctx.store.user) return { redirect: '/login' }
-  },
-
-  // Server fetchers receive ctx.store with the resolved store state
-  server: {
-    orders: async (ctx) => db.orders.forUser(ctx.store.user.id),
-  },
-
-  view: (state, server) => \`
-    <h1>Orders for \${server.user.name}</h1>
-  \`,
-}`,"js"))}
-
-      ${e("store-field-reference","Store field reference")}
-      ${a(["Field","Type","Description"],[["<code>state</code>","object","Default values. Used as fallbacks when a server fetcher returns <code>undefined</code> or the server key is absent."],["<code>server</code>","object of functions","Async fetchers \u2014 <code>async (ctx) => value</code>. Receive the same <code>ctx</code> as page server fetchers. Results override <code>state</code> defaults."]])}
-
-      ${e("spec-store-reference","spec.store field")}
-      ${a(["Field","Type","Description"],[["<code>store</code>","string[]","Array of store key strings to make available in the view's <code>server</code> argument. e.g. <code>['user', 'settings']</code>"]])}
-      ${o("tip","Pages that do not declare <code>store</code> receive no store data \u2014 the store never leaks to pages that do not ask for it.")}
-
-      ${e("reactivity","Reactive updates \u2014 no refresh needed")}
-      <p>When a page action changes store data, all other mounted pages that subscribe to the affected keys re-render immediately \u2014 no page refresh, no polling.</p>
-      <p>Return <code>_storeUpdate</code> from a page action's <code>onSuccess</code> to push a change into the global store:</p>
-      ${t(s(`// src/pages/settings.js
-export default {
-  route:    '/settings',
-  store:    ['settings'],
-  state:    { saved: false },
-
-  actions: {
-    saveTheme: {
-      run: async (state, server, payload) => {
-        const theme = payload.get('theme')
-        await fetch('/api/settings', { method: 'PATCH', body: payload })
-        return theme
-      },
-      onSuccess: (state, theme) => ({
-        saved: true,
-        _storeUpdate: { settings: { theme } },  // \u2190 push to global store
-      }),
-      onError: (state, err) => ({ error: err.message }),
-    },
-  },
-
-  view: (state, server) => \`
-    <form data-action="saveTheme">
-      <select name="theme">
-        <option value="dark"  \${server.settings.theme === 'dark'  ? 'selected' : ''}>Dark</option>
-        <option value="light" \${server.settings.theme === 'light' ? 'selected' : ''}>Light</option>
-      </select>
-      <button type="submit">Save</button>
-      \${state.saved ? '<p>Saved!</p>' : ''}
-    </form>
-  \`,
-}`,"js"))}
-      <p>Any other page that has <code>store: ['settings']</code> will re-render with the new theme value the moment <code>_storeUpdate</code> is dispatched \u2014 without navigating away or refreshing.</p>
-      ${o("note","<code>_storeUpdate</code> is stripped from the local page state \u2014 it is only forwarded to the store. The rest of the <code>onSuccess</code> return is merged into the page's own state as usual.")}
-
-      ${e("caching","Caching and performance")}
-      <p>Store fetchers run once per request, in parallel. They share the same request context as page server fetchers, so they can read cookies, params, and headers to scope data to the current user.</p>
-      <p>If your store data changes infrequently (nav items from a CMS, feature flags), consider adding a <code>serverTtl</code> to the relevant page spec to cache the full rendered HTML \u2014 or caching inside the fetcher itself:</p>
-      ${t(s(`// pulse.store.js \u2014 cache nav items in-process for 60 seconds
-import { createCache } from './src/lib/cache.js'
-
-const navCache = createCache(60)
-
-export default {
-  server: {
-    nav: async () => navCache.getOrFetch('nav', () => cms.getNavItems()),
-  },
-}`,"js"))}
-    `})};var r=document.getElementById("pulse-root");r&&!r.dataset.pulseMounted&&(r.dataset.pulseMounted="1",c(i,r,window.__PULSE_SERVER__||{},{ssr:!0}),p(r,c));var x=i;export{x as default};

package/docs/public/dist/streaming.boot-W2DZSMW4.js

@@ -1,80 +0,0 @@
-import{a}from"./runtime-QFURDKA2.js";import{a as i,b as d,c as l,d as c,e,g as t,h,i as r}from"./runtime-L2HNXIHW.js";import{a as n,b as m}from"./runtime-B73WLANC.js";var{prev:p,next:g}=i("/streaming"),o={route:"/streaming",meta:{title:"Streaming SSR \u2014 Pulse Docs",description:"How streaming server-side rendering works in Pulse \u2014 shell, deferred segments, and when to use it.",styles:["/docs.css"]},state:{},view:()=>d({currentHref:"/streaming",prev:p,next:g,content:`
-      ${l("Streaming SSR")}
-      ${c("Streaming SSR eliminates the tradeoff between fast paint and real content. The shell \u2014 chrome, navigation, above-the-fold layout \u2014 renders and streams immediately. Slower data-dependent segments arrive over the same connection without blocking the initial paint.")}
-
-      ${e("how-it-works","How it works")}
-      <p>Without streaming, the server waits for all data to resolve before sending any HTML \u2014 slow queries block the entire response. Pulse splits the view into a <strong>shell</strong> (sent immediately) and <strong>deferred</strong> segments (sent as placeholders, then replaced when data resolves).</p>
-      <p>Deferred segments arrive as chunks of HTML over the same connection \u2014 no extra requests, no client-side JavaScript required to swap content in.</p>
-
-      ${e("enabling","Enabling streaming")}
-      <p>To use streaming, the <code>view</code> is an <strong>object of named segment functions</strong> rather than a single function. The spec declares which segments are in the shell and which are deferred:</p>
-      ${t(a(`export default {
-  route: '/dashboard',
-  state: {},
-  server: {
-    data: async (ctx) => ({
-      user:   await auth.getUser(ctx.cookies.sessionId),  // fast
-      feed:   await db.feed.latest(),                      // slow
-      stats:  await analytics.summary(ctx.params.id),      // slow
-    }),
-  },
-  stream: {
-    shell:    ['header', 'nav'],     // rendered immediately
-    deferred: ['feed', 'stats'],     // streamed when server data resolves
-  },
-  view: {
-    header: (state, server) => \`
-      <header class="site-header">
-        <a href="/">Dashboard</a>
-        <span>Hello, \${server.user.name}</span>
-      </header>
-    \`,
-    nav: () => \`
-      <nav>
-        <a href="/dashboard">Home</a>
-        <a href="/settings">Settings</a>
-      </nav>
-    \`,
-    feed: (state, server) => \`
-      <section class="feed">
-        \${server.feed.map(item => \`<article>\${item.title}</article>\`).join('')}
-      </section>
-    \`,
-    stats: (state, server) => \`
-      <div class="stats">
-        <p>Page views: \${server.stats.views}</p>
-        <p>Conversions: \${server.stats.conversions}</p>
-      </div>
-    \`,
-  },
-}`,"js"))}
-
-      ${e("placeholders","Deferred placeholders")}
-      <p>While deferred segments are loading, Pulse renders a <code>&lt;div id="pulse-slot-[name]"&gt;</code> placeholder in their place. When the segment resolves, the rendered HTML is appended to the stream and a small inline script swaps the placeholder content.</p>
-      ${r("note","The swap is done with a tiny inline script \u2014 not a separate JS bundle. Deferred streaming works even on pages with no hydration (<code>hydrate</code> omitted).")}
-
-      ${e("server-data","Server data and streaming")}
-      <p>All <code>server.data()</code> calls resolve in a single async call before rendering begins. Streaming is about splitting the <em>view</em> \u2014 not about parallelising data fetching. For parallel data fetching, use <code>Promise.all</code> inside <code>server.data()</code>:</p>
-      ${t(a(`server: {
-  data: async (ctx) => {
-    // Fetch in parallel \u2014 both requests run concurrently
-    const [feed, stats] = await Promise.all([
-      db.feed.latest(),
-      analytics.summary(),
-    ])
-    return { feed, stats }
-  },
-}`,"js"))}
-
-      ${e("when-to-use","When to use streaming")}
-      ${h(["Scenario","Use streaming?"],[["Page with fast server data (< 20ms)","No \u2014 standard SSR is simpler and fast enough"],["Page with slow database queries","Yes \u2014 stream the shell while data loads"],["Pages with above-the-fold and below-the-fold content","Yes \u2014 shell renders above the fold immediately"],["API or raw response endpoints",'No \u2014 use <a href="/raw-responses">raw responses</a>']])}
-
-      ${e("stream-option","Server-level streaming option")}
-      <p>Streaming is enabled by default in <code>createServer</code>. Disable it globally with <code>stream: false</code>:</p>
-      ${t(a(`createServer(specs, {
-  stream: false,  // disable streaming for all specs
-})`,"js"))}
-      <p>Even with global streaming enabled, only specs that declare a <code>stream</code> field will use chunked responses. All other specs use regular buffered SSR.</p>
-
-      ${r("tip","Streaming is most beneficial on pages with large datasets or slow queries. For most pages, the speed of Pulse's synchronous rendering means streaming adds unnecessary complexity.")}
-    `})};var s=document.getElementById("pulse-root");s&&!s.dataset.pulseMounted&&(s.dataset.pulseMounted="1",n(o,s,window.__PULSE_SERVER__||{},{ssr:!0}),m(s,n));var P=o;export{P as default};

package/docs/public/dist/stripe.boot-QN3C2GEL.js

@@ -1,164 +0,0 @@
-import{a as t}from"./runtime-QFURDKA2.js";import{a as c,b as a,c as u,d as p,e as r,g as e,h as d,i as o}from"./runtime-L2HNXIHW.js";import{a as n,b as h}from"./runtime-B73WLANC.js";var{prev:l,next:m}=c("/stripe"),i={route:"/stripe",meta:{title:"Payments (Stripe) \u2014 Pulse Docs",description:"Integrating Stripe Checkout and webhooks with Pulse using actions, raw response specs, and server data fetchers.",styles:["/docs.css"]},state:{},view:()=>a({currentHref:"/stripe",prev:l,next:m,content:`
-      ${u("Payments (Stripe)")}
-      ${p("Pulse uses Stripe's hosted Checkout \u2014 no client-side Stripe JS required. Checkout sessions are created server-side in an action's <code>run</code> function. Stripe handles the payment UI entirely. Webhooks are verified and handled through a raw response spec.")}
-
-      ${o("info","Pulse has no external client-side JS. Use Stripe's hosted Checkout page (redirect flow) rather than Stripe Elements, which requires loading Stripe's client library.")}
-
-      ${r("setup","Setup")}
-      ${e(t("npm install stripe","bash"))}
-      ${e(t(`# .env
-STRIPE_SECRET_KEY=sk_test_...
-STRIPE_WEBHOOK_SECRET=whsec_...
-APP_URL=http://localhost:3000`,"bash"))}
-
-      ${r("checkout","Checkout action")}
-      <p>Create a Stripe Checkout session in an action's <code>run</code> function and redirect the browser to it.</p>
-      ${e(t(`// src/pages/pricing.js
-import Stripe from 'stripe'
-
-const stripe = new Stripe(process.env.STRIPE_SECRET_KEY)
-const APP_URL = process.env.APP_URL
-
-export default {
-  route: '/pricing',
-
-  state: { status: 'idle' },
-
-  view: (state) => \`
-    <main id="main-content">
-      <h1>Pricing</h1>
-      <form data-action="checkout">
-        <input type="hidden" name="priceId" value="price_xxxx">
-        <button type="submit">
-          \${state.status === 'loading' ? 'Redirecting\u2026' : 'Buy now'}
-        </button>
-      </form>
-      \${state.status === 'error'
-        ? '<p role="alert">Something went wrong. Please try again.</p>'
-        : ''}
-    </main>
-  \`,
-
-  actions: {
-    checkout: {
-      onStart: () => ({ status: 'loading' }),
-
-      run: async (state, serverState, formData) => {
-        const priceId = formData.get('priceId')
-
-        const session = await stripe.checkout.sessions.create({
-          mode:                'payment',
-          line_items:          [{ price: priceId, quantity: 1 }],
-          success_url:         \`\${APP_URL}/checkout/success?session={CHECKOUT_SESSION_ID}\`,
-          cancel_url:          \`\${APP_URL}/checkout/cancel\`,
-        })
-
-        return { url: session.url }
-      },
-
-      onSuccess: (state, result) => {
-        // Redirect to Stripe's hosted checkout page
-        window.location.href = result.url
-        return { status: 'redirecting' }
-      },
-
-      onError: () => ({ status: 'error' }),
-    },
-  },
-}`,"js"))}
-
-      ${r("success","Success and cancel pages")}
-      ${e(t(`// src/pages/checkout/success.js
-import Stripe from 'stripe'
-const stripe = new Stripe(process.env.STRIPE_SECRET_KEY)
-
-export default {
-  route: '/checkout/success',
-  meta: { title: 'Payment successful', styles: ['/app.css'] },
-
-  server: {
-    session: async (ctx) => {
-      const { session } = ctx.query
-      if (!session) return null
-      return stripe.checkout.sessions.retrieve(session)
-    },
-  },
-
-  state: {},
-  view: (state, server) => \`
-    <main id="main-content">
-      <h1>Payment successful</h1>
-      \${server.session
-        ? \`<p>Thank you! Your order reference is <strong>\${server.session.id}</strong>.</p>\`
-        : '<p>Thank you for your purchase.</p>'
-      }
-      <a href="/">Back to home</a>
-    </main>
-  \`,
-}`,"js"))}
-
-      ${e(t(`// src/pages/checkout/cancel.js
-export default {
-  route: '/checkout/cancel',
-  meta: { title: 'Payment cancelled', styles: ['/app.css'] },
-  state: {},
-  view: () => \`
-    <main id="main-content">
-      <h1>Payment cancelled</h1>
-      <p>No charge was made.</p>
-      <a href="/pricing">Back to pricing</a>
-    </main>
-  \`,
-}`,"js"))}
-
-      ${r("webhooks","Webhook handler")}
-      <p>Stripe sends signed POST requests to your webhook endpoint. Use a raw response spec to verify the signature and handle events. The raw body is required for signature verification \u2014 access it via <code>ctx.rawBody</code> if your server is configured to populate it, or read it from the request stream.</p>
-      ${e(t(`// src/pages/webhooks/stripe.js
-import Stripe from 'stripe'
-
-const stripe         = new Stripe(process.env.STRIPE_SECRET_KEY)
-const webhookSecret  = process.env.STRIPE_WEBHOOK_SECRET
-
-export default {
-  route:       '/webhooks/stripe',
-  contentType: 'application/json',
-
-  server: {
-    event: async (ctx) => {
-      const sig  = ctx.headers['stripe-signature']
-      const body = ctx.rawBody // raw Buffer \u2014 see note below
-
-      try {
-        return stripe.webhooks.constructEvent(body, sig, webhookSecret)
-      } catch (err) {
-        return { error: err.message }
-      }
-    },
-  },
-
-  render: (ctx, server) => {
-    if (server.event.error) {
-      ctx.setHeader('X-Webhook-Error', server.event.error)
-      return JSON.stringify({ error: server.event.error })
-    }
-
-    const event = server.event
-
-    if (event.type === 'checkout.session.completed') {
-      const session = event.data.object
-      // fulfil the order...
-    }
-
-    if (event.type === 'customer.subscription.deleted') {
-      // handle cancellation...
-    }
-
-    return JSON.stringify({ received: true })
-  },
-}`,"js"))}
-
-      ${o("warning","Stripe signature verification requires the raw request body before JSON parsing. Configure your Pulse server with <code>onRequest</code> to capture <code>ctx.rawBody</code> for the webhook route, or use a dedicated webhook path handled before Pulse's request pipeline.")}
-
-      ${r("reference","Pattern summary")}
-      ${d(["Concern","Pulse primitive"],[["Initiate checkout","<code>action.run</code> \u2014 calls Stripe API server-side, returns checkout URL"],["Redirect to Stripe","<code>action.onSuccess</code> \u2014 sets <code>window.location.href</code>"],["Confirm payment","<code>spec.server</code> on success page \u2014 retrieves session from Stripe"],["Handle webhooks","Raw response spec with <code>render</code> returning JSON"],["Verify signature","<code>spec.server</code> fetcher using <code>stripe.webhooks.constructEvent</code>"]])}
-    `})};var s=document.getElementById("pulse-root");s&&!s.dataset.pulseMounted&&(s.dataset.pulseMounted="1",n(i,s,window.__PULSE_SERVER__||{},{ssr:!0}),h(s,n));var E=i;export{E as default};