@astrale-os/adapter-cloudflare 0.1.8 → 0.1.10

package/template/client/__tests__/app.test.tsx

@@ -1,21 +1,32 @@
-import { act, cleanup, render, screen } from '@testing-library/react'
-import { afterEach, describe, expect, it } from 'vitest'
+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 
-import { App } from '../src/app'
-import { type CapturedRequest, installFakeKernel, installFakeParent, noteNode, ok } from './harness'
+import { App } from '@/app'
+import { installFakeKernel, installFakeParent, monitorNode, ok } from './harness'
 
 const KERNEL_URL = 'https://k.example.test/api'
-const KERNEL_TYPE = 'application/vnd.astrale.kernel+json'
+
+/**
+ * The router picks a view from `window.location.pathname`, so every test mounts
+ * at a known path. `replaceState` rewrites the happy-dom location without a
+ * reload. Default to the Monitor detail path; the fallback test overrides.
+ */
+function mountAt(path: string) {
+  window.history.replaceState({}, '', path)
+}
+
+beforeEach(() => {
+  mountAt('/ui/monitor')
+})
 
 afterEach(() => {
   cleanup()
 })
 
 /**
- * Let the handshake + any kernel fetch settle, flushing the resulting React
+ * Let the handshake + any kernel fetches settle, flushing the resulting React
  * state updates inside `act`. The handshake completes over a real MessagePort
- * (async hops), so a microtask isn't enough — a short timer pump is. Wrapping
- * it in `act` keeps the updates warning-free and committed before we assert.
+ * (async hops), so a microtask isn't enough — a short timer pump is.
  */
 async function flush(ms = 20) {
   await act(async () => {
@@ -23,35 +34,36 @@ async function flush(ms = 20) {
   })
 }
 
-/** Common assertions on a captured kernel request for `@<id>::get`. */
-function expectGetCall(req: CapturedRequest, nodeId: string, token: string) {
-  // POST to the kernel URL with a trailing slash added.
-  expect(req.method).toBe('POST')
-  expect(req.url).toBe(`${KERNEL_URL}/`)
-  // Bare delegation token (no "Bearer ").
-  expect(req.headers['authorization']).toBe(token)
-  // Kernel JSON envelope content type on both content-type and accept.
-  expect(req.headers['content-type']).toBe(KERNEL_TYPE)
-  expect(req.headers['accept']).toBe(KERNEL_TYPE)
-  // Envelope body shape.
-  expect(req.body.method).toBe(`@${nodeId}::get`)
-  expect(req.body.params).toEqual({})
-  expect(req.body.id).toBeTruthy()
+function handshake(targetNodeId?: string) {
+  return installFakeParent({
+    windowId: 'win-1',
+    kernelUrl: KERNEL_URL,
+    functionId: 'ui-monitor',
+    delegationToken: 'tok-A',
+    tokenExpiresAt: Date.now() + 3_600_000,
+    targetNodeId,
+  })
 }
 
-describe('ui-note view — handshake + real node render', () => {
-  it('completes the handshake, calls @<id>::get, and renders the Note', async () => {
-    const parent = installFakeParent({
-      windowId: 'win-1',
-      kernelUrl: KERNEL_URL,
-      functionId: 'ui-note',
-      delegationToken: 'tok-A',
-      tokenExpiresAt: Date.now() + 3_600_000,
-      targetNodeId: 'note-1',
+describe('monitor view (/ui/monitor)', () => {
+  it('loads the target node and renders name, url, status and latency', async () => {
+    const parent = handshake('mon-1')
+    const kernel = installFakeKernel((body) => {
+      if (body.method === '@mon-1::get') {
+        return ok(
+          monitorNode({
+            id: 'mon-1',
+            name: 'API health',
+            url: 'https://api.example.test/health',
+            status: 'up',
+            statusCode: '200',
+            latencyMs: '42',
+            lastCheckedAt: '2026-06-14T10:00:00Z',
+          }),
+        )
+      }
+      return { error: { code: 3002, message: `unexpected: ${body.method}` } }
     })
-    const kernel = installFakeKernel(() =>
-      ok(noteNode({ id: 'note-1', name: 'My first note', body: 'Hello from the kernel.' })),
-    )
 
     try {
       render(<App />)
@@ -60,113 +72,176 @@ describe('ui-note view — handshake + real node render', () => {
       // Parent observed the child's handshakeAck.
       await expect(parent.ack).resolves.toBeUndefined()
 
-      // The Note renders its title (Named.name) and body.
-      expect(screen.getByText('My first note')).toBeTruthy()
-      expect(screen.getByText('Hello from the kernel.')).toBeTruthy()
+      expect(screen.getByText('API health')).toBeTruthy()
+      // ExternalLink strips the scheme.
+      expect(screen.getByText('api.example.test/health')).toBeTruthy()
+      const badge = screen.getByText('UP')
+      expect(badge.className).toContain('status-up')
+      expect(screen.getByText('42ms')).toBeTruthy()
+      expect(screen.getByText('200')).toBeTruthy()
 
-      // Exactly one kernel call, with the verified wire shape.
+      // Exactly one kernel call, for the node load.
       expect(kernel.calls).toHaveLength(1)
-      expectGetCall(kernel.calls[0]!, 'note-1', 'tok-A')
+      expect(kernel.calls[0]!.body.method).toBe('@mon-1::get')
     } finally {
       kernel.restore()
       parent.restore()
     }
   })
 
-  it('renders the kernel error envelope on the error path', async () => {
-    const parent = installFakeParent({
-      windowId: 'win-2',
-      kernelUrl: KERNEL_URL,
-      functionId: 'ui-note',
-      delegationToken: 'tok-A',
-      tokenExpiresAt: Date.now() + 3_600_000,
-      targetNodeId: 'missing-1',
-    })
-    const kernel = installFakeKernel(() => ({
-      error: { code: 3002, message: 'Path not found' },
-    }))
+  it('renders a DOWN badge when the monitor status is down', async () => {
+    const parent = handshake('mon-d')
+    const kernel = installFakeKernel(() =>
+      ok(monitorNode({ id: 'mon-d', name: 'Down site', url: 'https://x.test', status: 'down' })),
+    )
 
     try {
       render(<App />)
       await flush()
 
-      expect(screen.getByText(/Failed to load the Note/)).toBeTruthy()
-      // The "<code>: <message>" surfaces from kernelCall.
-      expect(screen.getByText(/3002: Path not found/)).toBeTruthy()
-      expect(kernel.calls).toHaveLength(1)
+      const badge = screen.getByText('DOWN')
+      expect(badge).toBeTruthy()
+      expect(badge.className).toContain('status-down')
     } finally {
       kernel.restore()
       parent.restore()
     }
   })
 
-  it('re-fetches on a setTarget hot-swap', async () => {
-    const parent = installFakeParent({
-      windowId: 'win-3',
-      kernelUrl: KERNEL_URL,
-      functionId: 'ui-note',
-      delegationToken: 'tok-A',
-      tokenExpiresAt: Date.now() + 3_600_000,
-      targetNodeId: 'note-1',
+  it('clicks "Check now", issues @<id>::check, and reflects the refreshed status', async () => {
+    const parent = handshake('mon-1')
+    // First ::get is down; ::check mutates server-side; the post-check ::get is up.
+    let checked = false
+    const kernel = installFakeKernel((body) => {
+      if (body.method === '@mon-1::check') {
+        checked = true
+        return ok(null)
+      }
+      // @mon-1::get — reflect the pre/post-check status.
+      return ok(
+        monitorNode({
+          id: 'mon-1',
+          name: 'API health',
+          url: 'https://api.example.test/health',
+          status: checked ? 'up' : 'down',
+          statusCode: checked ? '200' : '503',
+        }),
+      )
     })
-    const kernel = installFakeKernel((body) =>
-      // Respond per-target so the swap is observable.
-      body.method === '@note-2::get'
-        ? ok(noteNode({ id: 'note-2', name: 'Second note', body: 'Swapped in.' }))
-        : ok(noteNode({ id: 'note-1', name: 'First note', body: 'Original.' })),
-    )
 
     try {
       render(<App />)
       await flush()
-      expect(screen.getByText('First note')).toBeTruthy()
+
+      // Initial load: DOWN.
+      expect(screen.getByText('DOWN')).toBeTruthy()
       expect(kernel.calls).toHaveLength(1)
+      expect(kernel.calls[0]!.body.method).toBe('@mon-1::get')
 
-      // Parent pushes a new target node.
-      parent.setTarget('note-2')
+      // Click "Check now".
+      await act(async () => {
+        fireEvent.click(screen.getByText('Check now'))
+      })
       await flush()
 
-      expect(screen.getByText('Second note')).toBeTruthy()
-      expect(screen.getByText('Swapped in.')).toBeTruthy()
+      // A ::check call was issued, then the node was re-fetched.
+      expect(kernel.calls.map((c) => c.body.method)).toEqual([
+        '@mon-1::get',
+        '@mon-1::check',
+        '@mon-1::get',
+      ])
 
-      // A second kernel call for the new node.
-      expect(kernel.calls).toHaveLength(2)
-      expectGetCall(kernel.calls[1]!, 'note-2', 'tok-A')
+      // The refreshed status renders.
+      expect(screen.getByText('UP')).toBeTruthy()
+      expect(screen.getByText('200')).toBeTruthy()
     } finally {
       kernel.restore()
       parent.restore()
     }
   })
 
-  it('uses the refreshed token for calls after ctrl:tokenRefresh', async () => {
-    const parent = installFakeParent({
-      windowId: 'win-4',
-      kernelUrl: KERNEL_URL,
-      functionId: 'ui-note',
-      delegationToken: 'tok-A',
-      tokenExpiresAt: Date.now() + 1_000,
-      targetNodeId: 'note-1',
+  it('surfaces a check failure without losing the loaded record', async () => {
+    const parent = handshake('mon-1')
+    const kernel = installFakeKernel((body) => {
+      if (body.method === '@mon-1::check') {
+        return { error: { code: 2004, message: 'Permission denied' } }
+      }
+      return ok(monitorNode({ id: 'mon-1', name: 'API health', url: 'https://x.test', status: 'up' }))
     })
+
+    try {
+      render(<App />)
+      await flush()
+
+      await act(async () => {
+        fireEvent.click(screen.getByText('Check now'))
+      })
+      await flush()
+
+      // The proper client maps the error code to a typed error, so the operator
+      // sees the clean server message (no `<code>:` prefix).
+      expect(screen.getByText(/Check failed:/)).toBeTruthy()
+      expect(screen.getByText(/Permission denied/)).toBeTruthy()
+      // The record is still shown.
+      expect(screen.getByText('API health')).toBeTruthy()
+    } finally {
+      kernel.restore()
+      parent.restore()
+    }
+  })
+
+  it('renders the kernel error on the node-load error path', async () => {
+    const parent = handshake('missing-1')
+    const kernel = installFakeKernel(() => ({ error: { code: 3002, message: 'Path not found' } }))
+
+    try {
+      render(<App />)
+      await flush()
+
+      expect(screen.getByText(/Failed to load the Monitor/)).toBeTruthy()
+      // The proper client maps NOT_FOUND (3002) to a typed error → clean message.
+      expect(screen.getByText(/Path not found/)).toBeTruthy()
+    } finally {
+      kernel.restore()
+      parent.restore()
+    }
+  })
+
+  it('re-fetches on a setTarget hot-swap', async () => {
+    const parent = handshake('mon-1')
     const kernel = installFakeKernel((body) =>
-      ok(noteNode({ id: body.method.slice(1, -5), name: 'Note', body: 'b' })),
+      body.method === '@mon-2::get'
+        ? ok(monitorNode({ id: 'mon-2', name: 'Second monitor', url: 'https://b.test', status: 'down' }))
+        : ok(monitorNode({ id: 'mon-1', name: 'First monitor', url: 'https://a.test', status: 'up' })),
     )
 
     try {
       render(<App />)
       await flush()
-      expect(kernel.calls).toHaveLength(1)
-      // First call used the handshake token.
-      expect(kernel.calls[0]!.headers['authorization']).toBe('tok-A')
+      expect(screen.getByText('First monitor')).toBeTruthy()
+      expect(screen.getByText('UP')).toBeTruthy()
+
+      // Parent pushes a new target node.
+      parent.setTarget('mon-2')
+      await flush()
+
+      expect(screen.getByText('Second monitor')).toBeTruthy()
+      expect(screen.getByText('DOWN')).toBeTruthy()
+    } finally {
+      kernel.restore()
+      parent.restore()
+    }
+  })
 
-      // Parent pushes a fresh token, then triggers a new fetch via setTarget.
-      parent.tokenRefresh('tok-B', Date.now() + 3_600_000)
-      parent.setTarget('note-9')
+  it('explains a missing target instead of a blank screen', async () => {
+    const parent = handshake(undefined)
+    const kernel = installFakeKernel(() => ok(null))
+    try {
+      render(<App />)
       await flush()
 
-      // The post-refresh call carries the NEW token.
-      expect(kernel.calls).toHaveLength(2)
-      expect(kernel.calls[1]!.body.method).toBe('@note-9::get')
-      expect(kernel.calls[1]!.headers['authorization']).toBe('tok-B')
+      expect(screen.getByText(/No target Monitor/)).toBeTruthy()
+      expect(kernel.calls).toHaveLength(0)
     } finally {
       kernel.restore()
       parent.restore()
@@ -174,15 +249,29 @@ describe('ui-note view — handshake + real node render', () => {
   })
 
   it('falls back to a standalone preview with no parent', async () => {
-    // No fake parent installed → connectShell rejects fast because
-    // window.parent === window in this realm.
+    // No fake parent → the shell sees window.parent === window and stands alone.
     const kernel = installFakeKernel(() => ok(null))
     try {
       render(<App />)
       await flush()
 
       expect(screen.getByText(/No parent shell/)).toBeTruthy()
-      // Never hit the kernel in standalone mode.
+      expect(kernel.calls).toHaveLength(0)
+    } finally {
+      kernel.restore()
+    }
+  })
+})
+
+describe('router fallback', () => {
+  it('renders "No view registered" for an unregistered path', async () => {
+    mountAt('/ui/nope')
+    const kernel = installFakeKernel(() => ok(null))
+    try {
+      render(<App />)
+      await flush()
+
+      expect(screen.getByText(/No view registered for \/ui\/nope/)).toBeTruthy()
       expect(kernel.calls).toHaveLength(0)
     } finally {
       kernel.restore()

package/template/client/__tests__/harness.ts

@@ -1,7 +1,11 @@
 /**
- * Test harness — a FAKE shell parent + a FAKE kernel, so the client's inline
- * handshake (`src/lib/shell.ts`) and JSON kernel client (`src/lib/kernel.ts`)
- * can be exercised with no real GUI/kernel.
+ * Test harness — a FAKE shell parent + a FAKE kernel, so the client's shell
+ * handshake (now `@astrale-os/shell`, `createShell({ mode: 'sandboxed' })`) and
+ * its kernel calls can be exercised with no real GUI/kernel.
+ *
+ * `fakeKernelSession()` is the unit-test counterpart: a `KernelClient` whose
+ * `call` hits the fake kernel directly (no handshake), for hooks tested in
+ * isolation.
  *
  * The fake parent mirrors `runParentHandshake`
  * (`shell/packages/shell/src/application/windowing/handshake.ts`):
@@ -17,6 +21,8 @@
  * the child believes it is framed.
  */
 
+import type { KernelClient } from '@/shell'
+
 const INIT_REQUEST_TYPE = 'astrale-shell/init-request'
 const INIT_RESPONSE_TYPE = 'astrale-shell/init-response'
 
@@ -196,26 +202,75 @@ export function ok(result: unknown): { result: unknown } {
   return { result }
 }
 
-/** Build a minimal kernel Note node whose props carry title/body. */
-export function noteNode(opts: {
+/**
+ * A `KernelClient` for unit tests that exercise feature hooks WITHOUT a
+ * handshake. Its `call` POSTs the kernel JSON envelope (`{ method, params, id }`)
+ * so the `installFakeKernel` fetch stub records it and `body.method`/
+ * `body.params` assertions hold — same wire the real `shell.kernel` speaks to a
+ * JSON kernel. The credential surface (`mintDelegation`/`authToken`/`url`) is
+ * stubbed minimally — the isolated hooks under test only ever touch `call`.
+ */
+export function fakeKernelSession(kernelUrl = 'https://k.example.test/api'): KernelClient {
+  let idSeq = 0
+  return {
+    async call(method: string, params: unknown = {}): Promise<unknown> {
+      idSeq += 1
+      const res = await fetch(kernelUrl, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/vnd.astrale.kernel+json',
+          accept: 'application/vnd.astrale.kernel+json',
+          authorization: 'tok-A',
+        },
+        body: JSON.stringify({ method, params, id: `c${idSeq}` }),
+      })
+      const obj = (await res.json()) as Record<string, unknown>
+      if (obj.error && typeof obj.error === 'object') {
+        const err = obj.error as { code?: unknown; message?: unknown }
+        const code = typeof err.code === 'number' ? err.code : 5000
+        const message = typeof err.message === 'string' ? err.message : 'Unknown error'
+        throw new Error(`${code}: ${message}`)
+      }
+      return obj.result
+    },
+    mintDelegation: async () => '<fake>',
+    authToken: () => '<fake>',
+    url: kernelUrl,
+  }
+}
+
+/**
+ * Build a minimal kernel Monitor node whose props carry url/status/statusCode/
+ * latencyMs/lastCheckedAt, with the same domain-qualified key format the kernel
+ * uses (`<domain>:class.Monitor.property.<name>`). The name uses the kernel
+ * `Named.name` key.
+ */
+export function monitorNode(opts: {
   id: string
   path?: string
   name?: string
-  title?: string
-  body?: string
+  url?: string
+  status?: string
+  statusCode?: string
+  latencyMs?: string
+  lastCheckedAt?: string
   domain?: string
 }): { id: string; path: string; class: { raw: string }; props: Record<string, unknown> } {
-  const domain = opts.domain ?? 'notes.astrale.ai'
+  const domain = opts.domain ?? 'monitors.astrale.ai'
+  const base = `${domain}:class.Monitor.property`
   const props: Record<string, unknown> = {}
   if (opts.name !== undefined) {
     props['kernel.astrale.ai:interface.Named.property.name'] = opts.name
   }
-  if (opts.title !== undefined) props[`${domain}:class.Note.property.title`] = opts.title
-  if (opts.body !== undefined) props[`${domain}:class.Note.property.body`] = opts.body
+  if (opts.url !== undefined) props[`${base}.url`] = opts.url
+  if (opts.status !== undefined) props[`${base}.status`] = opts.status
+  if (opts.statusCode !== undefined) props[`${base}.statusCode`] = opts.statusCode
+  if (opts.latencyMs !== undefined) props[`${base}.latencyMs`] = opts.latencyMs
+  if (opts.lastCheckedAt !== undefined) props[`${base}.lastCheckedAt`] = opts.lastCheckedAt
   return {
     id: opts.id,
-    path: opts.path ?? `/notes/${opts.id}`,
-    class: { raw: `/:${domain}:class.Note` },
+    path: opts.path ?? `/monitors/${opts.id}`,
+    class: { raw: `/:${domain}:class.Monitor` },
     props,
   }
 }

package/template/client/__tests__/kernel.test.ts

@@ -1,68 +1,83 @@
-import { afterEach, describe, expect, it } from 'vitest'
+import { describe, expect, it } from 'vitest'
 
-import { kernelCall, readProp, readPropBySuffix } from '../src/lib/kernel'
-import { installFakeKernel } from './harness'
+import { qualifiedString, readProp, readPropBySuffix } from '@/shell'
+import { monitorFromNode, normalizeStatus } from '@/monitor'
+import { relativeTime } from '@/ui'
+import { monitorNode } from './harness'
 
-const TYPE = 'application/vnd.astrale.kernel+json'
-
-describe('kernelCall — inline JSON envelope client', () => {
-  let restore: (() => void) | undefined
-  afterEach(() => {
-    restore?.()
-    restore = undefined
+describe('prop readers', () => {
+  it('readProp returns the string value at the exact key', () => {
+    expect(readProp({ a: 'x', b: 1 }, 'a')).toBe('x')
+    expect(readProp({ a: 'x' }, 'missing')).toBeUndefined()
+    expect(readProp({ a: 1 }, 'a')).toBeUndefined() // non-string
   })
 
-  it('POSTs the envelope with a trailing slash, bare token, and kernel content type', async () => {
-    const k = installFakeKernel(() => ({ result: { ok: true } }))
-    restore = k.restore
-    const result = await kernelCall('https://k.test/api', 'tok-X', '@n1::get', {})
-    expect(result).toEqual({ ok: true })
-
-    const req = k.calls[0]!
-    expect(req.method).toBe('POST')
-    expect(req.url).toBe('https://k.test/api/') // slash added
-    expect(req.headers['authorization']).toBe('tok-X')
-    expect(req.headers['content-type']).toBe(TYPE)
-    expect(req.headers['accept']).toBe(TYPE)
-    expect(req.body).toMatchObject({ method: '@n1::get', params: {} })
-    expect(req.body.id).toBeTruthy()
+  it('readPropBySuffix matches the first key ending with the suffix', () => {
+    const props = {
+      'monitors.astrale.ai:class.Monitor.property.url': 'https://x.test',
+      'kernel.astrale.ai:interface.Named.property.name': 'n',
+    }
+    expect(readPropBySuffix(props, '.property.url')).toBe('https://x.test')
+    expect(readPropBySuffix(props, '.property.status')).toBeUndefined()
   })
 
-  it('does not double the trailing slash when the URL already ends in one', async () => {
-    const k = installFakeKernel(() => ({ result: 1 }))
-    restore = k.restore
-    await kernelCall('https://k.test/api/', 'tok', '@n::get')
-    expect(k.calls[0]!.url).toBe('https://k.test/api/')
+  it('qualifiedString prefers a domain key over the kernel one for the same suffix', () => {
+    const props = {
+      'kernel.astrale.ai:interface.Named.property.name': 'kernel name',
+      'monitors.astrale.ai:class.Monitor.property.name': 'domain name',
+    }
+    expect(qualifiedString(props, 'name')).toBe('domain name')
   })
+})
 
-  it('throws "<code>: <message>" on a kernel error envelope', async () => {
-    const k = installFakeKernel(() => ({ error: { code: 2004, message: 'Permission denied' } }))
-    restore = k.restore
-    await expect(kernelCall('https://k.test/api', 't', '@n::get')).rejects.toThrow(
-      '2004: Permission denied',
+describe('monitorFromNode mapper', () => {
+  it('projects name, url, normalized status and coerced numbers', () => {
+    const record = monitorFromNode(
+      monitorNode({
+        id: 'mon-1',
+        name: 'API health',
+        url: 'https://api.test/health',
+        status: 'up',
+        statusCode: '200',
+        latencyMs: '42',
+        lastCheckedAt: '2026-06-14T10:00:00Z',
+      }),
     )
+    expect(record).toMatchObject({
+      id: 'mon-1',
+      name: 'API health',
+      url: 'https://api.test/health',
+      status: 'up',
+      statusCode: 200,
+      latencyMs: 42,
+      lastCheckedAt: '2026-06-14T10:00:00Z',
+    })
   })
 
-  it('throws on an unexpected redirect envelope', async () => {
-    const k = installFakeKernel(() => ({ redirect: { url: 'https://other.test/api' } }))
-    restore = k.restore
-    await expect(kernelCall('https://k.test/api', 't', '@n::get')).rejects.toThrow(/redirect/)
+  it('falls back to the path segment for the name and unknown for a missing status', () => {
+    const record = monitorFromNode(monitorNode({ id: 'mon-9', path: '/monitors/edge' }))
+    expect(record.name).toBe('edge')
+    expect(record.status).toBe('unknown')
+    expect(record.url).toBe('')
+    expect(record.statusCode).toBeUndefined()
   })
 })
 
-describe('prop readers', () => {
-  it('readProp returns the string value at the exact key', () => {
-    expect(readProp({ a: 'x', b: 1 }, 'a')).toBe('x')
-    expect(readProp({ a: 'x' }, 'missing')).toBeUndefined()
-    expect(readProp({ a: 1 }, 'a')).toBeUndefined() // non-string
+describe('normalizeStatus', () => {
+  it('passes through up/down and maps everything else to unknown', () => {
+    expect(normalizeStatus('up')).toBe('up')
+    expect(normalizeStatus('down')).toBe('down')
+    expect(normalizeStatus('weird')).toBe('unknown')
+    expect(normalizeStatus(undefined)).toBe('unknown')
   })
+})
 
-  it('readPropBySuffix matches the first key ending with the suffix', () => {
-    const props = {
-      'notes.astrale.ai:class.Note.property.body': 'the body',
-      'kernel.astrale.ai:interface.Named.property.name': 'n',
-    }
-    expect(readPropBySuffix(props, '.property.body')).toBe('the body')
-    expect(readPropBySuffix(props, '.property.title')).toBeUndefined()
+describe('relativeTime', () => {
+  const now = Date.parse('2026-06-14T12:00:00Z')
+  it('renders coarse buckets and a dash for missing input', () => {
+    expect(relativeTime(undefined, now)).toBe('—')
+    expect(relativeTime('2026-06-14T11:55:00Z', now)).toBe('5m ago')
+    expect(relativeTime('2026-06-14T10:00:00Z', now)).toBe('2h ago')
+    expect(relativeTime('not-a-date', now)).toBe('not-a-date')
   })
 })