@invisibleloop/pulse 0.20.38 → 0.20.40

package/src/md/md.test.js

@@ -1,217 +0,0 @@
-/**
- * Markdown parser tests — run with: node src/md/md.test.js
- */
-import { parseMd } from './index.js'
-
-let passed = 0
-let failed = 0
-
-function test(label, fn) {
-  try {
-    fn()
-    console.log(`  ✓ ${label}`)
-    passed++
-  } catch (e) {
-    console.log(`  ✗ ${label}`)
-    console.log(`    ${e.message}`)
-    failed++
-  }
-}
-
-function assert(condition, msg) {
-  if (!condition) throw new Error(msg || 'Assertion failed')
-}
-
-// ---------------------------------------------------------------------------
-// Task lists (GFM checkboxes)
-// ---------------------------------------------------------------------------
-
-console.log('\nTask list (checkbox) rendering\n')
-
-test('unchecked item renders disabled checkbox', () => {
-  const { html } = parseMd('- [ ] Buy milk')
-  assert(html.includes('<input type="checkbox" class="ui-checkbox-input" disabled>'), `Got: ${html}`)
-  assert(html.includes('Buy milk'), `Got: ${html}`)
-})
-
-test('checked item renders checked disabled checkbox', () => {
-  const { html } = parseMd('- [x] Done')
-  assert(html.includes('<input type="checkbox" class="ui-checkbox-input" disabled checked>'), `Got: ${html}`)
-})
-
-test('uppercase X is also treated as checked', () => {
-  const { html } = parseMd('- [X] Done')
-  assert(html.includes('<input type="checkbox" class="ui-checkbox-input" disabled checked>'), `Got: ${html}`)
-})
-
-test('task list items get task-list-item class', () => {
-  const { html } = parseMd('- [ ] Item')
-  assert(html.includes('class="task-list-item"'), `Got: ${html}`)
-})
-
-test('task item checkbox is wrapped in a label for accessibility', () => {
-  const { html } = parseMd('- [ ] Buy milk')
-  assert(html.includes('class="ui-checkbox ui-checkbox--disabled"'), `Got: ${html}`)
-  assert(html.includes('<input type="checkbox" class="ui-checkbox-input" disabled>'), `Got: ${html}`)
-  assert(html.includes('<span class="ui-checkbox-box" aria-hidden="true">'), `Got: ${html}`)
-  assert(html.includes('<span class="ui-checkbox-label">Buy milk</span>'), `Got: ${html}`)
-})
-
-test('task list ul gets contains-task-list class', () => {
-  const { html } = parseMd('- [ ] Item one\n- [x] Item two')
-  assert(html.includes('class="contains-task-list"'), `Got: ${html}`)
-})
-
-test('mixed task and regular items — ul gets contains-task-list class', () => {
-  const { html } = parseMd('- [ ] Task\n- Regular item')
-  assert(html.includes('class="contains-task-list"'), `Got: ${html}`)
-})
-
-test('regular list has no task-list classes', () => {
-  const { html } = parseMd('- Apple\n- Banana')
-  assert(!html.includes('contains-task-list'), `Got: ${html}`)
-  assert(!html.includes('task-list-item'), `Got: ${html}`)
-  assert(!html.includes('checkbox'), `Got: ${html}`)
-})
-
-test('task item label text is rendered as inline markdown', () => {
-  const { html } = parseMd('- [ ] Read **important** docs')
-  assert(html.includes('<strong>important</strong>'), `Got: ${html}`)
-})
-
-test('multiple items preserve checked state independently', () => {
-  const { html } = parseMd('- [ ] Unchecked\n- [x] Checked\n- [ ] Also unchecked')
-  const checkedCount   = (html.match(/disabled checked>/g) || []).length
-  const uncheckedCount = (html.match(/disabled>/g) || []).length
-  assert(checkedCount === 1,   `Expected 1 checked, got ${checkedCount}`)
-  assert(uncheckedCount === 2, `Expected 2 unchecked, got ${uncheckedCount}`)
-})
-
-// ---------------------------------------------------------------------------
-// Frontmatter
-// ---------------------------------------------------------------------------
-
-console.log('\nFrontmatter\n')
-
-test('extracts frontmatter key/value pairs', () => {
-  const { frontmatter } = parseMd('---\ntitle: Hello World\ndate: 2026-01-01\n---\nBody text')
-  assert(frontmatter.title === 'Hello World', `Got: ${JSON.stringify(frontmatter)}`)
-  assert(frontmatter.date === '2026-01-01', `Got: ${JSON.stringify(frontmatter)}`)
-})
-
-test('body is parsed without frontmatter block', () => {
-  const { html } = parseMd('---\ntitle: Test\n---\n# Heading')
-  assert(html.includes('<h1'), `Got: ${html}`)
-  assert(!html.includes('title:'), `Got: ${html}`)
-})
-
-test('no frontmatter — returns empty object', () => {
-  const { frontmatter } = parseMd('# Just a heading')
-  assert(Object.keys(frontmatter).length === 0, `Got: ${JSON.stringify(frontmatter)}`)
-})
-
-// ---------------------------------------------------------------------------
-// Core inline / block rendering
-// ---------------------------------------------------------------------------
-
-console.log('\nInline and block rendering\n')
-
-test('bold', () => {
-  const { html } = parseMd('**bold**')
-  assert(html.includes('<strong>bold</strong>'), `Got: ${html}`)
-})
-
-test('italic', () => {
-  const { html } = parseMd('*italic*')
-  assert(html.includes('<em>italic</em>'), `Got: ${html}`)
-})
-
-test('strikethrough', () => {
-  const { html } = parseMd('~~strike~~')
-  assert(html.includes('<del>strike</del>'), `Got: ${html}`)
-})
-
-test('inline code', () => {
-  const { html } = parseMd('Use `foo()` here')
-  assert(html.includes('<code>foo()</code>'), `Got: ${html}`)
-})
-
-test('heading levels', () => {
-  const { html } = parseMd('# H1\n## H2\n### H3')
-  assert(html.includes('<h1'), `Got: ${html}`)
-  assert(html.includes('<h2'), `Got: ${html}`)
-  assert(html.includes('<h3'), `Got: ${html}`)
-})
-
-test('heading gets id from text', () => {
-  const { html } = parseMd('## My Section')
-  assert(html.includes('id="my-section"'), `Got: ${html}`)
-})
-
-test('ordered list', () => {
-  const { html } = parseMd('1. First\n2. Second')
-  assert(html.includes('<ol>'), `Got: ${html}`)
-  assert(html.includes('<li>First</li>'), `Got: ${html}`)
-})
-
-test('blockquote', () => {
-  const { html } = parseMd('> A quote')
-  assert(html.includes('<blockquote>'), `Got: ${html}`)
-})
-
-test('horizontal rule', () => {
-  const { html } = parseMd('---')
-  assert(html.includes('<hr>'), `Got: ${html}`)
-})
-
-test('link', () => {
-  const { html } = parseMd('[Pulse](https://example.com)')
-  assert(html.includes('<a href="https://example.com">Pulse</a>'), `Got: ${html}`)
-})
-
-test('HTML is escaped in inline text', () => {
-  const { html } = parseMd('A <script>alert(1)</script> here')
-  assert(!html.includes('<script>'), `Got: ${html}`)
-  assert(html.includes('&lt;script&gt;'), `Got: ${html}`)
-})
-
-// --- URL scheme sanitisation (XSS) -----------------------------------------
-
-test('link with javascript: scheme is neutralised to #', () => {
-  const { html } = parseMd('[x](javascript:alert(1))')
-  assert(!html.toLowerCase().includes('javascript:'), `Got: ${html}`)
-  assert(html.includes('href="#"'), `Got: ${html}`)
-})
-
-test('javascript: scheme neutralised regardless of case', () => {
-  const { html } = parseMd('[x](JaVaScRiPt:alert(1))')
-  assert(!html.toLowerCase().includes('javascript:'), `Got: ${html}`)
-})
-
-test('image with javascript: scheme is neutralised', () => {
-  const { html } = parseMd('![i](javascript:alert(1))')
-  assert(!html.toLowerCase().includes('javascript:'), `Got: ${html}`)
-  assert(html.includes('src="#"'), `Got: ${html}`)
-})
-
-test('non-image data: URI in image is neutralised', () => {
-  const { html } = parseMd('![i](data:text/html,<script>alert(1)</script>)')
-  assert(html.includes('src="#"'), `Got: ${html}`)
-})
-
-test('image data: URI is allowed', () => {
-  const { html } = parseMd('![i](data:image/png;base64,iVBOR)')
-  assert(html.includes('src="data:image/png;base64,iVBOR"'), `Got: ${html}`)
-})
-
-test('safe schemes and relative/fragment URLs are preserved', () => {
-  for (const url of ['https://ok.com', 'http://ok.com', '/relative', '#frag', 'mailto:a@b.com', 'tel:+15551234']) {
-    const { html } = parseMd(`[x](${url})`)
-    assert(html.includes(`href="${url}"`), `Expected ${url} preserved, got: ${html}`)
-  }
-})
-
-// ---------------------------------------------------------------------------
-
-console.log(`\n${passed + failed} tests: ${passed} passed, ${failed} failed\n`)
-if (failed > 0) process.exit(1)

package/src/runtime/image.test.js

@@ -1,111 +0,0 @@
-/**
- * Pulse — Image helper tests
- * run: node src/runtime/image.test.js
- */
-
-import { img, picture } from './image.js'
-
-let passed = 0
-let failed = 0
-
-function test(label, fn) {
-  try {
-    fn()
-    console.log(`  ✓ ${label}`)
-    passed++
-  } catch (e) {
-    console.log(`  ✗ ${label}`)
-    console.log(`    ${e.message}`)
-    failed++
-  }
-}
-
-function assert(condition, msg) {
-  if (!condition) throw new Error(msg || 'Assertion failed')
-}
-
-// ---------------------------------------------------------------------------
-
-console.log('\nimg()\n')
-
-test('renders src and alt', () => {
-  const out = img({ src: '/photo.jpg', alt: 'A photo' })
-  assert(out.includes('src="/photo.jpg"'), `Missing src: ${out}`)
-  assert(out.includes('alt="A photo"'),    `Missing alt: ${out}`)
-})
-
-test('renders width and height', () => {
-  const out = img({ src: '/x.jpg', alt: '', width: 800, height: 600 })
-  assert(out.includes('width="800"'),  `Missing width: ${out}`)
-  assert(out.includes('height="600"'), `Missing height: ${out}`)
-})
-
-test('defaults to lazy loading', () => {
-  const out = img({ src: '/x.jpg', alt: '' })
-  assert(out.includes('loading="lazy"'), `Expected lazy: ${out}`)
-  assert(!out.includes('fetchpriority="high"'), `Should not have high priority: ${out}`)
-})
-
-test('priority sets eager loading and high fetchpriority', () => {
-  const out = img({ src: '/hero.jpg', alt: 'Hero', priority: true })
-  assert(out.includes('loading="eager"'),       `Expected eager: ${out}`)
-  assert(out.includes('fetchpriority="high"'),  `Expected high fetchpriority: ${out}`)
-})
-
-test('always includes decoding="async"', () => {
-  const out = img({ src: '/x.jpg', alt: '' })
-  assert(out.includes('decoding="async"'), `Missing decoding: ${out}`)
-})
-
-test('applies class attribute', () => {
-  const out = img({ src: '/x.jpg', alt: '', class: 'card-img' })
-  assert(out.includes('class="card-img"'), `Missing class: ${out}`)
-})
-
-test('escapes alt text', () => {
-  const out = img({ src: '/x.jpg', alt: 'A "quoted" & <tagged> image' })
-  assert(!out.includes('"quoted"'),  `Should escape quotes in alt: ${out}`)
-  assert(out.includes('&amp;'),      `Should escape & in alt: ${out}`)
-})
-
-// ---------------------------------------------------------------------------
-
-console.log('\npicture()\n')
-
-test('wraps img in picture element', () => {
-  const out = picture({ src: '/x.jpg', alt: 'test', width: 100, height: 100 })
-  assert(out.includes('<picture>'),  `Missing <picture>: ${out}`)
-  assert(out.includes('</picture>'), `Missing </picture>: ${out}`)
-  assert(out.includes('<img '),      `Missing <img>: ${out}`)
-})
-
-test('includes source elements for each format', () => {
-  const out = picture({
-    src: '/x.jpg', alt: '',
-    sources: [
-      { src: '/x.avif', type: 'image/avif' },
-      { src: '/x.webp', type: 'image/webp' },
-    ]
-  })
-  assert(out.includes('image/avif'), `Missing avif source: ${out}`)
-  assert(out.includes('image/webp'), `Missing webp source: ${out}`)
-  assert(out.includes('srcset="/x.avif"'), `Missing avif srcset: ${out}`)
-})
-
-test('sources appear before fallback img', () => {
-  const out = picture({
-    src: '/x.jpg', alt: '',
-    sources: [{ src: '/x.webp', type: 'image/webp' }]
-  })
-  assert(out.indexOf('<source') < out.indexOf('<img'), `source must precede img: ${out}`)
-})
-
-test('priority propagates to inner img', () => {
-  const out = picture({ src: '/x.jpg', alt: 'Hero', priority: true, sources: [] })
-  assert(out.includes('fetchpriority="high"'), `Expected high priority in picture: ${out}`)
-})
-
-// ---------------------------------------------------------------------------
-
-console.log(`\n${passed + failed} tests: ${passed} passed, ${failed} failed\n`)
-if (failed > 0) process.exit(1)

package/src/runtime/morph.test.js

@@ -1,317 +0,0 @@
-/**
- * Pulse — morph / key-based reconciliation tests
- * run: node src/runtime/morph.test.js
- *
- * Sets up a minimal DOM shim so morphNodes runs its real code path
- * (not the innerHTML fallback). Tests verify node identity is preserved
- * across updates — the key property of key-based reconciliation.
- */
-
-// ---------------------------------------------------------------------------
-// Minimal DOM shim
-// ---------------------------------------------------------------------------
-
-class FakeText {
-  constructor(value) {
-    this.nodeType  = 3
-    this.nodeName  = '#text'
-    this.nodeValue = value
-    this.parentNode = null
-    this.nextSibling = null
-  }
-  cloneNode() { return new FakeText(this.nodeValue) }
-}
-
-class FakeElement {
-  constructor(tag) {
-    this.nodeType  = 1
-    this.nodeName  = tag.toUpperCase()
-    this._attrs    = {}
-    this._children = []
-    this.parentNode  = null
-    this.nextSibling = null
-  }
-
-  // ---- child access ----
-  get childNodes() { return this._children }
-  get lastChild()  { return this._children[this._children.length - 1] ?? null }
-
-  // ---- attributes ----
-  get attributes()        { return Object.entries(this._attrs).map(([name, value]) => ({ name, value })) }
-  getAttribute(n)         { return this._attrs[n] ?? null }
-  setAttribute(n, v)      { this._attrs[n] = v }
-  removeAttribute(n)      { delete this._attrs[n] }
-  hasAttribute(n)         { return n in this._attrs }
-
-  // ---- mutation ----
-  appendChild(node) {
-    if (node.parentNode) node.parentNode._detach(node)
-    const prev = this._children[this._children.length - 1]
-    if (prev) prev.nextSibling = node
-    node.nextSibling = null
-    node.parentNode  = this
-    this._children.push(node)
-    return node
-  }
-
-  removeChild(node) {
-    const i = this._children.indexOf(node)
-    if (i === -1) throw new Error('removeChild: node not a child')
-    this._children.splice(i, 1)
-    if (i > 0) this._children[i - 1].nextSibling = this._children[i] ?? null
-    node.parentNode  = null
-    node.nextSibling = null
-    return node
-  }
-
-  replaceChild(newNode, oldNode) {
-    const i = this._children.indexOf(oldNode)
-    if (i === -1) throw new Error('replaceChild: oldNode not a child')
-    if (newNode.parentNode) newNode.parentNode._detach(newNode)
-    this._children[i]  = newNode
-    newNode.parentNode = this
-    newNode.nextSibling = this._children[i + 1] ?? null
-    if (i > 0) this._children[i - 1].nextSibling = newNode
-    oldNode.parentNode  = null
-    oldNode.nextSibling = null
-    return oldNode
-  }
-
-  insertBefore(node, ref) {
-    if (node.parentNode) node.parentNode._detach(node)
-    if (ref === null) return this.appendChild(node)
-    const i = this._children.indexOf(ref)
-    if (i === -1) throw new Error('insertBefore: ref not a child')
-    this._children.splice(i, 0, node)
-    node.parentNode  = this
-    node.nextSibling = ref
-    if (i > 0) this._children[i - 1].nextSibling = node
-    return node
-  }
-
-  // Internal: remove without clearing siblings (used by move operations)
-  _detach(node) {
-    const i = this._children.indexOf(node)
-    if (i === -1) return
-    this._children.splice(i, 1)
-    if (i > 0) this._children[i - 1].nextSibling = this._children[i] ?? null
-    node.parentNode = null
-  }
-
-  cloneNode(deep = false) {
-    const clone = new FakeElement(this.nodeName.toLowerCase())
-    clone._attrs = { ...this._attrs }
-    if (deep) {
-      for (const child of this._children) {
-        clone.appendChild(child.cloneNode(true))
-      }
-    }
-    return clone
-  }
-
-  // ---- innerHTML (for test setup only) ----
-  set innerHTML(html) {
-    this._children = []
-    for (const node of parseHtml(html)) this.appendChild(node)
-  }
-
-  get innerHTML() {
-    return this._children.map(n => {
-      if (n.nodeType === 3) return n.nodeValue
-      const attrs = Object.entries(n._attrs).map(([k, v]) => ` ${k}="${v}"`).join('')
-      return `<${n.nodeName.toLowerCase()}${attrs}>${n.innerHTML}</${n.nodeName.toLowerCase()}>`
-    }).join('')
-  }
-
-  addEventListener() {}
-  querySelectorAll() { return [] }
-}
-
-// Minimal HTML parser — handles flat list of elements with attributes + text content
-// Sufficient for testing morph with <li data-key="x">text</li> structures
-function parseHtml(html) {
-  const nodes  = []
-  const re     = /<(\w+)((?:\s+[\w-]+=(?:"[^"]*"|'[^']*'|[^\s>]*))*)\s*>([\s\S]*?)<\/\1>|([^<]+)/g
-  let m
-  while ((m = re.exec(html)) !== null) {
-    if (m[4] !== undefined) {
-      const text = m[4]
-      if (text.trim()) nodes.push(new FakeText(text))
-    } else {
-      const el = new FakeElement(m[1])
-      const attrRe = /([\w-]+)=(?:"([^"]*)"|'([^']*)'|(\S+))/g
-      let am
-      while ((am = attrRe.exec(m[2])) !== null) {
-        el.setAttribute(am[1], am[2] ?? am[3] ?? am[4])
-      }
-      for (const child of parseHtml(m[3])) el.appendChild(child)
-      nodes.push(el)
-    }
-  }
-  return nodes
-}
-
-// Inject document shim so morph() uses real DOM path
-global.document = {
-  createElement: (tag) => new FakeElement(tag),
-}
-
-// ---------------------------------------------------------------------------
-// Import runtime (after shim is in place)
-// ---------------------------------------------------------------------------
-
-import { mount } from './index.js'
-
-// ---------------------------------------------------------------------------
-// Test runner
-// ---------------------------------------------------------------------------
-
-let passed = 0
-let failed = 0
-
-function test(label, fn) {
-  try {
-    fn()
-    console.log(`  ✓ ${label}`)
-    passed++
-  } catch (e) {
-    console.log(`  ✗ ${label}`)
-    console.log(`    ${e.message}`)
-    console.log(e.stack.split('\n')[1])
-    failed++
-  }
-}
-
-function assert(cond, msg) {
-  if (!cond) throw new Error(msg || 'Assertion failed')
-}
-
-// ---------------------------------------------------------------------------
-// Helper — mount a spec and return the root element + instance
-// ---------------------------------------------------------------------------
-
-function makeListSpec(items) {
-  return {
-    route:   '/list',
-    state:   { items },
-    view:    (s) => `<ul>${s.items.map(it => `<li data-key="${it.id}">${it.label}</li>`).join('')}</ul>`,
-    mutations: {
-      setItems: (_, items) => ({ items }),
-    },
-  }
-}
-
-console.log('\nKey-based morphing\n')
-
-// ---------------------------------------------------------------------------
-
-test('initial render produces correct keyed list', () => {
-  const el = new FakeElement('div')
-  const items = [{ id: 'a', label: 'Alpha' }, { id: 'b', label: 'Beta' }]
-  mount(makeListSpec(items), el)
-
-  const ul = el.childNodes[0]
-  assert(ul.nodeName === 'UL', 'expected UL')
-  assert(ul.childNodes.length === 2, `expected 2 children, got ${ul.childNodes.length}`)
-  assert(ul.childNodes[0].getAttribute('data-key') === 'a', 'first key should be a')
-  assert(ul.childNodes[1].getAttribute('data-key') === 'b', 'second key should be b')
-})
-
-test('removing an item removes only that node', () => {
-  const el = new FakeElement('div')
-  const items = [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }, { id: 'c', label: 'C' }]
-  const instance = mount(makeListSpec(items), el)
-
-  const ul    = el.childNodes[0]
-  const nodeA = ul.childNodes[0]
-  const nodeC = ul.childNodes[2]
-
-  instance.dispatch('setItems', [{ id: 'a', label: 'A' }, { id: 'c', label: 'C' }])
-
-  assert(ul.childNodes.length === 2, `expected 2 children after remove, got ${ul.childNodes.length}`)
-  assert(ul.childNodes[0] === nodeA, 'node A should be the same object (not recreated)')
-  assert(ul.childNodes[1] === nodeC, 'node C should be the same object (not recreated)')
-})
-
-test('reordering moves nodes without recreating them', () => {
-  const el = new FakeElement('div')
-  const items = [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }, { id: 'c', label: 'C' }]
-  const instance = mount(makeListSpec(items), el)
-
-  const ul    = el.childNodes[0]
-  const nodeA = ul.childNodes[0]
-  const nodeB = ul.childNodes[1]
-  const nodeC = ul.childNodes[2]
-
-  instance.dispatch('setItems', [{ id: 'c', label: 'C' }, { id: 'a', label: 'A' }, { id: 'b', label: 'B' }])
-
-  assert(ul.childNodes.length === 3, 'length unchanged after reorder')
-  assert(ul.childNodes[0] === nodeC, 'C should now be first (same node)')
-  assert(ul.childNodes[1] === nodeA, 'A should now be second (same node)')
-  assert(ul.childNodes[2] === nodeB, 'B should now be third (same node)')
-})
-
-test('inserting an item at the start preserves existing nodes', () => {
-  const el = new FakeElement('div')
-  const items = [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }]
-  const instance = mount(makeListSpec(items), el)
-
-  const ul    = el.childNodes[0]
-  const nodeA = ul.childNodes[0]
-  const nodeB = ul.childNodes[1]
-
-  instance.dispatch('setItems', [{ id: 'x', label: 'X' }, { id: 'a', label: 'A' }, { id: 'b', label: 'B' }])
-
-  assert(ul.childNodes.length === 3, `expected 3 children, got ${ul.childNodes.length}`)
-  assert(ul.childNodes[0].getAttribute('data-key') === 'x', 'new node X at index 0')
-  assert(ul.childNodes[1] === nodeA, 'A same node at index 1')
-  assert(ul.childNodes[2] === nodeB, 'B same node at index 2')
-})
-
-test('text content is updated when label changes on an existing node', () => {
-  const el = new FakeElement('div')
-  const items = [{ id: 'a', label: 'Alpha' }, { id: 'b', label: 'Beta' }]
-  const instance = mount(makeListSpec(items), el)
-
-  const ul    = el.childNodes[0]
-  const nodeA = ul.childNodes[0]
-
-  instance.dispatch('setItems', [{ id: 'a', label: 'UPDATED' }, { id: 'b', label: 'Beta' }])
-
-  assert(ul.childNodes[0] === nodeA, 'node A is same object (reused)')
-  assert(nodeA.innerHTML === 'UPDATED', `expected text UPDATED, got: ${nodeA.innerHTML}`)
-})
-
-test('clearing to empty list removes all nodes', () => {
-  const el = new FakeElement('div')
-  const instance = mount(makeListSpec([{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }]), el)
-
-  const ul = el.childNodes[0]
-  instance.dispatch('setItems', [])
-
-  assert(ul.childNodes.length === 0, `expected empty list, got ${ul.childNodes.length} nodes`)
-})
-
-test('unkeyed content falls back to position-based morphing', () => {
-  const el = new FakeElement('div')
-  const spec = {
-    route: '/unkeyed',
-    state: { label: 'hello' },
-    view:  (s) => `<p>${s.label}</p>`,
-    mutations: { setLabel: (_, v) => ({ label: v }) },
-  }
-  const instance = mount(spec, el)
-  instance.dispatch('setLabel', 'world')
-
-  assert(el.childNodes[0].innerHTML === 'world', `expected 'world', got: ${el.childNodes[0].innerHTML}`)
-})
-
-// ---------------------------------------------------------------------------
-
-console.log()
-if (failed > 0) {
-  console.log(`${passed} passed, ${failed} failed`)
-  process.exit(1)
-} else {
-  console.log(`${passed} passed, 0 failed`)
-}