@astrale-os/adapter-cloudflare 0.2.1 → 0.3.0

package/template/runtime/index.ts

@@ -1,8 +1,8 @@
 /**
  * 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 per-operation I/O
- * functions in `runtime/monitor/` and `runtime/status-page/`. No business logic
+ * needs (the `Prober` port, the self node) and delegates to the monitoring
+ * bounded context in `runtime/monitoring/{monitor,page}`. No business logic
  * lives here.
  *
  * `check` is the `Checkable` interface method, declared `abstract`, so it is
@@ -19,8 +19,7 @@ import type { Deps } from '../deps'
 
 import { MONITOR_KEYS } from '../core/monitor'
 import { schema } from '../schema'
-import { check as monitorCheck, seed, watch } from './monitor'
-import { add, check as pageCheck, create } from './status-page'
+import { monitor, page } from './monitoring'
 
 const method = remoteMethod<Deps>()
 const classMethods = remoteClassMethods<Deps>()
@@ -34,21 +33,14 @@ const monitorCheckMethod = method(schema, 'Monitor', 'check', {
     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 monitorCheck(kernel, deps.prober({ class: node.class.raw, url }), self.path.raw, url)
+    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 watch(kernel, params)
-  },
-})
-
-const seedMethod = method(schema, 'Monitor', 'seed', {
-  authorize: async () => undefined,
-  execute: ({ kernel, deps }) => {
-    return seed(kernel, deps.prober())
+    return monitor.watch(kernel, params)
   },
 })
 
@@ -57,21 +49,21 @@ const seedMethod = method(schema, 'Monitor', 'seed', {
 const pageCheckMethod = method(schema, 'StatusPage', 'check', {
   authorize: async () => undefined,
   execute: ({ kernel, self }) => {
-    return pageCheck(kernel, self.path.raw)
+    return page.check(kernel, self.path.raw)
   },
 })
 
 const createMethod = method(schema, 'StatusPage', 'create', {
   authorize: async () => undefined,
   execute: ({ kernel, params }) => {
-    return create(kernel, params)
+    return page.create(kernel, params)
   },
 })
 
 const addMethod = method(schema, 'StatusPage', 'add', {
   authorize: async () => undefined,
   execute: ({ kernel, self, params }) => {
-    return add(kernel, self.path.raw, params)
+    return page.add(kernel, self.path.raw, params)
   },
 })
 
@@ -80,7 +72,6 @@ export const methods: SchemaMethodsImpl<typeof schema, Deps> = {
     Monitor: classMethods(schema, 'Monitor', {
       check: monitorCheckMethod,
       watch: watchMethod,
-      seed: seedMethod,
     }),
     StatusPage: classMethods(schema, 'StatusPage', {
       check: pageCheckMethod,

package/template/runtime/monitoring/index.ts

@@ -0,0 +1,8 @@
+/**
+ * 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/{monitor → monitoring/monitor}/check.ts

@@ -1,5 +1,5 @@
-import type { Prober } from '../../integrations/prober/port'
-import type { CallableKernel } from '../shared'
+import type { Prober } from '../../../integrations/prober/port'
+import type { CallableKernel } from '../../shared'
 
 /**
  * `Monitor.check` (instance) — implements `Checkable.check` for a single endpoint:
@@ -7,7 +7,7 @@ import type { CallableKernel } from '../shared'
  * 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'
+import { classify, MONITOR_KEYS } from '../../../core/monitor'
 
 export async function check(
   kernel: CallableKernel,

package/template/runtime/{monitor → monitoring/monitor}/index.ts

@@ -1,6 +1,7 @@
 /**
- * Monitor operations — one file per method, assembled here for the composition
- * root (`runtime/index.ts`). Each is transport-agnostic logic over a
+ * 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.
  */

package/template/runtime/{monitor → monitoring/monitor}/seed.ts

@@ -1,12 +1,14 @@
-import type { Prober } from '../../integrations/prober/port'
+import type { Prober } from '../../../integrations/prober/port'
 
 /**
- * `Monitor.seed` (static) — the domain's post-install bootstrap. The kernel calls
- * it ONCE after install, as __SYSTEM__ (see `postInstall` in `domain.ts`), so the
- * domain comes up demonstrable: a `/monitors` folder + starter Monitors (each
- * probed once), and a `/status-pages` folder + one 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.
+ * 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.
  */
@@ -15,6 +17,7 @@ import {
   FOLDER_CLASS,
   MONITOR_CLASS,
   MONITOR_KEYS,
+  MONITORING_PARENT,
   MONITORS_PARENT,
   NAME_KEY,
   NODE_CREATE,
@@ -26,8 +29,8 @@ import {
   PAGE_KEYS,
   WATCHES_EDGE,
   WATCHES_KEYS,
-} from '../../core/monitor'
-import { type CallableKernel, isPathConflict } from '../shared'
+} 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> {
@@ -41,6 +44,12 @@ async function ensure(kernel: CallableKernel, params: unknown): Promise<boolean>
 }
 
 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,
@@ -73,7 +82,7 @@ export async function seed(kernel: CallableKernel, prober: Prober): Promise<{ se
   await ensure(kernel, {
     class: FOLDER_CLASS,
     path: STATUS_PAGES_PARENT,
-    props: { [NAME_KEY]: 'status-pages' },
+    props: { [NAME_KEY]: 'pages' },
   })
   const pagePath = `${STATUS_PAGES_PARENT}/${STARTER_PAGE.slug}`
   await ensure(kernel, {

package/template/runtime/{monitor → monitoring/monitor}/watch.ts

@@ -1,7 +1,7 @@
 /**
- * `Monitor.watch` (static) — create a Monitor node under `/monitors`. The slug
- * format is pure (`core/monitor`'s `uniqueSlug`); the entropy suffix (impure,
- * clock/RNG) comes from `runtime/shared`, keeping core deterministic.
+ * `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,
@@ -10,8 +10,8 @@ import {
   NAME_KEY,
   NODE_CREATE,
   uniqueSlug,
-} from '../../core/monitor'
-import { type CallableKernel, randomSuffix } from '../shared'
+} from '../../../core/monitor'
+import { type CallableKernel, randomSuffix } from '../../shared'
 
 export async function watch(
   kernel: CallableKernel,

package/template/runtime/{status-page → monitoring/page}/add.ts

@@ -1,11 +1,11 @@
-import type { CallableKernel } from '../shared'
+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'
+import { WATCHES_EDGE, WATCHES_KEYS } from '../../../core/monitor'
 
 export async function add(
   kernel: CallableKernel,

package/template/runtime/{status-page → monitoring/page}/check.ts

@@ -1,4 +1,4 @@
-import type { CallableKernel } from '../shared'
+import type { CallableKernel } from '../../shared'
 
 /**
  * `StatusPage.check` (instance) — implements `Checkable.check` for a page: walk
@@ -8,7 +8,7 @@ import type { CallableKernel } from '../shared'
  * `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'
+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 = {

package/template/runtime/{status-page → monitoring/page}/create.ts

@@ -1,5 +1,5 @@
 /**
- * `StatusPage.create` (static) — create a StatusPage node under `/status-pages`.
+ * `StatusPage.create` (static) — create a StatusPage node under `/monitoring/pages`.
  */
 import {
   NAME_KEY,
@@ -7,8 +7,8 @@ import {
   STATUS_PAGE_CLASS,
   STATUS_PAGES_PARENT,
   uniqueSlug,
-} from '../../core/monitor'
-import { type CallableKernel, randomSuffix } from '../shared'
+} from '../../../core/monitor'
+import { type CallableKernel, randomSuffix } from '../../shared'
 
 export async function create(
   kernel: CallableKernel,

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

@@ -0,0 +1,9 @@
+/**
+ * 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/schema/monitor.ts

@@ -6,7 +6,8 @@
  *                             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; `seed` lays down the demo set.
+ *                             `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.
@@ -50,17 +51,14 @@ export const Monitor = nodeClass({
     // 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/monitor/check.ts`.
+    // The body lives in `runtime/monitoring/monitor/check.ts`.
     check: fn({ returns: CheckResult }),
-    /** Create a Monitor under `/monitors`. */
+    /** Create a Monitor under `/monitoring/monitors`. */
     watch: fn({
       static: true,
       params: { url: z.string(), name: z.string().optional() },
       returns: NodeRef,
     }),
-    // Post-install bootstrap (wired as `postInstall` in domain.ts). Static: the
-    // kernel calls it ONCE after install, as __SYSTEM__. Must stay idempotent.
-    seed: fn({ static: true, returns: z.object({ seeded: z.number().int() }) }),
   },
 })
 
@@ -73,9 +71,9 @@ export const StatusPage = nodeClass({
   methods: {
     // Implements `Checkable.check` for a page (roll up the watched monitors).
     // Redeclared so StatusPage materializes its OWN `check` node. Body in
-    // `runtime/status-page/check.ts`.
+    // `runtime/monitoring/page/check.ts`.
     check: fn({ returns: CheckResult }),
-    /** Create a StatusPage under `/status-pages`. */
+    /** 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({

package/template/views/index.ts

@@ -1,6 +1,6 @@
 /**
  * View registry — one file per view under `views/`, assembled here. Slug = map
- * key; each becomes a View node at `/<origin>/core/views/<slug>` whose iframe
+ * 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.
  *