@astrale-os/adapter-cloudflare 0.3.0 → 0.3.2

package/template/client/src/shell/use-node.ts

@@ -4,6 +4,12 @@ import { useCallback, useEffect, useState } from 'react'
 
 import { errorMessage, type KernelNode } from './client'
 
+type KernelReadClient = KernelClient & {
+  get(
+    path: string,
+  ): Promise<{ node: { id: string } | null; wire: { nodes: readonly KernelNode[] } }>
+}
+
 export type NodeState =
   | { status: 'idle' }
   | { status: 'loading' }
@@ -11,16 +17,8 @@ export type NodeState =
   | { status: 'error'; message: string }
 
 /**
- * Fetch a node by id via `@<id>::get`. Re-fetches when the target node id
- * changes (`setTarget` hot-swap); stays `idle` until a target node id exists.
- * `session` is a stable reference for the view's lifetime, so listing it as a
- * dep never re-fires on its own — and the shell's client reads the fresh token
- * at call time, so a `ctrl:tokenRefresh` needs no re-fetch.
- *
- * Returns the node state plus a `reload()` that re-fetches the current node —
- * the view calls it after an instance method (e.g. `::check`) mutates the node
- * so the fresh props render. It bumps an internal `nonce` dep, re-firing the
- * effect.
+ * Fetch a node by id through `shell.kernel.get('@<id>')`.
+ * `null` means missing or masked; `reload()` refetches the current id.
  */
 export function useNode(
   session: KernelClient,
@@ -40,11 +38,21 @@ export function useNode(
     }
 
     let cancelled = false
+    const kernel = session as KernelReadClient
     setState({ status: 'loading' })
-    session
-      .call(`@${nodeId}::get`, {})
+    kernel
+      .get(`@${nodeId}`)
       .then((result) => {
-        if (!cancelled) setState({ status: 'ok', node: result as KernelNode })
+        if (cancelled) return
+        const node =
+          result.node === null
+            ? null
+            : (result.wire.nodes.find((n) => n.id === result.node?.id) ?? null)
+        if (node === null) {
+          setState({ status: 'error', message: 'Node not found or not visible' })
+          return
+        }
+        setState({ status: 'ok', node })
       })
       .catch((err: unknown) => {
         if (!cancelled) {

package/template/client/src/ui/index.ts

@@ -1,13 +1,10 @@
 /**
  * The design system — generic, feature-AGNOSTIC presentational primitives +
- * display formatters, no domain knowledge and no kernel session. The one
- * domain-shaped exception is `StatusBadge`: it renders the up/degraded/down/
- * unknown health vocabulary that any `Checkable` node reports, so it's a shared
- * primitive here rather than living inside the status feature.
- * Import from the barrel: `import { Panel, KV, relativeTime } from '@/ui'`.
+ * display formatters, no domain knowledge and no kernel session. Import from the
+ * barrel: `import { Panel, KV, relativeTime } from '@/ui'`. A view's own
+ * health/status chips and other domain-shaped widgets live alongside their
+ * feature, not here.
  */
 export { EmptyState, ErrorBanner, Panel, Spinner } from './surface'
-export { StatusBadge } from './StatusBadge'
-export type { HealthStatus } from './StatusBadge'
 export { ExternalLink, KV, Mono } from './value'
 export { relativeTime } from './format'

package/template/core/README.md

@@ -0,0 +1,23 @@
+# core/ — pure domain logic
+
+This folder holds the **pure, transport-agnostic logic** for each bounded
+context — no I/O, no `fetch`, no clock/RNG, no kernel session. Just functions
+over plain data that `runtime/` handlers call. Being pure makes it the easy part
+to unit-test.
+
+A context usually gets its own subfolder:
+
+```
+core/<context>/
+  keys.ts     compiled-schema accessors (class paths, prop keys) — the ONE
+              place graph-facing strings come from; read them off `D` from
+              `schema/`, never hand-write them
+  logic.ts    the pure rules (validation, computation, state transitions)
+  index.ts    re-export the context's surface
+```
+
+Keep the impure bits (network calls, kernel reads/writes, entropy) out of here —
+those live behind a port in `integrations/` and in the `runtime/` handlers.
+
+Delete this README once you add your first context. Load the `astrale-domain`
+skill for the modeling patterns.

package/template/deps.ts

@@ -7,20 +7,21 @@ import type { Env } from './env'
  * it's where ports/clients are wired once instead of being re-derived in every
  * handler.
  *
- * The prober port is resolved PER-REQUEST and PER-NODE (each `prober(target)`
- * call), not here — so this stays a cheap synchronous wiring step and the backend
- * can be chosen from the monitor being probed, not just the env.
+ * It starts as a PASSTHROUGH — handlers get the raw `Env` as `ctx.deps`.
+ * Transform here the moment a handler should depend on a PORT (built from
+ * `integrations/`) instead of raw config — that's the whole point of this seam:
  *
- * Omit the `deps` field in `domain.ts` for the trivial case (handlers then get
- * raw `Env`). Transform here the moment a handler should depend on a PORT instead
- * of raw config — that's the whole point of this seam.
+ *   import { buildExampleRegistry, type ExampleRegistry } from './integrations/example/registry'
+ *   export interface Deps extends ExampleRegistry {}
+ *   export function deps(env: Env): Deps {
+ *     return buildExampleRegistry(env)
+ *   }
  */
-import { buildProberRegistry, type ProberRegistry } from './integrations/prober/registry'
 
 /** Typed dependency container handed to every method as `ctx.deps`. */
-export interface Deps extends ProberRegistry {}
+export interface Deps extends Env {}
 
 /** Map the worker env to the handler deps (the seam `defineDomain({ deps })` mounts). */
 export function deps(env: Env): Deps {
-  return buildProberRegistry(env)
+  return env
 }

package/template/domain.ts

@@ -1,11 +1,17 @@
 /**
  * domain.ts — the WORKER-SAFE domain definition: what the domain IS (its
  * `schema`, `methods`, `deps`, `views`, `functions`) plus its identity
- * (`origin` defaults to `schema.domain`; `postInstall`). Everything is wired
- * EXPLICITLY here — a renamed or mistyped module is a compile error at this
- * call, never a silently-missing route. The handlers live in `runtime/` (the
- * composition root), the pure logic in `core/`, the external-API ports in
- * `integrations/` — but the worker only ever sees this one wired definition.
+ * (`origin` defaults to `schema.domain`; `requires`; optional `postInstall`).
+ * Everything is wired EXPLICITLY here — a renamed or mistyped module is a
+ * compile error at this call, never a silently-missing route. The handlers live
+ * in `runtime/` (the composition root), the pure logic in `core/`, the
+ * external-API ports in `integrations/` — but the worker only ever sees this one
+ * wired definition.
+ *
+ * The maps it wires (`methods`, `views`, `functions`) start empty — this is a
+ * blank skeleton. Fill them in their folders and they flow through here with no
+ * change needed. Add `postInstall: functions.<key>` once you author a seed
+ * function — the kernel calls it once after install, as __SYSTEM__.
  *
  * The generated worker (`.astrale/worker.gen.ts`) imports THIS and spreads it,
  * so your folder layout is invisible to it — reorganize freely; only this wiring
@@ -27,9 +33,5 @@ export const domain = defineDomain({
   deps,
   views,
   functions,
-  // Reference the `seed` function directly — the SDK derives its path from the
-  // `functions` map, so a rename can't leave a stale string. The kernel calls it
-  // once after install, as __SYSTEM__. (A class method would be `'class.X:seed'`.)
-  postInstall: functions.seed,
   requires: [],
 })

package/template/env.ts

@@ -1,7 +1,8 @@
 /**
  * Worker runtime env. The adapter injects `WORKER_URL` and the bindings; your
- * handlers receive this as `ctx.deps`. Secrets from `.env.<env>` arrive as
- * extra string fields here. Add typed fields as you reference new secrets/vars.
+ * handlers receive this (mapped by `deps.ts`) as `ctx.deps`. Secrets from
+ * `.env.<env>` arrive as extra string fields here. Add typed fields as you
+ * reference new secrets/vars.
  */
 export interface Env {
   /** The worker's canonical serving URL (its `iss` identity), injected by the
@@ -19,8 +20,5 @@ export interface Env {
   /** Dev-only: forward /ui/* to a running Vite dev server. */
   VIEW_DEV_URL?: string
 
-  /** `http` only — per-probe timeout in ms (default 10000). */
-  PROBE_TIMEOUT_MS?: string
-
   [key: string]: unknown
 }

package/template/functions/index.ts

@@ -2,32 +2,21 @@
  * Standalone-function registry — one entry per callable that is NOT a method of
  * a class. Each becomes a first-class domain MEMBER: a `Function` node at
  * `/<origin>/functions/<key>` with an `of_domain` edge (slug `function.<key>`),
- * so it is addressable by the semantic domain path `/:<origin>:function.<key>`
- * (e.g. as a `postInstall` target — see `domain.ts`) on top of its worker route
- * `/functions/<key>`. The SDK stamps `binding.remoteUrl` with the worker's public
- * URL at install. The map key is the slug (single source of truth).
+ * addressable by the semantic domain path `/:<origin>:function.<key>` on top of
+ * its worker route `/functions/<key>`. The map key is the slug.
+ *
+ * It starts EMPTY. Add a function (e.g. a webhook, or a `postInstall` seed) with
+ * `defineRemoteFunction` and list it here; reference it from `domain.ts` (e.g.
+ * `postInstall: functions.seed`) so a rename can't leave a stale path string:
+ *
+ *   seed: defineRemoteFunction({
+ *     inputSchema: z.object({}),
+ *     outputSchema: z.object({ seeded: z.number().int() }),
+ *     authorize: async () => undefined,
+ *     execute: ({ kernel }) => ({ seeded: 0 }),
+ *   }),
  *
  * A standalone function's `execute` receives the same request context as a
  * method MINUS `self` (it is not node-bound): `{ params, kernel, deps, auth, … }`.
  */
-import { defineRemoteFunction } from '@astrale-os/sdk'
-import { z } from 'zod'
-
-import type { Deps } from '../deps'
-
-import { monitor } from '../runtime/monitoring'
-
-export const functions = {
-  // Post-install bootstrap, wired as `postInstall` in `domain.ts`. The kernel
-  // calls it ONCE after install, as __SYSTEM__ (its delegation minted for this
-  // function's own identity), so the domain comes up demonstrable. Must stay
-  // idempotent — a re-install runs it again. `auth: 'required'` (the default)
-  // makes `ctx.kernel` non-null; the body delegates to the per-operation seed
-  // logic in `runtime/monitor/seed.ts`.
-  seed: defineRemoteFunction<Record<string, never>, { seeded: number }, Deps>({
-    inputSchema: z.object({}),
-    outputSchema: z.object({ seeded: z.number().int() }),
-    authorize: async () => undefined,
-    execute: ({ kernel, deps }) => monitor.seed(kernel, deps.prober()),
-  }),
-}
+export const functions = {}

package/template/icons.ts

@@ -0,0 +1,25 @@
+/**
+ * Class icons — raw SVG markup attached to a class via `nodeClass({ icon })`.
+ * The kernel materializes the icon onto the class `self` node (the `Iconable`
+ * interface) at boot; clients resolve an instance's icon through its class.
+ *
+ * Markup is raw inner SVG — lift glyphs verbatim from lucide (ISC) and the
+ * `svg()` wrapper supplies the `<svg>` shell. `stroke="currentColor"` so the
+ * glyph follows text color. Add one constant per class:
+ *
+ *   import { BOX_ICON } from '../icons'
+ *   export const Widget = nodeClass({ icon: BOX_ICON, props: { … } })
+ */
+
+const svg = (inner: string): string =>
+  `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">${inner}</svg>`
+
+/** lucide `box` — a generic starter glyph for your first class. */
+export const BOX_ICON = svg(
+  '<path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/>',
+)
+
+/** lucide `sparkles` — for an AI / generative class. */
+export const SPARKLES_ICON = svg(
+  '<path d="M9.937 15.5A2 2 0 0 0 8.5 14.063l-6.135-1.582a.5.5 0 0 1 0-.962L8.5 9.936A2 2 0 0 0 9.937 8.5l1.582-6.135a.5.5 0 0 1 .962 0L14.063 8.5A2 2 0 0 0 15.5 9.937l6.135 1.581a.5.5 0 0 1 0 .964L15.5 14.063a2 2 0 0 0-1.437 1.437l-1.582 6.135a.5.5 0 0 1-.962 0z"/><path d="M20 3v4"/><path d="M22 5h-4"/><path d="M4 17v2"/><path d="M5 18H3"/>',
+)

package/template/integrations/README.md

@@ -0,0 +1,22 @@
+# integrations/ — external-API ports + adapters
+
+This is the seam between your domain's logic and the outside world (an HTTP API,
+an SDK, a queue, …). The pattern keeps `runtime/` logic depending on a narrow
+**port** (an interface), never on `fetch` or a vendor SDK directly — so a handler
+is testable against a fake and the backend can be swapped per env or per node.
+
+```
+integrations/<service>/
+  port.ts       the interface the logic depends on (the narrowest surface)
+  http.ts       a real adapter implementing the port
+  mock.ts       an offline/deterministic adapter, for tests
+  registry.ts   picks an adapter from `Env` (and optionally the target node),
+                exposed to handlers as part of `Deps`
+```
+
+`deps.ts` builds the registry from the worker `Env` once per isolate and mounts
+it as `ctx.deps`; handlers resolve the concrete port per request. Until you add a
+port, `deps.ts` is a passthrough (`Deps = Env`).
+
+Delete this README once you add your first integration. Load the
+`astrale-domain` skill for the DI / secrets / idempotency patterns.

package/template/package.json

@@ -14,10 +14,10 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@astrale-os/adapter-cloudflare": ">=0.3.0 <1.0.0",
-    "@astrale-os/kernel-core": ">=0.4.3 <1.0.0",
+    "@astrale-os/adapter-cloudflare": ">=0.3.2 <1.0.0",
+    "@astrale-os/kernel-core": ">=0.6.2 <1.0.0",
     "@astrale-os/kernel-dsl": ">=0.1.2 <1.0.0",
-    "@astrale-os/sdk": ">=0.2.0 <1.0.0",
+    "@astrale-os/sdk": ">=0.3.0 <1.0.0",
     "@hono/node-server": "^1.19.0",
     "zod": "^4.3.6"
   },

package/template/runtime/index.ts

@@ -1,82 +1,35 @@
 /**
  * Runtime composition root — the ONLY place request context (kernel/self/params/
- * auth) and `deps` meet the per-feature logic. Each `execute` resolves what it
- * needs (the `Prober` port, the self node) and delegates to the monitoring
- * bounded context in `runtime/monitoring/{monitor,page}`. No business logic
- * lives here.
+ * auth) and `deps` meet the per-feature logic. The `methods` map is what
+ * `domain.ts` mounts: one entry per class method, each delegating to the pure
+ * logic in `core/` and resolving its ports from `deps`. No business logic lives
+ * here — this file is just the wiring.
  *
- * `check` is the `Checkable` interface method, declared `abstract`, so it is
- * implemented PER CLASS (Monitor probes; StatusPage rolls up) — wired under
- * `class.Monitor` / `class.StatusPage`, NOT a shared `interface` block. The
- * kernel dispatches `@<node>::check` to the impl for that node's class.
+ * It starts EMPTY (`class: {}`). Once you declare a class with methods in
+ * `schema/`, wire its handlers here:
  *
- * SDK-level `authorize` is an additive throw-to-deny check (returns void). For
- * finer worker checks see `assertPerm` / `requireOwnership` from `@astrale-os/sdk`.
+ *   import { remoteClassMethods, remoteMethod } from '@astrale-os/sdk'
+ *   const method = remoteMethod<Deps>()
+ *   const classMethods = remoteClassMethods<Deps>()
+ *
+ *   const greetMethod = method(schema, 'Greeter', 'greet', {
+ *     authorize: async () => undefined,
+ *     execute: ({ params }) => ({ message: `hi ${params.name}` }),
+ *   })
+ *
+ *   export const methods: SchemaMethodsImpl<typeof schema, Deps> = {
+ *     class: { Greeter: classMethods(schema, 'Greeter', { greet: greetMethod }) },
+ *   }
+ *
+ * Load the `astrale-domain` skill for the full handler/authorize/port patterns.
  */
-import { remoteClassMethods, remoteMethod, type SchemaMethodsImpl } from '@astrale-os/sdk'
+import type { SchemaMethodsImpl } from '@astrale-os/sdk'
 
 import type { Deps } from '../deps'
-
-import { MONITOR_KEYS } from '../core/monitor'
-import { schema } from '../schema'
-import { monitor, page } from './monitoring'
-
-const method = remoteMethod<Deps>()
-const classMethods = remoteClassMethods<Deps>()
-
-// ── Monitor ─────────────────────────────────────────────────────────
-
-const monitorCheckMethod = method(schema, 'Monitor', 'check', {
-  authorize: async () => undefined,
-  execute: async ({ kernel, self, deps }) => {
-    const node = await self.node()
-    const url = node.props[MONITOR_KEYS.url]
-    if (typeof url !== 'string') throw new Error('Monitor node is missing its url property')
-    // Pass the node to the picker — the prober is chosen FOR this monitor.
-    return monitor.check(kernel, deps.prober({ class: node.class.raw, url }), self.path.raw, url)
-  },
-})
-
-const watchMethod = method(schema, 'Monitor', 'watch', {
-  authorize: async () => undefined,
-  execute: ({ kernel, params }) => {
-    return monitor.watch(kernel, params)
-  },
-})
-
-// ── StatusPage ──────────────────────────────────────────────────────
-
-const pageCheckMethod = method(schema, 'StatusPage', 'check', {
-  authorize: async () => undefined,
-  execute: ({ kernel, self }) => {
-    return page.check(kernel, self.path.raw)
-  },
-})
-
-const createMethod = method(schema, 'StatusPage', 'create', {
-  authorize: async () => undefined,
-  execute: ({ kernel, params }) => {
-    return page.create(kernel, params)
-  },
-})
-
-const addMethod = method(schema, 'StatusPage', 'add', {
-  authorize: async () => undefined,
-  execute: ({ kernel, self, params }) => {
-    return page.add(kernel, self.path.raw, params)
-  },
-})
+// While the map is empty, `schema` is only referenced as a type (`typeof schema`).
+// Drop the `type` keyword once you pass `schema` to `method()` / `classMethods()`.
+import type { schema } from '../schema'
 
 export const methods: SchemaMethodsImpl<typeof schema, Deps> = {
-  class: {
-    Monitor: classMethods(schema, 'Monitor', {
-      check: monitorCheckMethod,
-      watch: watchMethod,
-    }),
-    StatusPage: classMethods(schema, 'StatusPage', {
-      check: pageCheckMethod,
-      create: createMethod,
-      add: addMethod,
-    }),
-  },
+  class: {},
 }

package/template/schema/index.ts

@@ -5,26 +5,26 @@
  * and the worker signs JWTs under it. The scaffolder set this string from your
  * slug; change it here to rename the domain's identity.
  *
- * Add a context: author `schema/<context>.ts`, then import its members and list
- * them in the `interfaces` / `classes` maps below.
+ * The maps start EMPTY — this is prepared terrain, not a working domain. Add a
+ * context by authoring `schema/<context>.ts` (declare classes with `nodeClass`,
+ * interfaces with `nodeInterface`, edges with `edgeClass`), then import its
+ * members and list them in the `interfaces` / `classes` maps below. Wire the
+ * matching handlers in `runtime/`. Load the `astrale-domain` skill for the
+ * authoring patterns.
  */
 import { defineSchema, KernelSchema } from '@astrale-os/kernel-core'
 import { compileDomain, type Domain } from '@astrale-os/kernel-core/domain'
 
-import { Checkable, Monitor, StatusPage, watches } from './monitor'
-
 export const schema = defineSchema('astrale-domain.example.dev', {
-  interfaces: { Checkable },
-  classes: { Monitor, StatusPage, watches },
+  interfaces: {},
+  classes: {},
   imports: [KernelSchema],
 })
 
 /**
  * The compiled domain — resolved class/interface paths + qualified prop keys.
  * `compileDomain` is pure (no env), so this is safe to import from the worker
- * and from build tooling alike. `core/monitor/keys.ts` re-exports it as the single
- * source of graph-facing strings (class paths, prop keys) — never hand-write those.
+ * and from build tooling alike. Read graph-facing strings (class paths, prop
+ * keys) off `D` once you add classes — never hand-write them.
  */
 export const D: Domain<typeof schema> = compileDomain(schema)
-
-export * from './monitor'

package/template/tsconfig.json

@@ -22,6 +22,7 @@
     "deps.ts",
     "env.ts",
     "domain.ts",
+    "icons.ts",
     "astrale.config.ts"
   ],
   "exclude": ["node_modules", ".astrale", ".dist"]

package/template/views/index.ts

@@ -1,16 +1,19 @@
 /**
  * View registry — one file per view under `views/`, assembled here. Slug = map
- * key; each becomes a View node at `/<origin>/views/<slug>` whose iframe
- * binding the SDK stamps with the worker's live serving URL when it builds the
- * install bundle.
+ * key; each becomes a View node at `/<origin>/views/<slug>` whose iframe binding
+ * the SDK stamps with the worker's live serving URL when it builds the install
+ * bundle.
  *
- * `welcome` is a worker-rendered inline-HTML view (no SPA). `ui-status-page` is
- * the `client/` SPA (mounted at `/ui/status-page`, offered for any StatusPage).
+ * It starts EMPTY. Two shapes of view:
+ *
+ *   - Inline HTML, rendered straight from the worker (no client bundle):
+ *       export const welcome = defineView({ auth: 'public', render: ({ c }) =>
+ *         c.html('<h1>hello</h1>') })
+ *   - A `client/` SPA view, mounted under `/ui/<route>` and offered for a class:
+ *       export const panel = defineView({ auth: 'public', mount: '/ui/panel',
+ *         viewFor: selfOf(SomeClass) })
+ *     then register a matching route in `client/src/app.tsx`.
+ *
+ * Add the view file under `views/`, import it, and list it below (key = slug).
  */
-import { statusPage } from './status-page'
-import { welcome } from './welcome'
-
-export const views = {
-  welcome,
-  'ui-status-page': statusPage,
-}
+export const views = {}

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

@@ -1,77 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { qualifiedString, readProp, readPropBySuffix } from '@/shell'
-import { checkableFromNode, watchedMonitorRefs } from '@/status'
-import { relativeTime } from '@/ui'
-
-import { checkableNode } from './harness'
-
-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('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('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')
-  })
-})
-
-describe('checkableFromNode mapper', () => {
-  it('projects the name and rolled-up status of a StatusPage node', () => {
-    const record = checkableFromNode(
-      checkableNode({ id: 'page-1', name: 'Public', status: 'degraded', className: 'StatusPage' }),
-    )
-    expect(record).toMatchObject({
-      id: 'page-1',
-      name: 'Public',
-      status: 'degraded',
-      className: 'StatusPage',
-    })
-  })
-
-  it('falls back to the path segment for the name and unknown for a missing status', () => {
-    const record = checkableFromNode(
-      checkableNode({ id: 'page-9', path: '/monitoring/pages/edge' }),
-    )
-    expect(record.name).toBe('edge')
-    expect(record.status).toBe('unknown')
-  })
-})
-
-describe('watchedMonitorRefs mapper', () => {
-  it('projects target refs and critical edge weights', () => {
-    const refs = watchedMonitorRefs([
-      {
-        class: { raw: '/:monitors.astrale.ai:class.watches' },
-        target: { raw: '/monitoring/monitors/astrale' },
-        props: { 'monitors.astrale.ai:class.watches.property.critical': true },
-      },
-    ])
-    expect(refs).toEqual([{ target: '/monitoring/monitors/astrale', critical: true }])
-  })
-})
-
-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')
-  })
-})