@astrale-os/adapter-cloudflare 0.1.10 → 0.2.0

package/template/client/src/shell/view-router.tsx

@@ -2,7 +2,7 @@
  * Tiny multi-view router for the domain's one SPA bundle.
  *
  * The domain declares several SPA Views, each mounted by the shell at its own
- * path under `/ui/*` (e.g. `/ui/monitor`). The shell mounts ONE iframe per view,
+ * path under `/ui/*` (e.g. `/ui/status-page`). The shell mounts ONE iframe per view,
  * so inside the iframe `window.location.pathname` is that view's mount path. This
  * bundle reads that path and renders the matching view — one build, many views.
  *
@@ -16,16 +16,15 @@
  * matching `defineView({ mount })` in the domain's `views/`.
  */
 
-import type { ReactNode } from 'react'
-
 import type { KernelClient } from '@astrale-os/shell'
+import type { ReactNode } from 'react'
 
 import type { ShellState } from './use-shell'
 
 /** A view: given the shell state, render its tree. */
 export type ViewComponent = (shell: ShellState) => ReactNode
 
-/** Mount path → view component (key e.g. `/ui/monitor`). */
+/** Mount path → view component (key e.g. `/ui/status-page`). */
 export type ViewRoutes = Record<string, ViewComponent>
 
 /** Strip a single trailing slash (but keep a bare `/`). */

package/template/client/src/status/components/StatusCard.tsx

@@ -0,0 +1,50 @@
+/**
+ * StatusCard — the status feature's one container. It owns the data/logic: loads
+ * the node (`useCheckable`), wires the `check` write (`useCheck`), and composes
+ * the presentation. Handles the query's loading/error/ok states; on `ok` it
+ * renders a `Panel` with the check-error banner (if any) + the StatusBadge.
+ * "Check now" runs the check then reloads the node so the fresh status renders.
+ *
+ * The generic surfaces come from the `@/ui` design system; the only domain-shaped
+ * primitive is the shared `StatusBadge`.
+ */
+import type { KernelClient } from '@/shell'
+
+import { ErrorBanner, Panel, Spinner, StatusBadge } from '@/ui'
+
+import { useCheck, useCheckable } from '../hooks'
+
+export function StatusCard({ session, nodeId }: { session: KernelClient; nodeId: string }) {
+  const checkable = useCheckable(session, nodeId)
+  const check = useCheck(session, nodeId)
+
+  async function checkNow() {
+    if (await check.run()) checkable.reload()
+  }
+
+  if (checkable.state === 'idle' || checkable.state === 'loading') {
+    return <Spinner label="Loading…" />
+  }
+  if (checkable.state === 'error') {
+    return <ErrorBanner>Failed to load: {checkable.message}</ErrorBanner>
+  }
+
+  const record = checkable.record!
+  const checking = check.phase === 'running'
+  const checkButton = (
+    <button type="button" className="check-btn" onClick={checkNow} disabled={checking}>
+      {checking ? 'Checking…' : 'Check now'}
+    </button>
+  )
+
+  return (
+    <Panel title={record.name} actions={checkButton}>
+      {check.phase === 'failed' && check.error && (
+        <ErrorBanner>Check failed: {check.error}</ErrorBanner>
+      )}
+      <div className="status-row">
+        <StatusBadge status={record.status} />
+      </div>
+    </Panel>
+  )
+}

package/template/client/src/status/components/index.ts

@@ -0,0 +1 @@
+export { StatusCard } from './StatusCard'

package/template/client/src/status/hooks/index.ts

@@ -0,0 +1,3 @@
+export { useCheckable } from './useCheckable.query'
+export type { CheckableQuery } from './useCheckable.query'
+export { useCheck } from './useCheck.mutation'

package/template/client/src/{monitor → status}/hooks/useCheck.mutation.ts

@@ -1,7 +1,7 @@
-/** Run a Monitor's `check` probe — the feature's one write capability. */
+/** Run a checkable node's `check` — the feature's one write capability. */
 import { type Capability, type KernelClient, useCapability } from '@/shell'
 
-import { check } from '../monitor.api'
+import { check } from '../status.api'
 
 /**
  * Wrap `@<id>::check` in the shared `useCapability` lifecycle (idle → running →

package/template/client/src/{monitor/hooks/useMonitor.query.ts → status/hooks/useCheckable.query.ts}

@@ -1,17 +1,17 @@
-/** Load a Monitor node → typed record, with a `reload()` for post-check refresh. */
+/** Load a checkable node → typed record, with a `reload()` for post-check refresh. */
 import { useCallback, useRef, useState } from 'react'
 
 import { type KernelClient, useNode } from '@/shell'
 
-import type { MonitorRecord } from '../monitor.types'
+import type { CheckableRecord } from '../status.types'
 
-import { monitorFromNode } from '../monitor.mappers'
+import { checkableFromNode } from '../status.mappers'
 
-export type MonitorQuery = {
+export type CheckableQuery = {
   /** Lifecycle of the underlying `@<id>::get`. */
   state: 'idle' | 'loading' | 'error' | 'ok'
   /** The projected record once `ok`. */
-  record?: MonitorRecord
+  record?: CheckableRecord
   /** Failure message once `error`. */
   message?: string
   /** Re-fetch the node — call after `check` mutates it server-side. */
@@ -21,13 +21,13 @@ export type MonitorQuery = {
 }
 
 /**
- * Load the Monitor node `nodeId` and project it to a `MonitorRecord`. Wraps
+ * Load the checkable node `nodeId` and project it to a `CheckableRecord`. Wraps
  * `useNode` (which owns the `@<id>::get` + the hot-swap re-fetch) and re-exposes
  * its `reload()` so the view can refresh after a `check`. `reloading` is true
  * from the moment `reload()` is called until the re-fetch settles — distinct from
  * the initial `loading`, so the view can show the existing record meanwhile.
  */
-export function useMonitor(session: KernelClient, nodeId: string): MonitorQuery {
+export function useCheckable(session: KernelClient, nodeId: string): CheckableQuery {
   const node = useNode(session, nodeId)
   const [reloading, setReloading] = useState(false)
   // Two-phase reload tracker. `reload()` arms it as `'requested'`; once we
@@ -53,7 +53,7 @@ export function useMonitor(session: KernelClient, nodeId: string): MonitorQuery
 
   switch (node.status) {
     case 'ok':
-      return { state: 'ok', record: monitorFromNode(node.node), reload, reloading }
+      return { state: 'ok', record: checkableFromNode(node.node), reload, reloading }
     case 'error':
       return { state: 'error', message: node.message, reload, reloading }
     case 'loading':

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

@@ -0,0 +1,7 @@
+/** The status feature — its api, types, mappers, hooks and components. One card,
+ * polymorphic over any `Checkable` node (Monitor or StatusPage). */
+export * from './components'
+export * from './hooks'
+export { check } from './status.api'
+export { checkableFromNode } from './status.mappers'
+export type { CheckableRecord } from './status.types'

package/template/client/src/status/status.api.ts

@@ -0,0 +1,12 @@
+/** Raw kernel calls for the status feature — node instance methods. */
+import { invokeNode, type KernelClient } from '@/shell'
+
+/**
+ * Run a checkable node's `check` instance method (`@<id>::check`). The single
+ * write both classes share: a Monitor probes its target URL, a StatusPage rolls
+ * its watched monitors up — each updates its own `status` prop server-side; the
+ * caller reloads the node to render the fresh value.
+ */
+export function check(session: KernelClient, nodeId: string): Promise<unknown> {
+  return invokeNode(session, nodeId, 'check', {})
+}

package/template/client/src/status/status.mappers.ts

@@ -0,0 +1,19 @@
+/** Node → typed record transform for the status feature. */
+import { type KernelNode, PROP, readProp, readPropBySuffix } from '@/shell'
+
+import type { CheckableRecord } from './status.types'
+
+const lastSegment = (path: string): string => path.split('/').filter(Boolean).pop() ?? path
+
+/**
+ * Project a `Checkable` `KernelNode` into a `CheckableRecord`: the name from the
+ * kernel `Named.name` key, the domain-qualified `status` read by suffix (default
+ * `'unknown'`).
+ */
+export function checkableFromNode(node: KernelNode): CheckableRecord {
+  const p = node.props ?? {}
+  return {
+    name: readProp(p, PROP.named.name) ?? lastSegment(node.path ?? '') ?? node.id,
+    status: readPropBySuffix(p, '.property.status') ?? 'unknown',
+  }
+}

package/template/client/src/status/status.types.ts

@@ -0,0 +1,11 @@
+/** The status feature's client type — what a `Checkable` node projects to. */
+
+/**
+ * Client-side projection of the `Checkable` node the view renders (a StatusPage).
+ * `status` stays a plain string — the page's rolled-up verdict
+ * (up/degraded/down/unknown), which `StatusBadge` renders.
+ */
+export type CheckableRecord = {
+  name: string
+  status: string
+}

package/template/client/src/styles.css

@@ -13,6 +13,7 @@
   --err: #dc2626;
   --err-soft: rgba(220, 38, 38, 0.1);
   --up: #16a34a;
+  --degraded: #d97706;
   --down: #dc2626;
   --unknown: #737373;
   --mono: ui-monospace, SFMono-Regular, Menlo, monospace;
@@ -198,6 +199,10 @@ body {
   background: var(--up);
 }
 
+.status-degraded {
+  background: var(--degraded);
+}
+
 .status-down {
   background: var(--down);
 }

package/template/client/src/ui/StatusBadge.tsx

@@ -0,0 +1,31 @@
+/** Health status chip — pure presentational; styling lives in `styles.css`. */
+
+/** The health vocabulary the badge styles, shared across checkable nodes. */
+export type HealthStatus = 'up' | 'down' | 'degraded' | 'unknown'
+
+/** Map any raw status string to the four styled states (unrecognized → unknown). */
+function normalize(status: string): HealthStatus {
+  return status === 'up' || status === 'down' || status === 'degraded' ? status : 'unknown'
+}
+
+/**
+ * Color-coded status pill: up = green, degraded = amber, down = red, unknown =
+ * muted. The label is the uppercased status (`UP` / `DEGRADED` / `DOWN` /
+ * `UNKNOWN`). Takes any raw status string — the vocabulary depends on the node
+ * type (up/down for a Monitor, up/degraded/down for a StatusPage) — and styles
+ * the four known states, falling back to `unknown` for anything else. Both
+ * checkable node types render through it, so it lives in the feature-agnostic
+ * `@/ui`, not a feature's own folder.
+ */
+export function StatusBadge({ status }: { status: string }) {
+  const known = normalize(status)
+  const label =
+    known === 'up'
+      ? 'UP'
+      : known === 'degraded'
+        ? 'DEGRADED'
+        : known === 'down'
+          ? 'DOWN'
+          : 'UNKNOWN'
+  return <span className={`status-badge status-${known}`}>{label}</span>
+}

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

@@ -1,9 +1,13 @@
 /**
  * The design system — generic, feature-AGNOSTIC presentational primitives +
- * display formatters, no domain knowledge and no kernel session. Feature-specific
- * UI (e.g. the Monitor's StatusBadge) lives in that feature's own `ui/`, not here.
+ * 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'`.
  */
 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/client/src/views/status.tsx

@@ -0,0 +1,28 @@
+/**
+ * The status view — the SPA's one view: the StatusPage panel at `/ui/status-page`.
+ * Mounted by the Astrale shell as a sandboxed iframe; `@/shell` (built on the real
+ * `@astrale-os/shell`) completes the handshake and hands over the kernel session +
+ * the target node id. `ViewFrame` gates the handshake (loading / standalone /
+ * ready); the `ready` body delegates to `StatusCard`, the feature container that
+ * loads the node, renders its rolled-up status, and exposes a "Check now" action.
+ *
+ * Pure composition — no data/transport logic lives here (that's `@/status` +
+ * `@/shell`).
+ */
+import { type ShellState, ViewFrame } from '@/shell'
+import { StatusCard } from '@/status'
+
+export function StatusView(shell: ShellState) {
+  return (
+    <ViewFrame shell={shell} title="Status" subline="astrale view">
+      {(session, nodeId) =>
+        nodeId ? (
+          // Keyed by node id so a target hot-swap remounts with fresh state.
+          <StatusCard key={nodeId} session={session} nodeId={nodeId} />
+        ) : (
+          <div className="banner">No target node — open this view from a StatusPage.</div>
+        )
+      }
+    </ViewFrame>
+  )
+}

package/template/client/vite.config.ts

@@ -1,6 +1,5 @@
-import { fileURLToPath } from 'node:url'
-
 import viteReact from '@vitejs/plugin-react'
+import { fileURLToPath } from 'node:url'
 import { defineConfig } from 'vite'
 
 /**
@@ -18,7 +17,7 @@ import { defineConfig } from 'vite'
  * negotiation, redirect following, delegation — all handled by the SDK).
  *
  * `@` is aliased to `src/` (mirrors tsconfig `paths`) so feature code imports
- * `@/shell`, `@/ui`, `@/monitor`.
+ * `@/shell`, `@/ui`, `@/status`.
  */
 export default defineConfig({
   base: '/ui/',

package/template/client/vitest.config.ts

@@ -1,6 +1,5 @@
-import { fileURLToPath } from 'node:url'
-
 import viteReact from '@vitejs/plugin-react'
+import { fileURLToPath } from 'node:url'
 import { defineConfig } from 'vitest/config'
 
 /**

package/template/core/monitor/health.ts

@@ -1,8 +1,8 @@
 /**
- * Health logic — PURE status rule, no I/O. Maps an observed probe result to the
- * monitor's verdict. (Node identity/layout/seed data lives in `./node`; the
- * kernel reads/writes live in `runtime/monitor/`; the network probe behind the
- * `Prober` port in `integrations/prober/`.)
+ * Health logic — PURE status rules, no I/O. `classify` maps one probe's HTTP code
+ * to a monitor verdict; `rollup` aggregates a status page's watched monitors into
+ * a page verdict. (Node identity/layout/seed data lives in `./node`; the kernel
+ * reads/writes live in `runtime/`; the network probe behind the `Prober` port.)
  */
 
 /** A monitor's health verdict. `unknown` is the pre-first-check state. */
@@ -17,3 +17,18 @@ export function classify(statusCode: number): HealthStatus {
   if (statusCode >= 200 && statusCode < 400) return 'up'
   return 'down'
 }
+
+/** A status page's rolled-up verdict — `degraded` = only non-critical checks down. */
+export type PageStatus = 'up' | 'degraded' | 'down' | 'unknown'
+
+/**
+ * Roll up a page's watched monitors into a page verdict: a CRITICAL monitor down
+ * ⇒ `down`; any other monitor down ⇒ `degraded`; all up ⇒ `up`; none ⇒ `unknown`.
+ * Pure.
+ */
+export function rollup(members: readonly { status: string; critical: boolean }[]): PageStatus {
+  if (members.length === 0) return 'unknown'
+  const down = members.filter((m) => m.status === 'down')
+  if (down.some((m) => m.critical)) return 'down'
+  return down.length > 0 ? 'degraded' : 'up'
+}

package/template/core/monitor/keys.ts

@@ -15,9 +15,10 @@ 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 paths. */
+/** Domain class/edge paths. */
 export const MONITOR_CLASS = D.Monitor.path.class.raw
-export const DEPENDS_ON_EDGE = D.depends_on.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 = {
@@ -27,3 +28,14 @@ export const MONITOR_KEYS = {
   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,43 +1,41 @@
 /**
- * Monitor node identity — PURE domain constants + slug logic (no I/O): where
- * monitors live in the graph, how a new node's slug is formed, and the seed set.
- * `runtime/monitor/` consumes these. The IMPURE bits (the slug's entropy suffix,
- * the actual node writes) stay in `runtime/`, so this file is deterministic and
- * trivially testable.
+ * 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 Monitor nodes live in the graph — a domain layout choice (`seed` creates the folder). */
+/** Where each kind of node lives in the graph (domain layout; `seed` creates the folders). */
 export const MONITORS_PARENT = '/monitors'
+export const STATUS_PAGES_PARENT = '/status-pages'
 
-/**
- * Deterministic URL-safe stem for a monitor's node slug (host + path, lowercased,
- * non-alnum → `-`). Pure.
- */
-export function slugForUrl(url: string): string {
+/** Deterministic URL-/name-safe stem (lowercased, non-alnum → `-`, clamped). Pure. */
+export function slugify(text: string): string {
   return (
-    url
+    text
       .replace(/^https?:\/\//i, '')
       .toLowerCase()
       .replace(/[^a-z0-9]+/g, '-')
       .replace(/^-|-$/g, '')
-      .slice(0, 40) || 'monitor'
+      .slice(0, 40) || 'node'
   )
 }
 
 /**
- * Slug for a NEW monitor node: the url stem + a caller-supplied `suffix`. Pure —
- * `runtime/monitor/watch` injects the `suffix` (clock/RNG entropy for collision
- * safety) so core stays deterministic. `seed` doesn't use this (it pins fixed
- * slugs for idempotency); `watch` does.
+ * 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 monitorSlug(url: string, suffix: string): string {
-  return `${slugForUrl(url)}-${suffix}`
+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
 }
 
 /**
@@ -46,6 +44,14 @@ export interface StarterMonitor {
  * a real site. Fixed slugs keep `seed` idempotent across reinstalls.
  */
 export const STARTERS: readonly StarterMonitor[] = [
-  { slug: 'astrale', name: 'Astrale', url: 'https://astrale.ai' },
-  { slug: 'httpbin-200', name: 'httpbin (200)', url: 'https://httpbin.org/status/200' },
+  { slug: 'astrale', name: 'Astrale', url: 'https://astrale.ai', critical: true },
+  {
+    slug: 'httpbin-200',
+    name: 'httpbin (200)',
+    url: 'https://httpbin.org/status/200',
+    critical: false,
+  },
 ]
+
+/** The status page `seed` creates, watching every starter monitor. */
+export const STARTER_PAGE = { slug: 'status', name: 'Status' } as const

package/template/deps.ts

@@ -1,3 +1,5 @@
+import type { Env } from './env'
+
 /**
  * env → handler dependency container — the ONE place the worker env becomes the
  * typed `ctx.deps` every method reads. `defineDomain({ deps })` mounts it; the
@@ -14,7 +16,6 @@
  * of raw config — that's the whole point of this seam.
  */
 import { buildProberRegistry, type ProberRegistry } from './integrations/prober/registry'
-import type { Env } from './env'
 
 /** Typed dependency container handed to every method as `ctx.deps`. */
 export interface Deps extends ProberRegistry {}

package/template/integrations/prober/http.ts

@@ -8,35 +8,24 @@
 import type { Prober, ProbeResult } from './port'
 
 export interface HttpProberConfig {
-  /** Probe verb — `GET` (default) or the lighter `HEAD`. */
-  method?: 'GET' | 'HEAD'
   /** Per-probe timeout in ms (default 10000). */
   timeoutMs?: number
 }
 
 const DEFAULT_TIMEOUT_MS = 10_000
 
-/** Build the keyless HTTP prober. */
+/** Build the keyless HTTP prober (a `GET` with a timeout). */
 export function createHttpProber(config: HttpProberConfig = {}): Prober {
-  const method = config.method ?? 'GET'
   const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS
   return {
     async probe(url): Promise<ProbeResult> {
       const start = Date.now()
       try {
-        const res = await fetch(url, {
-          method,
-          redirect: 'follow',
-          signal: AbortSignal.timeout(timeoutMs),
-        })
-        return {
-          statusCode: res.status,
-          latencyMs: Date.now() - start,
-          ok: res.status >= 200 && res.status < 400,
-        }
+        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, ok: false }
+        return { statusCode: 0, latencyMs: Date.now() - start }
       }
     },
   }

package/template/integrations/prober/mock.ts

@@ -9,11 +9,7 @@ import type { Prober, ProbeResult } from './port'
 export function createMockProber(opts: { statusCode?: number; latencyMs?: number } = {}): Prober {
   const statusCode = opts.statusCode ?? 200
   const latencyMs = opts.latencyMs ?? 1
-  const result: ProbeResult = {
-    statusCode,
-    latencyMs,
-    ok: statusCode >= 200 && statusCode < 400,
-  }
+  const result: ProbeResult = { statusCode, latencyMs }
   return {
     probe() {
       return Promise.resolve(result)

package/template/integrations/prober/port.ts

@@ -14,8 +14,6 @@ export interface ProbeResult {
   statusCode: number
   /** Round-trip time in ms. */
   latencyMs: number
-  /** Convenience flag — `statusCode` in `[200, 400)`. */
-  ok: boolean
 }
 
 export interface Prober {

package/template/integrations/prober/registry.ts

@@ -43,15 +43,14 @@ export function buildProberRegistry(env: Env): ProberRegistry {
   }
 }
 
-const DEFAULT_TIMEOUT_MS = 10_000
-
 /** 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.
-  return createHttpProber({ timeoutMs: parseIntOr(env.PROBE_TIMEOUT_MS, DEFAULT_TIMEOUT_MS) })
+  // 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. */
@@ -59,8 +58,8 @@ function isLocalTarget(url: string): boolean {
   return /^https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(:|\/|$)/i.test(url)
 }
 
-function parseIntOr(value: string | undefined, fallback: number): number {
-  if (!value) return fallback
+function parsePositiveInt(value: string | undefined): number | undefined {
+  if (!value) return undefined
   const n = Number.parseInt(value, 10)
-  return Number.isFinite(n) && n > 0 ? n : fallback
+  return Number.isFinite(n) && n > 0 ? n : undefined
 }

package/template/package.json

@@ -14,7 +14,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@astrale-os/adapter-cloudflare": ">=0.1.10 <1.0.0",
+    "@astrale-os/adapter-cloudflare": ">=0.2.0 <1.0.0",
     "@astrale-os/kernel-core": ">=0.4.3 <1.0.0",
     "@astrale-os/kernel-dsl": ">=0.1.2 <1.0.0",
     "@astrale-os/sdk": ">=0.1.7 <1.0.0",