@invisibleloop/pulse 0.20.0 → 0.20.1

package/CLAUDE.md

@@ -75,8 +75,10 @@ export const mySpec = {
   //   async () => [...]  → enumerate a dynamic :param route's URLs
   sitemap: async () => (await db.posts.list()).map(p => `/blog/${p.slug}`),
 
-  // Global store keys this page subscribes to — appears in view's server arg
-  // Store mutations update all subscribed pages without a server round-trip
+  // Global store keys this page subscribes to — appears in view's server arg.
+  // The store is defined in pulse.store.js at the project root — AUTO-DISCOVERED
+  // by pulse dev/start (no registration step). Mutations update all subscribed
+  // pages without a server round-trip.
   store: ['user', 'cart'],
 
   // Initial client state — deep cloned on mount, never mutated directly

package/docs/src/pages/store.js

@@ -50,16 +50,15 @@ export default {
 }`, 'js'))}
 
       ${section('registering', 'Registering the store')}
-      <p>Pass your store to <code>createServer</code> via the <code>store</code> option. The store is validated at startup — bad fetchers throw before the server accepts connections:</p>
+      <p><strong>There is no registration step.</strong> <code>pulse dev</code> and <code>pulse start</code> auto-discover <code>pulse.store.js</code> from the project root — the same way pages are discovered from <code>src/pages/</code>. The store is loaded server-side, served to the browser for mutations, validated at startup (bad fetchers fail the boot), and hot-reloaded in dev when you edit it.</p>
+      <p>Only when you run your own server entry do you pass it manually:</p>
       ${codeBlock(highlight(`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], {
+createServer(pages, {
   port:      3000,
   staticDir: 'public',
-  store,                 // ← register the global store
+  store,                 // ← manual server entry only
 })`, 'js'))}
 
       ${section('using', 'Using store data in a page')}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invisibleloop/pulse",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "type": "module",
   "description": "AI-first frontend framework. The spec is the source of truth.",
   "license": "MIT",

package/public/.pulse-ui-version

@@ -1 +1 @@
-0.20.0
+0.20.1

package/scripts/build.js

@@ -34,7 +34,10 @@ import { extractUsedClasses, purgeCss, minifyCss } from './css-purge.js'
  *     from being shipped to and evaluated in the browser
  *   - avoids bundling errors when server imports use Node-only modules
  */
-const SERVER_ONLY_KEYS = ['server', 'meta', 'guard', 'serverTimeout', 'contentType', 'render']
+// NOTE: spec.submit is also server-only but must NOT be listed here — the key
+// scanner is line-anchored at any nesting depth, and `submit:` is the most
+// common ACTION name (actions: { submit: {…} }), which would get stripped too.
+const SERVER_ONLY_KEYS = ['server', 'meta', 'guard', 'serverTimeout', 'contentType', 'render', 'sitemap']
 
 /**
  * Pulse subpath exports that are server-only (use Node built-ins).
@@ -351,17 +354,22 @@ function scanTemplateLiteral(src, pos) {
 
 /**
  * esbuild plugin — strips server-only spec properties before bundling.
- * Only transforms files under src/pages/ to avoid touching runtime/server code.
+ * Transforms files under src/pages/ plus the global store file (pulse.store.js
+ * carries server fetchers that must never reach the browser) — never touches
+ * runtime/server code.
  *
- * @param {string} pagesDir  Absolute path to src/pages/
+ * @param {string} pagesDir         Absolute path to src/pages/
+ * @param {string|null} storePath   Absolute path to pulse.store.js, if it exists
  */
-function createStripServerPlugin(pagesDir) {
+function createStripServerPlugin(pagesDir, storePath = null) {
   return {
     name: 'pulse-strip-server',
     setup(build) {
       build.onLoad({ filter: /\.js$/ }, (args) => {
-        if (!args.path.startsWith(pagesDir + path.sep) &&
-            args.path !== pagesDir.replace(/\/$/, '') + '.js') return undefined
+        const isPage  = args.path.startsWith(pagesDir + path.sep) ||
+                        args.path === pagesDir.replace(/\/$/, '') + '.js'
+        const isStore = storePath && args.path === storePath
+        if (!isPage && !isStore) return undefined
 
         const source   = fs.readFileSync(args.path, 'utf8')
         const stripped = stripServerOnlyImports(stripServerOnlyKeys(source))
@@ -435,6 +443,11 @@ const NAVIGATE_PATH = new URL('../src/runtime/navigate.js', import.meta.url).pat
 
 const PAGES_DIR = path.join(ROOT, 'src', 'pages')
 
+// Global store — bundled into boot files (server fetchers stripped) when present
+const STORE_PATH = fs.existsSync(path.join(ROOT, 'pulse.store.js'))
+  ? path.join(ROOT, 'pulse.store.js')
+  : null
+
 const bootstrapFiles = pages.flatMap(({ filePath }) => {
   // Strip server-only keys/imports to check what's left for the client.
   // Skip specs with no view — these are API routes or raw content specs
@@ -453,15 +466,22 @@ const bootstrapFiles = pages.flatMap(({ filePath }) => {
   const relRuntime    = path.relative(TMP_DIR, RUNTIME_PATH)
   const relNavigate   = path.relative(TMP_DIR, NAVIGATE_PATH)
 
+  // Global store — when pulse.store.js exists, every boot bundle imports it and
+  // passes it to mount() so client store mutations register in production.
+  // The strip plugin removes its server fetchers from the browser bundle;
+  // esbuild's shared-chunk splitting keeps it from being duplicated per page.
+  const storeImport = STORE_PATH ? `\nimport store from '${path.relative(TMP_DIR, STORE_PATH)}'` : ''
+  const mountOpts   = STORE_PATH ? `{ ssr: true, store }` : `{ ssr: true }`
+
   fs.writeFileSync(bootstrapPath, `\
 import spec from '${relSpec}'
 import { mount } from '${relRuntime}'
-import { initNavigation } from '${relNavigate}'
+import { initNavigation } from '${relNavigate}'${storeImport}
 
 const root = document.getElementById('pulse-root')
 if (root && !root.dataset.pulseMounted) {
   root.dataset.pulseMounted = '1'
-  mount(spec, root, window.__PULSE_SERVER__ || {}, { ssr: true })
+  mount(spec, root, window.__PULSE_SERVER__ || {}, ${mountOpts})
   initNavigation(root, mount)
 }
 
@@ -488,7 +508,7 @@ const result = await esbuild.build({
   metafile:    true,
   sourcemap:   false,
   treeShaking: true,
-  plugins:     [createStripServerPlugin(PAGES_DIR)],
+  plugins:     [createStripServerPlugin(PAGES_DIR, STORE_PATH)],
   define: {
     'process.env.NODE_ENV': '"production"'
   }

package/scripts/strip-server.test.js

@@ -7,7 +7,7 @@
 // Inline the scanner functions (duplicated here to keep test self-contained)
 // ---------------------------------------------------------------------------
 
-const SERVER_ONLY_KEYS = ['server', 'meta', 'guard', 'serverTimeout', 'contentType', 'render']
+const SERVER_ONLY_KEYS = ['server', 'meta', 'guard', 'serverTimeout', 'contentType', 'render', 'sitemap']
 const SERVER_ONLY_IMPORTS = ['@invisibleloop/pulse/md']
 
 function stripServerOnlyKeys(source) {
@@ -398,5 +398,24 @@ devTest('leaves module-level constants intact',
 
 // ---------------------------------------------------------------------------
 
+console.log('\nStore + new spec fields\n')
+
+test('sitemap enumerator is stripped (server-only)',
+  `export default {\n  route: '/blog/:slug',\n  sitemap: async () => ['/blog/a'],\n  view: () => '',\n}`,
+  `export default {\n  route: '/blog/:slug',\n  view: () => '',\n}`
+)
+
+test('submit is NOT stripped — it collides with the common submit action name',
+  `export default {\n  route: '/x',\n  actions: {\n    submit: {\n      run: async () => 1,\n    },\n  },\n  view: () => '',\n}`,
+  `export default {\n  route: '/x',\n  actions: {\n    submit: {\n      run: async () => 1,\n    },\n  },\n  view: () => '',\n}`
+)
+
+test('store definition: server fetchers stripped, state and mutations survive',
+  `export default {\n  state: { basket: [] },\n  server: {\n    nav: async () => fetchNav(),\n  },\n  mutations: {\n    add: (store, item) => ({ basket: [...store.basket, item] }),\n  },\n}`,
+  `export default {\n  state: { basket: [] },\n  mutations: {\n    add: (store, item) => ({ basket: [...store.basket, item] }),\n  },\n}`
+)
+
+// ---------------------------------------------------------------------------
+
 console.log(`\n${pass + fail} tests: ${pass} passed, ${fail} failed\n`)
 if (fail > 0) process.exit(1)

package/src/agent/guide-server.md

@@ -18,12 +18,10 @@ Only declared keys are saved. Restored values that differ from the spec default
 
 The global store is a shared data layer. Server fetchers run per request; mutations run on the client and broadcast to all subscribed pages without a server round-trip.
 
-**Define the store** in `pulse.store.js`:
+**Define the store** in `pulse.store.js` at the project root — that's the whole setup. The CLI auto-discovers it (like pages in `src/pages/`), loads it server-side, serves it to the browser, and hot-reloads it on edit:
 ```js
 // pulse.store.js
 export default {
-  hydrate: '/pulse.store.js',                   // browser-importable path — required for mutations
-
   state: {                                      // default/fallback values
     user:     null,
     settings: { theme: 'dark', lang: 'en' },
@@ -45,10 +43,10 @@ export default {
 }
 ```
 
-**Register the store** in your server file:
+**No registration step is needed** with `pulse dev` / `pulse start` — `pulse.store.js` is auto-discovered. Only when you call `createServer` yourself do you pass it manually:
 ```js
 import store from './pulse.store.js'
-createServer([...specs], { store })
+createServer([...specs], { store })   // manual server entry only
 ```
 
 **Use store data in a page** — declare `spec.store` with the keys needed. They appear in the view's `server` argument:

package/src/cli/cli.test.js

@@ -105,6 +105,59 @@ for (const skill of requiredSkills) {
   })
 }
 
+// ---------------------------------------------------------------------------
+// Store auto-discovery (loadStore)
+// ---------------------------------------------------------------------------
+// Regression: pulse.store.js was documented but never loaded by the CLI —
+// dev/start servers got no store, so spec.store keys were always empty.
+
+console.log('\nStore auto-discovery\n')
+
+{
+  const { mkdtempSync, writeFileSync, rmSync } = await import('node:fs')
+  const { tmpdir } = await import('node:os')
+  const { loadStore } = await import('./discover.js')
+
+  const dir = mkdtempSync(path.join(tmpdir(), 'pulse-store-'))
+  try {
+    // No store file → null
+    const none = await loadStore(dir)
+    test('loadStore returns null when pulse.store.js is absent', () => {
+      if (none !== null) throw new Error(`Expected null, got ${JSON.stringify(none)}`)
+    })
+
+    // Valid store file → definition with browser hydrate path set
+    writeFileSync(path.join(dir, 'pulse.store.js'),
+      `export default { state: { basket: [] }, server: { nav: async () => ['Home'] }, mutations: { add: (s, i) => ({ basket: [...s.basket, i] }) } }`)
+    const def = await loadStore(dir)
+    test('loadStore loads pulse.store.js and sets the browser hydrate path', () => {
+      if (!def)                                     throw new Error('Expected a store definition')
+      if (def.hydrate !== '/pulse.store.js')        throw new Error(`Expected hydrate /pulse.store.js, got ${def.hydrate}`)
+      if (typeof def.server?.nav !== 'function')    throw new Error('server fetchers missing')
+      if (typeof def.mutations?.add !== 'function') throw new Error('mutations missing')
+      if (!Array.isArray(def.state?.basket))        throw new Error('state missing')
+    })
+
+    // Cache-busted re-import returns the edited module (dev hot reload)
+    writeFileSync(path.join(dir, 'pulse.store.js'),
+      `export default { state: { basket: [], promo: true }, mutations: {} }`)
+    const fresh = await loadStore(dir, Date.now())
+    test('loadStore cache-busts for hot reload', () => {
+      if (fresh?.state?.promo !== true) throw new Error('Expected fresh store definition after edit')
+    })
+
+    // Bad export → clear error
+    writeFileSync(path.join(dir, 'pulse.store.js'), `export default 42`)
+    let threw = false
+    try { await loadStore(dir, Date.now() + 1) } catch (e) { threw = /store object/.test(e.message) }
+    test('loadStore throws a clear error for a non-object export', () => {
+      if (!threw) throw new Error('Expected a descriptive throw for bad default export')
+    })
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+}
+
 // ---------------------------------------------------------------------------
 
 console.log(`\n${passed + failed} tests: ${passed} passed, ${failed} failed\n`)

package/src/cli/dev.js

@@ -11,7 +11,7 @@
 import path    from 'path'
 import fs      from 'fs'
 import { createServer } from '../server/index.js'
-import { loadPages }    from './discover.js'
+import { loadPages, loadStore } from './discover.js'
 import * as log         from './logger.js'
 
 // ---------------------------------------------------------------------------
@@ -109,6 +109,10 @@ const PUBLIC_DIR     = path.join(ROOT, 'public')
 
 const specs = await loadPages(ROOT)
 
+// Auto-discover the global store — pulse.store.js in the project root.
+// Mirrors page discovery; no custom server entry needed.
+const store = await loadStore(ROOT)
+
 if (specs.length === 0) {
   log.error('No pages found in src/pages/. Create a page to get started.')
   process.exit(1)
@@ -192,6 +196,9 @@ async function triggerReload(label = 'File changed') {
     try {
       const fresh = await loadPages(ROOT, now)
       updateSpecs(fresh)
+      // Hot-swap the store too — pulse.store.js edits take effect like spec edits
+      const freshStore = await loadStore(ROOT, now)
+      updateStore(freshStore)
       log.info(`${label} — specs reloaded`)
       checkUndefinedClasses(fresh)
     } catch (err) {
@@ -204,6 +211,11 @@ async function triggerReload(label = 'File changed') {
 // Watch src/ for changes to existing files (spec edits, component edits)
 fs.watch(path.join(ROOT, 'src'), { recursive: true }, () => triggerReload('File changed'))
 
+// Watch the store file — it lives in the project root, outside src/
+if (fs.existsSync(path.join(ROOT, 'pulse.store.js'))) {
+  fs.watch(path.join(ROOT, 'pulse.store.js'), () => triggerReload('Store changed'))
+}
+
 // Also watch the pages directory explicitly so macOS reliably fires on new file creation.
 // On macOS, fs.watch with recursive=true watches subdirectory contents but may not fire
 // for the parent dir entry when a brand-new file is created. Watching the dir non-recursively
@@ -227,7 +239,7 @@ const reloadScript = (nonce) => `<script nonce="${nonce}">
   })();
 </script>`
 
-const { updateSpecs } = await createServer(specs, {
+const { updateSpecs, updateStore } = await createServer(specs, {
   port:      PORT,
   stream:    true,
   staticDir: fs.existsSync(PUBLIC_DIR) ? PUBLIC_DIR : null,
@@ -235,6 +247,7 @@ const { updateSpecs } = await createServer(specs, {
   extraBody: reloadScript,
   dev:       true,
   agentMode: !!process.env.PULSE_AGENT_MODE,
+  ...(store ? { store } : {}),
   ...(_config.csp ? { csp: _config.csp } : {}),
   // Server options forwarded verbatim from pulse.config.js so dev behaves like
   // production — keep in sync with start.js PASSTHROUGH_OPTIONS
@@ -285,6 +298,11 @@ const { updateSpecs } = await createServer(specs, {
       return serveFile(filePath)
     }
 
+    // Global store — pulse.store.js lives in the project root (not src/), and the
+    // dev hydrate bootstrap imports it so client store mutations register.
+    // serveFile strips node:/server-only imports, same treatment as page specs.
+    if (url === '/pulse.store.js' && serveFile(path.join(ROOT, 'pulse.store.js'))) return false
+
     // Project source — /src/pages/, /src/components/, /src/lib/, etc.
     // Falls back to framework source for imports like /src/ui/ that sub-projects
     // resolve from relative paths (e.g. docs component pages → ../../../../src/ui/).

package/src/cli/discover.js

@@ -111,3 +111,29 @@ export async function loadPages(projectRoot, bust = 0) {
 
   return specs
 }
+
+/**
+ * Auto-discover the global store definition from pulse.store.js in the
+ * project root. Returns the store definition with `hydrate` set to its
+ * browser-importable path (used by the dev inline bootstrap), or null when
+ * the file doesn't exist.
+ *
+ * Mirrors page auto-discovery: pulse.store.js is the documented filename
+ * convention, so CLI-managed projects (pulse dev / pulse start) get the
+ * store without writing a custom server entry.
+ *
+ * @param {string} projectRoot
+ * @returns {Promise<object|null>}
+ */
+export async function loadStore(projectRoot, cacheBust = null) {
+  const storePath = path.join(projectRoot, 'pulse.store.js')
+  if (!fs.existsSync(storePath)) return null
+
+  const url = 'file://' + storePath + (cacheBust ? `?t=${cacheBust}` : '')
+  const mod = await import(url)
+  const def = mod.default
+  if (!def || typeof def !== 'object') {
+    throw new Error('pulse.store.js must export a default store object ({ state?, server?, mutations? })')
+  }
+  return { ...def, hydrate: def.hydrate || '/pulse.store.js' }
+}

package/src/cli/start.js

@@ -11,7 +11,7 @@
 import path from 'path'
 import fs   from 'fs'
 import { createServer } from '../server/index.js'
-import { loadPages }    from './discover.js'
+import { loadPages, loadStore } from './discover.js'
 
 const args    = process.argv.slice(2)
 const rootArg = args.indexOf('--root')
@@ -71,6 +71,9 @@ port = parseInt(process.env.PORT, 10) || port || 3000
 
 const specs = await loadPages(ROOT)
 
+// Auto-discover the global store — pulse.store.js in the project root
+const store = await loadStore(ROOT)
+
 if (specs.length === 0) {
   console.error('No pages found in src/pages/.')
   process.exit(1)
@@ -81,6 +84,7 @@ createServer(specs, {
   stream:       true,
   staticDir:    PUBLIC_DIR,
   defaultCache,
+  ...(store ? { store } : {}),
   ...(csp ? { csp } : {}),
   ...passthrough,
 })

package/src/runtime/ssr.js

@@ -631,11 +631,14 @@ function encode(str) {
  * bundle (i.e. resolved via the manifest) rather than a raw source file.
  * Bundles live under /dist/ and carry a content hash in their filename.
  *
- * @param {string} hydratePath
+ * Null-safe: purely server-rendered pages (no mutations/actions/persist) have
+ * no hydrate path at all — they are never bundles.
+ *
+ * @param {string|undefined} hydratePath
  * @returns {boolean}
  */
 function isBundle(hydratePath) {
-  return hydratePath.startsWith('/dist/')
+  return typeof hydratePath === 'string' && hydratePath.startsWith('/dist/')
 }
 
 /**

package/src/server/index.js

@@ -593,9 +593,13 @@ export async function createServer(entries, options = {}) {
 
   const healthPath = healthCheck === true ? '/healthz' : (healthCheck || null)
 
+  // Store definition — `let` so the dev server can hot-swap it via updateStore()
+  // when pulse.store.js changes, the same way updateSpecs() swaps page specs.
+  let storeDef = store
+
   // Validate store at startup — fail fast before the server accepts connections
-  if (store) {
-    const { valid, errors } = validateStore(store)
+  if (storeDef) {
+    const { valid, errors } = validateStore(storeDef)
     if (!valid) {
       throw new Error(`Invalid Pulse store:\n${errors.map(e => `  — ${e}`).join('\n')}`)
     }
@@ -897,8 +901,8 @@ export async function createServer(entries, options = {}) {
       // Global store — resolve once per request, attach to ctx before guard/server fetchers.
       // Use global fetcherTimeout for store fetchers; spec-level override applied below.
       ctx.fetcherTimeout = fetcherTimeout ?? null
-      if (store) {
-        ctx.store = await resolveStoreState(store, ctx)
+      if (storeDef) {
+        ctx.store = await resolveStoreState(storeDef, ctx)
       }
 
       const spec = resolveSpec(match.spec, hydrateMap)
@@ -1020,11 +1024,11 @@ export async function createServer(entries, options = {}) {
       // string path — they are small, must carry an explicit status, and POST
       // bodies are already consumed.
       if (responseStatus !== 200 || req.method === 'POST') {
-        await handleStringResponse(spec, ctx, req, res, extraBody, dev, canonicalBase, nonce, runtimeBundle, defaultCache, store, csp, faviconPath, responseStatus, livePath)
+        await handleStringResponse(spec, ctx, req, res, extraBody, dev, canonicalBase, nonce, runtimeBundle, defaultCache, storeDef, csp, faviconPath, responseStatus, livePath)
       } else if (stream) {
-        await handleStreamResponse(spec, ctx, req, res, extraBody, dev, canonicalBase, nonce, runtimeBundle, defaultCache, store, csp, faviconPath, livePath)
+        await handleStreamResponse(spec, ctx, req, res, extraBody, dev, canonicalBase, nonce, runtimeBundle, defaultCache, storeDef, csp, faviconPath, livePath)
       } else {
-        await handleStringResponse(spec, ctx, req, res, extraBody, dev, canonicalBase, nonce, runtimeBundle, defaultCache, store, csp, faviconPath, 200, livePath)
+        await handleStringResponse(spec, ctx, req, res, extraBody, dev, canonicalBase, nonce, runtimeBundle, defaultCache, storeDef, csp, faviconPath, 200, livePath)
       }
 
     } catch (err) {
@@ -1119,6 +1123,14 @@ export async function createServer(entries, options = {}) {
       notFoundSpec = newSpecs.find(s => s.route === '*') || null
       router       = buildRouter(newSpecs.filter(s => s.route !== '*'))
       allSpecs     = newSpecs
+    },
+    /** Swap the store definition at runtime (dev hot reload of pulse.store.js). */
+    updateStore(newStoreDef) {
+      if (newStoreDef) {
+        const { valid, errors } = validateStore(newStoreDef)
+        if (!valid) throw new Error(`Invalid Pulse store:\n${errors.map(e => `  — ${e}`).join('\n')}`)
+      }
+      storeDef = newStoreDef || null
     }
   }
 }

package/src/server/server.test.js

@@ -1294,6 +1294,30 @@ await test('without a "*" spec the default 404 still works', async () => {
   })
 })
 
+await test('custom 404 works in production mode (manifest with runtime bundle present)', async () => {
+  // Regression: in production the manifest sets runtimeBundle, which made
+  // wrapDocument call isBundle(spec.hydrate) — undefined for non-hydrated pages
+  // like a typical 404 spec → TypeError → 500 instead of the custom 404.
+  // Dev never hit it because runtimeBundle is '' there.
+  const prodManifest = { _runtime: '/dist/runtime-abcd1234.js' }
+  await withServer([helloSpec, notFoundPageSpec], { stream: true, manifest: prodManifest }, async (port) => {
+    const { status, body } = await get(port, '/nope')
+    assert(status === 404, `Expected 404 in production mode, got ${status}`)
+    assert(body.includes('Custom not found'), `Expected custom 404 content: ${body.slice(0, 200)}`)
+  })
+})
+
+await test('non-hydrated pages render on the buffered path in production mode', async () => {
+  // Same root cause, different surface: stream: false + production manifest
+  // crashed EVERY zero-JS page, not just the 404.
+  const prodManifest = { _runtime: '/dist/runtime-abcd1234.js' }
+  await withServer([helloSpec], { stream: false, manifest: prodManifest }, async (port) => {
+    const { status, body } = await get(port, '/hello')
+    assert(status === 200, `Expected 200, got ${status}`)
+    assert(body.includes('Hello world'), 'Expected page content')
+  })
+})
+
 // ---------------------------------------------------------------------------
 
 console.log('\nServer-side forms (spec.submit) + CSRF\n')

package/types/server.d.ts

@@ -175,6 +175,9 @@ export interface ServerInstance {
   /** Swap the spec list at runtime (used by the dev server for hot reload). */
   updateSpecs(specs: PulseSpec[]): void
 
+  /** Swap the store definition at runtime (dev hot reload of pulse.store.js). Validates; throws on a bad definition. */
+  updateStore(storeDef: PulseStoreDefinition | null): void
+
   /**
    * Broadcast a store patch to every connected live client (requires the
    * `live` option). Pages subscribed via spec.store merge the patch and