@astrale-os/adapter-cloudflare 0.3.1 → 0.3.2

package/template/core/monitor/keys.ts

@@ -1,41 +0,0 @@
-/**
- * Compiled-schema accessors for the monitor context — the ONE place class paths,
- * method paths, and qualified prop keys come from. Pure (schema-derived); never
- * hand-write key strings. `D` (the compiled domain) comes from `schema/index`,
- * re-exported here so the rest of the context reads it from one place.
- */
-import { K } from '@astrale-os/kernel-core'
-
-import { D } from '../../schema'
-
-export { D, K }
-
-/** Kernel ops/classes the logic addresses. */
-export const NODE_CREATE = K.Node.createNode.path.method.raw
-export const FOLDER_CLASS = K.Folder.path.class.raw
-export const NAME_KEY = K.Named.name.key
-
-/** Domain class/edge paths. */
-export const MONITOR_CLASS = D.Monitor.path.class.raw
-export const STATUS_PAGE_CLASS = D.StatusPage.path.class.raw
-export const WATCHES_EDGE = D.watches.path.class.raw
-
-/** Qualified storage keys for Monitor node props. */
-export const MONITOR_KEYS = {
-  url: D.Monitor.url.key,
-  status: D.Monitor.status.key,
-  statusCode: D.Monitor.statusCode.key,
-  latencyMs: D.Monitor.latencyMs.key,
-  lastCheckedAt: D.Monitor.lastCheckedAt.key,
-} as const
-
-/** Qualified storage key for the StatusPage's rolled-up status. */
-export const PAGE_KEYS = {
-  status: D.StatusPage.status.key,
-} as const
-
-/** Qualified key for the `watches` edge's `critical` prop. Edge-prop accessors
- *  aren't typed yet (an SDK gap), so this casts to read the key. */
-export const WATCHES_KEYS = {
-  critical: (D.watches as unknown as { critical: { key: string } }).critical.key,
-} as const

package/template/core/monitor/node.ts

@@ -1,63 +0,0 @@
-/**
- * Node identity — PURE domain constants + slug logic (no I/O): where monitors and
- * status pages live in the graph, how a new node's slug is formed, and the seed
- * set. `runtime/` consumes these; the IMPURE bits (the slug's entropy suffix, the
- * node writes) stay in `runtime/`, so this file is deterministic and testable.
- */
-
-/** Where monitoring nodes live in the graph (domain layout; `seed` creates the folders). */
-export const MONITORING_PARENT = '/monitoring'
-export const MONITORS_PARENT = `${MONITORING_PARENT}/monitors`
-export const STATUS_PAGES_PARENT = `${MONITORING_PARENT}/pages`
-
-/** Deterministic URL-/name-safe stem (lowercased, non-alnum → `-`, clamped). Pure. */
-export function slugify(text: string): string {
-  return (
-    text
-      .replace(/^https?:\/\//i, '')
-      .toLowerCase()
-      .replace(/[^a-z0-9]+/g, '-')
-      .replace(/^-|-$/g, '')
-      .slice(0, 40) || 'node'
-  )
-}
-
-/**
- * Slug for a NEW node: the stem + a caller-supplied `suffix`. Pure — `runtime/`
- * injects the `suffix` (clock/RNG entropy for collision safety) so core stays
- * deterministic. `seed` uses fixed slugs (not this) for idempotency.
- */
-export function uniqueSlug(text: string, suffix: string): string {
-  return `${slugify(text)}-${suffix}`
-}
-
-export interface StarterMonitor {
-  slug: string
-  name: string
-  url: string
-  /** Whether the seeded status page treats this monitor as critical. */
-  critical: boolean
-}
-
-/**
- * Monitors laid down by `seed` (postInstall). httpbin returns a deterministic
- * status code, so the second starter is a stable demo target; the first points at
- * a real site. Fixed slugs keep `seed` idempotent across reinstalls.
- */
-export const STARTERS: readonly StarterMonitor[] = [
-  {
-    slug: 'astrale',
-    name: 'Astrale homepage',
-    url: 'https://astrale.ai',
-    critical: true,
-  },
-  {
-    slug: 'httpbin-200',
-    name: 'HTTP 200 smoke check',
-    url: 'https://httpbin.org/status/200',
-    critical: false,
-  },
-]
-
-/** The status page `seed` creates, watching every starter monitor. */
-export const STARTER_PAGE = { slug: 'status', name: 'Public status' } as const

package/template/integrations/prober/http.ts

@@ -1,32 +0,0 @@
-/**
- * HTTP prober — the REAL external adapter: a single keyless `fetch` to the
- * target, timing the round-trip. This is the shape your domain's external calls
- * take — a timeout via `AbortSignal`, failures mapped to a domain result rather
- * than thrown. NO API key: a fresh scaffold makes a true external call out of
- * the box (it's the registry default).
- */
-import type { Prober, ProbeResult } from './port'
-
-export interface HttpProberConfig {
-  /** Per-probe timeout in ms (default 10000). */
-  timeoutMs?: number
-}
-
-const DEFAULT_TIMEOUT_MS = 10_000
-
-/** Build the keyless HTTP prober (a `GET` with a timeout). */
-export function createHttpProber(config: HttpProberConfig = {}): Prober {
-  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS
-  return {
-    async probe(url): Promise<ProbeResult> {
-      const start = Date.now()
-      try {
-        const res = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(timeoutMs) })
-        return { statusCode: res.status, latencyMs: Date.now() - start }
-      } catch {
-        // Unreachable / timeout / DNS failure — a `down` result, not an error.
-        return { statusCode: 0, latencyMs: Date.now() - start }
-      }
-    },
-  }
-}

package/template/integrations/prober/mock.ts

@@ -1,18 +0,0 @@
-/**
- * Mock prober — offline + deterministic, no network. Used by tests (construct it
- * directly with the status you want) and by `PROBER=mock` for an offline dev
- * loop. Returns a fixed result regardless of URL.
- */
-import type { Prober, ProbeResult } from './port'
-
-/** Build an offline prober that always returns `opts` (default: a healthy 200). */
-export function createMockProber(opts: { statusCode?: number; latencyMs?: number } = {}): Prober {
-  const statusCode = opts.statusCode ?? 200
-  const latencyMs = opts.latencyMs ?? 1
-  const result: ProbeResult = { statusCode, latencyMs }
-  return {
-    probe() {
-      return Promise.resolve(result)
-    },
-  }
-}

package/template/integrations/prober/port.ts

@@ -1,26 +0,0 @@
-/**
- * Prober — the PORT between the domain's logic and whatever performs the actual
- * uptime probe. This is the external-API seam every real domain has, reduced to
- * the narrowest interface the logic needs.
- *
- * `runtime/` logic depends on THIS interface only — never on `fetch`, an SDK, or
- * `env`. Adapters in this folder implement it: `http.ts` (a real, keyless HTTP
- * request) and `mock.ts` (offline + deterministic, for tests). The registry
- * picks one from `env`; the handler logic only ever sees the resolved port. Swap
- * or add a backend = one adapter + one arm in `registry.ts`.
- */
-export interface ProbeResult {
-  /** Observed HTTP status code, or `0` if the host was unreachable. */
-  statusCode: number
-  /** Round-trip time in ms. */
-  latencyMs: number
-}
-
-export interface Prober {
-  /**
-   * Probe a URL once. MUST resolve, never reject: an unreachable host or a
-   * timeout is a `down` RESULT (`statusCode: 0`), not an error — a probe failing
-   * is the normal case a monitor exists to observe.
-   */
-  probe(url: string): Promise<ProbeResult>
-}

package/template/integrations/prober/registry.ts

@@ -1,65 +0,0 @@
-/**
- * Prober registry — the ONE place the worker env (and the probed node) become the
- * live `Prober` port. Adding a backend = one more arm in `selectProber`; handler
- * logic only ever sees the resolved port.
- *
- * Resolution is PER-REQUEST and PER-NODE: each `prober(target)` call selects +
- * builds the port from env AND the monitor being probed — nothing is built at
- * `deps()` / isolate setup. A per-node choice can't be memoized at the isolate
- * level, which is exactly why `deps` exposes `prober()` as a FUNCTION, not a
- * value. The default is the keyless `http` prober (so the scaffold makes a real
- * probe out of the box); `PROBER=mock` forces the offline prober.
- */
-import type { Env } from '../../env'
-import type { Prober } from './port'
-
-import { createHttpProber } from './http'
-import { createMockProber } from './mock'
-
-/**
- * The node a probe is for — what the registry may branch on. Mirrors how the
- * `services` domain picks a provider from a node's class; here we also look at
- * the target url. The handler passes this from `self.node()`; omit it for
- * node-less callers (e.g. `seed`, which just wants the env default).
- */
-export interface ProbeTarget {
-  /** The monitor node's class path (`node.class.raw`). */
-  class: string
-  /** The url this monitor probes (`node.props[MONITOR_KEYS.url]`). */
-  url: string
-}
-
-export interface ProberRegistry {
-  /** Resolve the prober for a probe — built per call from env + the target node. */
-  prober(target?: ProbeTarget): Prober
-}
-
-/** Build the registry from the worker env. The port is resolved per request. */
-export function buildProberRegistry(env: Env): ProberRegistry {
-  return {
-    prober(target) {
-      return selectProber(env, target)
-    },
-  }
-}
-
-/** Bind the abstract prober port to the concrete adapter for this env + target. */
-function selectProber(env: Env, target?: ProbeTarget): Prober {
-  if (target && isLocalTarget(target.url)) {
-    return createMockProber()
-  }
-  // Default: the real, keyless HTTP prober. Pass the env override (if any); the
-  // adapter owns the default timeout, so there's no second copy of it here.
-  return createHttpProber({ timeoutMs: parsePositiveInt(env.PROBE_TIMEOUT_MS) })
-}
-
-/** A loopback / unspecified host the public edge can't reach. */
-function isLocalTarget(url: string): boolean {
-  return /^https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(:|\/|$)/i.test(url)
-}
-
-function parsePositiveInt(value: string | undefined): number | undefined {
-  if (!value) return undefined
-  const n = Number.parseInt(value, 10)
-  return Number.isFinite(n) && n > 0 ? n : undefined
-}

package/template/runtime/monitoring/index.ts

@@ -1,8 +0,0 @@
-/**
- * Monitoring runtime context — method implementations grouped by the domain
- * slice they serve. `runtime/index.ts` wires these into SDK method handlers.
- */
-import * as monitor from './monitor'
-import * as page from './page'
-
-export { monitor, page }

package/template/runtime/monitoring/monitor/check.ts

@@ -1,29 +0,0 @@
-import type { Prober } from '../../../integrations/prober/port'
-import type { CallableKernel } from '../../shared'
-
-/**
- * `Monitor.check` (instance) — implements `Checkable.check` for a single endpoint:
- * probe the target via the resolved `Prober` port, classify (pure, `core/monitor`),
- * record status/latency on the node, and return the verdict. `url` + `prober` are
- * resolved by the wiring (`runtime/index.ts`) from `self.node()`.
- */
-import { classify, MONITOR_KEYS } from '../../../core/monitor'
-
-export async function check(
-  kernel: CallableKernel,
-  prober: Prober,
-  selfPathRaw: string,
-  url: string,
-): Promise<{ status: string }> {
-  const result = await prober.probe(url)
-  const status = classify(result.statusCode)
-  await kernel.call(`${selfPathRaw}::update`, {
-    props: {
-      [MONITOR_KEYS.status]: status,
-      [MONITOR_KEYS.statusCode]: result.statusCode,
-      [MONITOR_KEYS.latencyMs]: result.latencyMs,
-      [MONITOR_KEYS.lastCheckedAt]: new Date().toISOString(),
-    },
-  })
-  return { status }
-}

package/template/runtime/monitoring/monitor/index.ts

@@ -1,10 +0,0 @@
-/**
- * Monitor operations inside the monitoring bounded context — one file per
- * method, assembled here for the composition root (`runtime/index.ts`). Each is
- * transport-agnostic logic over a
- * `CallableKernel` (+ the `Prober` port where it probes), delegating pure
- * decisions to `core/monitor` — so all are unit-testable with fakes.
- */
-export { check } from './check'
-export { seed } from './seed'
-export { watch } from './watch'

package/template/runtime/monitoring/monitor/seed.ts

@@ -1,104 +0,0 @@
-import type { Prober } from '../../../integrations/prober/port'
-
-/**
- * The domain's post-install bootstrap — exposed as the standalone `seed` function
- * (`functions/`) and wired as `postInstall` in `domain.ts`. The kernel calls it
- * ONCE after install, as __SYSTEM__, so the
- * domain comes up demonstrable: a `/monitoring` folder, `/monitoring/monitors`
- * starter Monitors (each probed once), and `/monitoring/pages/status`, a
- * StatusPage that `watches` them (its initial status rolled up from the probes).
- * Idempotent: node creates swallow `PATH_CONFLICT` (fixed paths) and re-linking
- * a `watches` edge is a graph no-op.
- * It grants nothing — the installing owner reaches these nodes via root-propagated
- * perms; grant explicitly here for non-owner access.
- */
-import {
-  classify,
-  FOLDER_CLASS,
-  MONITOR_CLASS,
-  MONITOR_KEYS,
-  MONITORING_PARENT,
-  MONITORS_PARENT,
-  NAME_KEY,
-  NODE_CREATE,
-  rollup,
-  STARTER_PAGE,
-  STARTERS,
-  STATUS_PAGE_CLASS,
-  STATUS_PAGES_PARENT,
-  PAGE_KEYS,
-  WATCHES_EDGE,
-  WATCHES_KEYS,
-} from '../../../core/monitor'
-import { type CallableKernel, isPathConflict } from '../../shared'
-
-/** Create a node, swallowing a re-seed's `PATH_CONFLICT`. Returns true if newly created. */
-async function ensure(kernel: CallableKernel, params: unknown): Promise<boolean> {
-  try {
-    await kernel.call(NODE_CREATE, params)
-    return true
-  } catch (e) {
-    if (!isPathConflict(e)) throw e
-    return false
-  }
-}
-
-export async function seed(kernel: CallableKernel, prober: Prober): Promise<{ seeded: number }> {
-  await ensure(kernel, {
-    class: FOLDER_CLASS,
-    path: MONITORING_PARENT,
-    props: { [NAME_KEY]: 'monitoring' },
-  })
-
-  await ensure(kernel, {
-    class: FOLDER_CLASS,
-    path: MONITORS_PARENT,
-    props: { [NAME_KEY]: 'monitors' },
-  })
-
-  // Probe + create each starter Monitor; collect the verdict for the page roll-up.
-  const members: { status: string; critical: boolean }[] = []
-  let seeded = 0
-  for (const s of STARTERS) {
-    const result = await prober.probe(s.url)
-    const status = classify(result.statusCode)
-    members.push({ status, critical: s.critical })
-    const created = await ensure(kernel, {
-      class: MONITOR_CLASS,
-      path: `${MONITORS_PARENT}/${s.slug}`,
-      props: {
-        [NAME_KEY]: s.name,
-        [MONITOR_KEYS.url]: s.url,
-        [MONITOR_KEYS.status]: status,
-        [MONITOR_KEYS.statusCode]: result.statusCode,
-        [MONITOR_KEYS.latencyMs]: result.latencyMs,
-        [MONITOR_KEYS.lastCheckedAt]: new Date().toISOString(),
-      },
-    })
-    if (created) seeded++
-  }
-
-  // A StatusPage watching every starter, its status rolled up from the probes.
-  await ensure(kernel, {
-    class: FOLDER_CLASS,
-    path: STATUS_PAGES_PARENT,
-    props: { [NAME_KEY]: 'pages' },
-  })
-  const pagePath = `${STATUS_PAGES_PARENT}/${STARTER_PAGE.slug}`
-  await ensure(kernel, {
-    class: STATUS_PAGE_CLASS,
-    path: pagePath,
-    props: { [NAME_KEY]: STARTER_PAGE.name, [PAGE_KEYS.status]: rollup(members) },
-  })
-  // Re-linking the same (page, monitor) `watches` edge is a graph no-op, so this
-  // needs no conflict guard.
-  for (const s of STARTERS) {
-    await kernel.call(`${pagePath}::link`, {
-      edgeClass: WATCHES_EDGE,
-      target: `${MONITORS_PARENT}/${s.slug}`,
-      props: { [WATCHES_KEYS.critical]: s.critical },
-    })
-  }
-
-  return { seeded }
-}

package/template/runtime/monitoring/monitor/watch.ts

@@ -1,31 +0,0 @@
-/**
- * `Monitor.watch` (static) — create a Monitor node under `/monitoring/monitors`.
- * The slug format is pure (`core/monitor`'s `uniqueSlug`); the entropy suffix
- * (impure, clock/RNG) comes from `runtime/shared`, keeping core deterministic.
- */
-import {
-  MONITOR_CLASS,
-  MONITOR_KEYS,
-  MONITORS_PARENT,
-  NAME_KEY,
-  NODE_CREATE,
-  uniqueSlug,
-} from '../../../core/monitor'
-import { type CallableKernel, randomSuffix } from '../../shared'
-
-export async function watch(
-  kernel: CallableKernel,
-  params: { url: string; name?: string },
-): Promise<{ id: string; path: string }> {
-  const path = `${MONITORS_PARENT}/${uniqueSlug(params.url, randomSuffix())}`
-  const created = (await kernel.call(NODE_CREATE, {
-    class: MONITOR_CLASS,
-    path,
-    props: {
-      [NAME_KEY]: params.name ?? params.url,
-      [MONITOR_KEYS.url]: params.url,
-      [MONITOR_KEYS.status]: 'unknown',
-    },
-  })) as { id: string }
-  return { id: created.id, path }
-}

package/template/runtime/monitoring/page/add.ts

@@ -1,21 +0,0 @@
-import type { CallableKernel } from '../../shared'
-
-/**
- * `StatusPage.add` (instance) — watch a Monitor: create a `watches` edge from
- * this page to `monitor`, tagged `critical` (default false). `monitor` is any
- * node address (a tree path or `@<id>`).
- */
-import { WATCHES_EDGE, WATCHES_KEYS } from '../../../core/monitor'
-
-export async function add(
-  kernel: CallableKernel,
-  selfPathRaw: string,
-  params: { monitor: string; critical?: boolean },
-): Promise<{ watched: string }> {
-  await kernel.call(`${selfPathRaw}::link`, {
-    edgeClass: WATCHES_EDGE,
-    target: params.monitor,
-    props: { [WATCHES_KEYS.critical]: params.critical ?? false },
-  })
-  return { watched: params.monitor }
-}

package/template/runtime/monitoring/page/check.ts

@@ -1,50 +0,0 @@
-import type { CallableKernel } from '../../shared'
-
-/**
- * `StatusPage.check` (instance) — implements `Checkable.check` for a page: walk
- * the `watches` edges, re-check each monitor (a cross-node `@<id>::check` call),
- * roll the verdicts up (pure, `core/monitor`), record the page status, return it.
- *
- * `getLinks` returns raw `Edge`s whose endpoint/prop accessors aren't typed yet
- * (an SDK gap) — `parseWatches` is the small cast that bridges it.
- */
-import { PAGE_KEYS, rollup, WATCHES_EDGE, WATCHES_KEYS } from '../../../core/monitor'
-
-/** A raw `watches` edge as `getLinks` returns it (endpoints are string-or-`{raw}`). */
-type RawEdge = {
-  class?: string | { raw: string }
-  target?: string | { raw: string }
-  props?: Record<string, unknown>
-}
-
-function rawOf(p: RawEdge['target']): string | undefined {
-  if (typeof p === 'string') return p
-  return typeof p?.raw === 'string' ? p.raw : undefined
-}
-
-/** The monitors this page watches: each target ref + its `critical` flag. */
-function parseWatches(raw: unknown): { monitor: string; critical: boolean }[] {
-  const edges = (Array.isArray(raw) ? raw : []) as RawEdge[]
-  const out: { monitor: string; critical: boolean }[] = []
-  for (const e of edges) {
-    if (rawOf(e.class) !== WATCHES_EDGE) continue
-    const monitor = rawOf(e.target)
-    if (monitor) out.push({ monitor, critical: e.props?.[WATCHES_KEYS.critical] === true })
-  }
-  return out
-}
-
-export async function check(
-  kernel: CallableKernel,
-  selfPathRaw: string,
-): Promise<{ status: string }> {
-  const links = await kernel.call(`${selfPathRaw}::getLinks`, { direction: 'out' })
-  const members = []
-  for (const w of parseWatches(links)) {
-    const { status } = (await kernel.call(`${w.monitor}::check`, {})) as { status: string }
-    members.push({ status, critical: w.critical })
-  }
-  const status = rollup(members)
-  await kernel.call(`${selfPathRaw}::update`, { props: { [PAGE_KEYS.status]: status } })
-  return { status }
-}

package/template/runtime/monitoring/page/create.ts

@@ -1,24 +0,0 @@
-/**
- * `StatusPage.create` (static) — create a StatusPage node under `/monitoring/pages`.
- */
-import {
-  NAME_KEY,
-  NODE_CREATE,
-  STATUS_PAGE_CLASS,
-  STATUS_PAGES_PARENT,
-  uniqueSlug,
-} from '../../../core/monitor'
-import { type CallableKernel, randomSuffix } from '../../shared'
-
-export async function create(
-  kernel: CallableKernel,
-  params: { name: string },
-): Promise<{ id: string; path: string }> {
-  const path = `${STATUS_PAGES_PARENT}/${uniqueSlug(params.name, randomSuffix())}`
-  const created = (await kernel.call(NODE_CREATE, {
-    class: STATUS_PAGE_CLASS,
-    path,
-    props: { [NAME_KEY]: params.name },
-  })) as { id: string }
-  return { id: created.id, path }
-}

package/template/runtime/monitoring/page/index.ts

@@ -1,9 +0,0 @@
-/**
- * StatusPage operations inside the monitoring bounded context — one file per
- * method, assembled here for the composition root (`runtime/index.ts`).
- * Transport-agnostic logic over a `CallableKernel`, delegating the roll-up
- * decision to `core/monitor`.
- */
-export { add } from './add'
-export { check } from './check'
-export { create } from './create'

package/template/runtime/shared.ts

@@ -1,21 +0,0 @@
-/**
- * Runtime-internal helpers shared across the context's operations. Not exported
- * from the domain — just the seam the operation files agree on.
- */
-
-/**
- * The minimal kernel surface the operations need — kept narrow so each is
- * unit-testable with a fake `{ call }`. The SDK hands the real client at the
- * `runtime/index.ts` seam.
- */
-export type CallableKernel = { call(path: string, params: unknown): Promise<unknown> }
-
-/** True for the kernel's create-collision error — lets `seed` stay idempotent. */
-export function isPathConflict(e: unknown): boolean {
-  return e instanceof Error && e.message.includes('PATH_CONFLICT')
-}
-
-/** Short clock+RNG entropy to dodge same-ms / same-stem slug collisions (impure). */
-export function randomSuffix(): string {
-  return `${Date.now().toString(36).slice(-4)}${Math.random().toString(36).slice(2, 6)}`
-}

package/template/schema/monitor.ts

@@ -1,92 +0,0 @@
-/**
- * Monitoring context — the domain's single bounded slice: a `Checkable` contract
- * implemented by two classes, plus the edge that binds them.
- *
- *   - Interface `Checkable`   one `abstract` method, `check()`. Abstract → each
- *                             implementing class brings its OWN body, and the
- *                             kernel dispatches by the node's class.
- *   - Class `Monitor`         a single HTTP check. `check()` probes `url`;
- *                             `watch` creates one. (The demo set is laid down by
- *                             the standalone `seed` function — see `functions/`.)
- *   - Class `StatusPage`      a roll-up. `check()` re-checks the monitors it
- *                             `watches` and aggregates; `create` makes a page;
- *                             `add` watches a monitor.
- *   - Edge `watches`          StatusPage → Monitor, with a `critical` flag.
- */
-import { edgeClass, nodeClass, nodeInterface } from '@astrale-os/kernel-core'
-import { fn } from '@astrale-os/kernel-dsl'
-import { z } from 'zod'
-
-/** Thin ref to a created node — what the static factories return (a full Node
- *  value does not round-trip over the worker wire). */
-export const NodeRef = z.object({ id: z.string(), path: z.string() })
-
-/** What `check()` reports — the subject's current health verdict. */
-export const CheckResult = z.object({ status: z.string() })
-
-export const Checkable = nodeInterface({
-  methods: {
-    // `abstract` → no shared body; every implementer supplies its own `check`,
-    // wired per-class in `runtime/`. `@<node>::check` dispatches by the node's class.
-    check: fn({ inheritance: 'abstract', returns: CheckResult }),
-  },
-})
-
-export const Monitor = nodeClass({
-  implements: [Checkable],
-  props: {
-    /** The target URL this monitor probes. */
-    url: z.string(),
-    // Live status, written by `check`. PLAIN STRING, not `z.enum()`: `::update`
-    // silently drops `z.enum()` props. Values: 'up' | 'down' | 'unknown'.
-    status: z.string().optional(),
-    /** Last observed HTTP status code (0 = host unreachable). */
-    statusCode: z.number().int().optional(),
-    /** Last observed round-trip latency, in ms. */
-    latencyMs: z.number().int().optional(),
-    /** ISO timestamp of the last check. */
-    lastCheckedAt: z.string().optional(),
-  },
-  methods: {
-    // Implements `Checkable.check` for a single endpoint (probe `url`). Redeclared
-    // here — a concrete class must declare each abstract method it implements, so
-    // the compiler materializes Monitor's OWN `check` node for per-class dispatch.
-    // The body lives in `runtime/monitoring/monitor/check.ts`.
-    check: fn({ returns: CheckResult }),
-    /** Create a Monitor under `/monitoring/monitors`. */
-    watch: fn({
-      static: true,
-      params: { url: z.string(), name: z.string().optional() },
-      returns: NodeRef,
-    }),
-  },
-})
-
-export const StatusPage = nodeClass({
-  implements: [Checkable],
-  props: {
-    /** Rolled-up status, written by `check`. 'up' | 'degraded' | 'down' | 'unknown'. */
-    status: z.string().optional(),
-  },
-  methods: {
-    // Implements `Checkable.check` for a page (roll up the watched monitors).
-    // Redeclared so StatusPage materializes its OWN `check` node. Body in
-    // `runtime/monitoring/page/check.ts`.
-    check: fn({ returns: CheckResult }),
-    /** Create a StatusPage under `/monitoring/pages`. */
-    create: fn({ static: true, params: { name: z.string() }, returns: NodeRef }),
-    /** Watch a monitor (a `watches` edge); `critical` decides the roll-up weight. */
-    add: fn({
-      params: { monitor: z.string(), critical: z.boolean().optional() },
-      returns: z.object({ watched: z.string() }),
-    }),
-  },
-})
-
-export const watches = edgeClass(
-  { as: 'page', types: [StatusPage] },
-  { as: 'monitor', types: [Monitor] },
-  // `critical` drives the roll-up: a critical monitor down ⇒ page `down`; a
-  // non-critical one down ⇒ `degraded`.
-  { props: { critical: z.boolean() } },
-)