alchemy 2.0.0-beta.18 → 2.0.0-beta.19

package/src/Axiom/Credentials.ts

@@ -0,0 +1,70 @@
+import {
+  Credentials,
+  DEFAULT_API_BASE_URL,
+} from "@distilled.cloud/axiom/Credentials";
+import { ConfigError } from "@distilled.cloud/core/errors";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Match from "effect/Match";
+import * as Redacted from "effect/Redacted";
+import * as Config from "effect/Config";
+import { getAuthProvider } from "../Auth/AuthProvider.ts";
+import { ALCHEMY_PROFILE, loadOrConfigure } from "../Auth/Profile.ts";
+import {
+  AXIOM_AUTH_PROVIDER_NAME,
+  type AxiomAuthConfig,
+  type AxiomResolvedCredentials,
+} from "./AuthProvider.ts";
+
+export {
+  Credentials,
+  CredentialsFromEnv,
+  DEFAULT_API_BASE_URL,
+} from "@distilled.cloud/axiom/Credentials";
+
+/**
+ * Build a `Credentials` layer that resolves Axiom credentials via the Alchemy
+ * AuthProvider using the configured profile (defaults to "default", overridable
+ * with the `ALCHEMY_PROFILE` env/config value).
+ */
+export const fromAuthProvider = () =>
+  Layer.effect(
+    Credentials,
+    Effect.gen(function* () {
+      const auth = yield* getAuthProvider<
+        AxiomAuthConfig,
+        AxiomResolvedCredentials
+      >(AXIOM_AUTH_PROVIDER_NAME);
+      const profileName = yield* ALCHEMY_PROFILE;
+      const ci = yield* Config.boolean("CI").pipe(Config.withDefault(false));
+      const ctx = yield* Effect.context<never>();
+
+      return yield* loadOrConfigure(auth, profileName, { ci }).pipe(
+        Effect.flatMap((config) =>
+          auth.read(profileName, config as AxiomAuthConfig),
+        ),
+        Effect.map((creds) =>
+          Match.value(creds).pipe(
+            Match.when({ type: "apiToken" }, (c) => ({
+              apiKey: c.apiToken,
+              apiBaseUrl: c.apiBaseUrl,
+              orgId: c.orgId,
+            })),
+            Match.when({ type: "pat" }, (c) => ({
+              apiKey: c.apiToken,
+              apiBaseUrl: c.apiBaseUrl,
+              orgId: c.orgId,
+            })),
+            Match.exhaustive,
+          ),
+        ),
+        Effect.mapError(
+          (e) =>
+            new ConfigError({
+              message: `Failed to resolve Axiom credentials for profile '${profileName}': ${(e as { message?: string }).message ?? String(e)}`,
+            }),
+        ),
+        Effect.provide(ctx),
+      );
+    }),
+  );

package/src/Axiom/Dashboard.ts

@@ -0,0 +1,192 @@
+import * as Operations from "@distilled.cloud/axiom/Operations";
+import * as Effect from "effect/Effect";
+import * as Provider from "../Provider.ts";
+import { Resource } from "../Resource.ts";
+import type { Chart, LayoutCell } from "./Chart.ts";
+import type { Providers } from "./Providers.ts";
+
+type DashboardDoc = Operations.CreateDashboardInput["dashboard"];
+
+/**
+ * Dashboard input. Mirrors `Operations.CreateDashboardInput` but
+ * narrows `dashboard.charts` and `dashboard.layout` to the typed
+ * {@link Chart} / {@link LayoutCell} shapes (Axiom declares them
+ * as `Schema.Array(Schema.Unknown)`, so this is a compile-time-only
+ * refinement; runtime validation is unchanged).
+ */
+export type DashboardProps = Omit<
+  Operations.CreateDashboardInput,
+  "dashboard"
+> & {
+  readonly dashboard: Omit<DashboardDoc, "charts" | "layout"> & {
+    readonly charts: readonly Chart[];
+    readonly layout: readonly LayoutCell[];
+  };
+};
+
+export type Dashboard = Resource<
+  "Axiom.Dashboard",
+  DashboardProps,
+  {
+    /** Stable Axiom dashboard `uid` (used as the path identifier). */
+    uid: string;
+    id: string;
+    createdAt: string;
+    createdBy: string;
+    updatedAt: string;
+    updatedBy: string;
+    /** The full dashboard document as returned by Axiom. */
+    dashboard: Operations.CreateDashboardOutput["dashboard"]["dashboard"];
+  },
+  never,
+  Providers
+>;
+
+/**
+ * An Axiom dashboard — a named, layout-driven collection of charts. Each
+ * dashboard takes a full document (`charts` + `layout` array of grid cells +
+ * `timeWindow` + `refreshTime`) at version `schemaVersion: 2`.
+ *
+ * Charts are typed via {@link Chart} (a discriminated union over the
+ * Axiom-validated chart kinds — `TimeSeries`, `Table`, `Pie`, `Statistic`,
+ * `Heatmap`, `LogStream`, `Note`). The `id` on each chart is a free-form
+ * string the author picks; layout cells join via `LayoutCell.i`.
+ *
+ * The path identifier is `uid` (auto-assigned by Axiom). `id` is also
+ * exposed as an output but the API uses `uid` everywhere.
+ *
+ * Notes from probing `POST /v2/dashboards`:
+ *
+ * - Relative time windows must use the `qr-now-{duration}` form (e.g.
+ *   `"qr-now-7d"` / `"qr-now"`); plain `"now-7d"` is rejected.
+ * - When authenticating with an API token, `dashboard.owner` must be `""`
+ *   (Axiom rewrites this to the org-shared `X-AXIOM-EVERYONE`); per-user
+ *   "private" dashboards aren't allowed for tokens.
+ * - The chart payload is strict: only `id`, `name`, `type`, `query`. Extra
+ *   keys (e.g. `dataset`, `description`) trigger
+ *   `Unrecognized keys: "<name>"`.
+ *
+ * @see https://axiom.co/docs/query-data/dashboards
+ *
+ * @section Creating a Dashboard
+ * @example Minimal empty dashboard
+ * ```typescript
+ * yield* Axiom.Dashboard("ops", {
+ *   dashboard: {
+ *     name: "Ops Overview",
+ *     owner: "",                 // org-shared (required for API tokens)
+ *     description: "Top-level service health",
+ *     charts: [],
+ *     layout: [],
+ *     refreshTime: 60,           // seconds: 15 | 60 | 300
+ *     schemaVersion: 2,
+ *     timeWindowStart: "qr-now-1h",
+ *     timeWindowEnd: "qr-now",
+ *   },
+ * });
+ * ```
+ *
+ * @example One-chart dashboard
+ * ```typescript
+ * import type { Chart, LayoutCell } from "alchemy/Axiom";
+ *
+ * const errors: Chart = {
+ *   id: "errors-5m",
+ *   name: "5xx errors / 5m",
+ *   type: "TimeSeries",
+ *   query: {
+ *     apl: `['my-app-traces']
+ *       | where status >= 500
+ *       | summarize count() by bin_auto(_time)`,
+ *   },
+ * };
+ *
+ * yield* Axiom.Dashboard("errors", {
+ *   dashboard: {
+ *     name: "Errors",
+ *     owner: "",
+ *     refreshTime: 60,
+ *     schemaVersion: 2,
+ *     timeWindowStart: "qr-now-24h",
+ *     timeWindowEnd: "qr-now",
+ *     charts: [errors],
+ *     layout: [{ i: errors.id, x: 0, y: 0, w: 12, h: 6 } satisfies LayoutCell],
+ *   },
+ * });
+ * ```
+ *
+ * @example Compare to last 24h
+ * ```typescript
+ * yield* Axiom.Dashboard("compare", {
+ *   dashboard: {
+ *     name: "Compare vs yesterday",
+ *     owner: "",
+ *     refreshTime: 300,
+ *     schemaVersion: 2,
+ *     timeWindowStart: "qr-now-1h",
+ *     timeWindowEnd: "qr-now",
+ *     against: "-1d",            // overlay the same window from 24h ago
+ *     charts: [],
+ *     layout: [],
+ *   },
+ * });
+ * ```
+ */
+export const Dashboard = Resource<Dashboard>("Axiom.Dashboard");
+
+export const DashboardProvider = () =>
+  Provider.effect(
+    Dashboard,
+    Effect.gen(function* () {
+      const create = yield* Operations.createDashboard;
+      const update = yield* Operations.updateDashboard;
+      const get = yield* Operations.getDashboard;
+      const del = yield* Operations.deleteDashboard;
+
+      const toAttrsFromCreate = (envelope: Operations.CreateDashboardOutput) => ({
+        uid: envelope.dashboard.uid,
+        id: envelope.dashboard.id,
+        createdAt: envelope.dashboard.createdAt,
+        createdBy: envelope.dashboard.createdBy,
+        updatedAt: envelope.dashboard.updatedAt,
+        updatedBy: envelope.dashboard.updatedBy,
+        dashboard: envelope.dashboard.dashboard,
+      });
+      const toAttrsFromGet = (current: Operations.GetDashboardOutput) => ({
+        uid: current.uid,
+        id: current.id,
+        createdAt: current.createdAt,
+        createdBy: current.createdBy,
+        updatedAt: current.updatedAt,
+        updatedBy: current.updatedBy,
+        dashboard: current.dashboard,
+      });
+
+      return {
+        stables: ["uid", "id", "createdAt", "createdBy"],
+        create: Effect.fn(function* ({ news }) {
+          return toAttrsFromCreate(yield* create(news));
+        }),
+        update: Effect.fn(function* ({ news, output }) {
+          // `overwrite: true` short-circuits Axiom's optimistic-concurrency
+          // check (otherwise the API requires the caller to echo back the
+          // server-side `version`, which the resource state doesn't track).
+          return toAttrsFromCreate(
+            yield* update({ ...news, uid: output.uid, overwrite: true }),
+          );
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* del({ uid: output.uid }).pipe(
+            Effect.catchTag("NotFound", () => Effect.void),
+          );
+        }),
+        read: Effect.fn(function* ({ output }) {
+          if (!output?.uid) return undefined;
+          return yield* get({ uid: output.uid }).pipe(
+            Effect.map(toAttrsFromGet),
+            Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+          );
+        }),
+      };
+    }),
+  );

package/src/Axiom/Dataset.ts

@@ -0,0 +1,291 @@
+import { Credentials } from "@distilled.cloud/axiom/Credentials";
+import * as Operations from "@distilled.cloud/axiom/Operations";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { AdoptPolicy } from "../AdoptPolicy.ts";
+import { isResolved } from "../Diff.ts";
+import * as Provider from "../Provider.ts";
+import { Resource } from "../Resource.ts";
+import { Stack } from "../Stack.ts";
+import { Stage } from "../Stage.ts";
+import type { Providers } from "./Providers.ts";
+
+export type DatasetKind =
+  | "otel:metrics:v1"
+  | "otel:traces:v1"
+  | "otel:logs:v1"
+  | "axiom:events:v1";
+
+export type DatasetProps = {
+  /**
+   * Dataset name. Used as the dataset's stable identifier in Axiom — changing
+   * this triggers a replacement.
+   */
+  name: string;
+  /** Free-form description shown in the Axiom UI. */
+  description?: string;
+  /**
+   * Dataset kind. Defaults to `axiom:events:v1`.
+   *
+   * For OTEL pipelines, choose:
+   * - `otel:traces:v1` for traces
+   * - `otel:logs:v1` for logs
+   * - `otel:metrics:v1` for metrics
+   *
+   * Cannot be changed after creation — triggers a replacement.
+   */
+  kind?: DatasetKind;
+  /** Retention in days. Plan-dependent — see Axiom docs. */
+  retentionDays?: number;
+  /** Whether to enforce the configured retention period. */
+  useRetentionPeriod?: boolean;
+};
+
+export type Dataset = Resource<
+  "Axiom.Dataset",
+  DatasetProps,
+  {
+    id: string;
+    name: string;
+    kind: DatasetKind;
+    description: string;
+    created: string;
+    apiBaseUrl: string;
+    /** Root OTLP endpoint (`${apiBaseUrl}`). Most exporters auto-append the signal path. */
+    otelEndpoint: string;
+    /** OTLP/HTTP traces endpoint. */
+    otelTracesEndpoint: string;
+    /** OTLP/HTTP logs endpoint. */
+    otelLogsEndpoint: string;
+    /** OTLP/HTTP metrics endpoint. */
+    otelMetricsEndpoint: string;
+    /**
+     * Headers required for OTLP shipping aside from the bearer token.
+     * Add `Authorization: Bearer <AXIOM_TOKEN>` separately at runtime so the
+     * secret is never persisted in resource state.
+     */
+    otelHeaders: Record<string, string>;
+  },
+  never,
+  Providers
+>;
+
+/**
+ * An Axiom dataset — the top-level container that stores events, logs,
+ * traces, or metrics. Pick a `kind` up-front: it determines schema and how
+ * the data is shown in the UI, and **cannot be changed** after creation
+ * (changing it triggers a replacement, which deletes the data).
+ *
+ * Datasets expose Axiom's OTLP/HTTP endpoints (`otelTracesEndpoint`,
+ * `otelLogsEndpoint`, `otelMetricsEndpoint`) as output attributes so you can
+ * inject them into a Worker / Lambda's env vars for OpenTelemetry shipping.
+ * The bearer token is **not** stored in resource state — supply
+ * `Authorization: Bearer <AXIOM_TOKEN>` separately at runtime.
+ *
+ * @see https://axiom.co/docs/reference/datasets
+ * @see https://axiom.co/docs/send-data/opentelemetry — OTLP endpoint reference
+ *
+ * @section Creating a Dataset
+ * @example Logs dataset with 30-day retention
+ * ```typescript
+ * const logs = yield* Axiom.Dataset("app-logs", {
+ *   name: "my-app-logs",
+ *   kind: "otel:logs:v1",
+ *   description: "Application logs from prod workers",
+ *   retentionDays: 30,
+ *   useRetentionPeriod: true,
+ * });
+ * ```
+ *
+ * @example Separate datasets per OTEL signal
+ * ```typescript
+ * const traces  = yield* Axiom.Dataset("traces",  { name: "app-traces",  kind: "otel:traces:v1"  });
+ * const logs    = yield* Axiom.Dataset("logs",    { name: "app-logs",    kind: "otel:logs:v1"    });
+ * const metrics = yield* Axiom.Dataset("metrics", { name: "app-metrics", kind: "otel:metrics:v1" });
+ * ```
+ *
+ * @section Shipping OTEL data
+ * @example Wire OTEL env vars into a Cloudflare Worker
+ * ```typescript
+ * yield* Cloudflare.Worker("api", {
+ *   vars: {
+ *     OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: traces.otelTracesEndpoint,
+ *     OTEL_EXPORTER_OTLP_LOGS_ENDPOINT:   logs.otelLogsEndpoint,
+ *     // Bearer token must come from a secret store, not the dataset state.
+ *     OTEL_EXPORTER_OTLP_HEADERS:
+ *       `Authorization=Bearer ${env.AXIOM_TOKEN},X-Axiom-Dataset=${traces.name}`,
+ *   },
+ * });
+ * ```
+ */
+export const Dataset = Resource<Dataset>("Axiom.Dataset");
+
+/**
+ * Axiom has no tags/labels API. The only writable field we can use to mark
+ * ownership is `description`. We append a deterministic marker on create so
+ * that on a re-apply (e.g. state was wiped) we can safely identify a dataset
+ * that **we** previously created and adopt it idempotently — without
+ * accidentally hijacking a dataset created by someone else with the same name.
+ */
+const MARKER_RE = /\s*\[alchemy:stack=([^;]+);stage=([^;]+);id=([^\]]+)\]\s*$/;
+
+const buildMarker = (stack: string, stage: string, id: string) =>
+  `[alchemy:stack=${stack};stage=${stage};id=${id}]`;
+
+const augmentDescription = (
+  description: string | undefined,
+  marker: string,
+) => {
+  const base = stripMarker(description ?? "");
+  return base.length > 0 ? `${base}\n${marker}` : marker;
+};
+
+const stripMarker = (description: string): string =>
+  description.replace(MARKER_RE, "").trimEnd();
+
+const parseMarker = (
+  description: string | undefined,
+): { stack: string; stage: string; id: string } | undefined => {
+  if (!description) return undefined;
+  const m = description.match(MARKER_RE);
+  if (!m) return undefined;
+  return { stack: m[1], stage: m[2], id: m[3] };
+};
+
+const buildOtelAttrs = (apiBaseUrl: string, name: string) => {
+  const root = apiBaseUrl.replace(/\/$/, "");
+  return {
+    apiBaseUrl: root,
+    otelEndpoint: root,
+    otelTracesEndpoint: `${root}/v1/traces`,
+    otelLogsEndpoint: `${root}/v1/logs`,
+    otelMetricsEndpoint: `${root}/v1/metrics`,
+    otelHeaders: { "X-Axiom-Dataset": name } as Record<string, string>,
+  };
+};
+
+export const DatasetProvider = () =>
+  Provider.effect(
+    Dataset,
+    Effect.gen(function* () {
+      const { apiBaseUrl } = yield* Credentials;
+      const create = yield* Operations.createDataset;
+      const update = yield* Operations.updateDataset;
+      const get = yield* Operations.getDataset;
+      const del = yield* Operations.deleteDataset;
+
+      const toAttrs = (
+        dataset: Operations.CreateDatasetOutput,
+      ) => ({
+        id: dataset.id,
+        name: dataset.name,
+        kind: dataset.kind,
+        description: stripMarker(dataset.description),
+        created: dataset.created,
+        ...buildOtelAttrs(apiBaseUrl, dataset.name),
+      });
+
+      return {
+        stables: ["id", "name", "kind"],
+        diff: Effect.fn(function* ({ olds, news, output }) {
+          if (!isResolved(news)) return undefined;
+          if (output && news.name !== output.name) {
+            return { action: "replace" } as const;
+          }
+          if (news.kind && output && news.kind !== output.kind) {
+            return { action: "replace" } as const;
+          }
+          if (
+            news.description !== olds?.description ||
+            news.retentionDays !== olds?.retentionDays ||
+            news.useRetentionPeriod !== olds?.useRetentionPeriod
+          ) {
+            return { action: "update" } as const;
+          }
+          return undefined;
+        }),
+        create: Effect.fn(function* ({ id, news }) {
+          const stack = yield* Stack;
+          const stage = yield* Stage;
+          const adoptPolicy = yield* Effect.serviceOption(AdoptPolicy).pipe(
+            Effect.map(Option.getOrElse(() => false)),
+          );
+          const marker = buildMarker(stack.name, stage, id);
+          const dataset = yield* (
+            create({
+              name: news.name,
+              description: augmentDescription(news.description, marker),
+              kind: news.kind,
+              retentionDays: news.retentionDays,
+              useRetentionPeriod: news.useRetentionPeriod,
+            }) as Effect.Effect<
+              Operations.CreateDatasetOutput,
+              { readonly _tag: string },
+              never
+            >
+          ).pipe(
+            Effect.catchIf(
+              (
+                e,
+              ): e is { readonly _tag: "Conflict" | "UnprocessableEntity" } =>
+                e._tag === "Conflict" || e._tag === "UnprocessableEntity",
+              () =>
+                Effect.gen(function* () {
+                  const existing = yield* get({ dataset_id: news.name });
+                  const ownership = parseMarker(existing.description);
+                  const isOurs =
+                    ownership !== undefined &&
+                    ownership.stack === stack.name &&
+                    ownership.stage === stage &&
+                    ownership.id === id;
+                  if (isOurs || adoptPolicy) {
+                    // Re-apply the user's desired props (and re-stamp marker)
+                    // so adoption is idempotent and Axiom-side state matches
+                    // the resource spec.
+                    return yield* update({
+                      dataset_id: existing.id,
+                      description: augmentDescription(news.description, marker),
+                      retentionDays: news.retentionDays,
+                      useRetentionPeriod: news.useRetentionPeriod,
+                    });
+                  }
+                  return yield* Effect.die(
+                    new Error(
+                      `Axiom dataset "${news.name}" already exists and was ` +
+                        `not created by this stack (${stack.name}/${stage}/${id}). ` +
+                        `Pipe the resource through \`adopt()\` from "alchemy/AdoptPolicy" ` +
+                        `to take ownership, or delete the dataset in Axiom and retry.`,
+                    ),
+                  );
+                }),
+            ),
+          );
+          return toAttrs(dataset);
+        }),
+        update: Effect.fn(function* ({ id, news, output }) {
+          const stack = yield* Stack;
+          const stage = yield* Stage;
+          const marker = buildMarker(stack.name, stage, id);
+          const dataset = yield* update({
+            dataset_id: output.id,
+            description: augmentDescription(news.description, marker),
+            retentionDays: news.retentionDays,
+            useRetentionPeriod: news.useRetentionPeriod,
+          });
+          return toAttrs(dataset);
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* del({ dataset_id: output.id }).pipe(
+            Effect.catchTag("NotFound", () => Effect.void),
+          );
+        }),
+        read: Effect.fn(function* ({ output }) {
+          if (!output?.id) return undefined;
+          return yield* get({ dataset_id: output.id }).pipe(
+            Effect.map(toAttrs),
+            Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+          );
+        }),
+      };
+    }),
+  );

package/src/Axiom/Monitor.ts

@@ -0,0 +1,122 @@
+import * as Operations from "@distilled.cloud/axiom/Operations";
+import * as Effect from "effect/Effect";
+import * as Provider from "../Provider.ts";
+import { Resource } from "../Resource.ts";
+import { isResolved } from "../Diff.ts";
+import type { Providers } from "./Providers.ts";
+
+export type MonitorProps = Operations.CreateMonitorInput;
+
+export type Monitor = Resource<
+  "Axiom.Monitor",
+  MonitorProps,
+  Operations.CreateMonitorOutput,
+  never,
+  Providers
+>;
+
+/**
+ * An Axiom monitor — a scheduled APL/MPL query that evaluates on a fixed
+ * cadence and fires alerts via {@link Notifier notifiers} when its
+ * condition is met.
+ *
+ * Three monitor `type`s are supported:
+ *
+ * - **`Threshold`** — fires when an aggregate result crosses a static
+ *   `threshold` (compared with `operator`).
+ * - **`MatchEvent`** — fires for every event matching the query.
+ * - **`AnomalyDetection`** — fires when results deviate from a learned
+ *   baseline by more than `tolerance` over `compareDays`.
+ *
+ * Changing `type` triggers a replacement; everything else updates in place.
+ *
+ * @see https://axiom.co/docs/monitor-data/monitors
+ *
+ * @section Creating a Monitor
+ * @example Threshold: alert on >100 errors per 5m
+ * ```typescript
+ * yield* Axiom.Monitor("error-rate", {
+ *   name: "High error rate",
+ *   description: "Fires when error count exceeds 100/5m",
+ *   type: "Threshold",
+ *   aplQuery: `
+ *     ['my-app-traces']
+ *     | where status >= 500
+ *     | summarize count() by bin_auto(_time)
+ *   `,
+ *   operator: "Above",
+ *   threshold: 100,
+ *   intervalMinutes: 5,
+ *   rangeMinutes: 5,
+ *   alertOnNoData: false,
+ *   resolvable: true,
+ *   notifierIds: [slack.id, pagerduty.id],
+ * });
+ * ```
+ *
+ * @example MatchEvent: alert on every panic
+ * ```typescript
+ * yield* Axiom.Monitor("panics", {
+ *   name: "Service panic",
+ *   type: "MatchEvent",
+ *   aplQuery: `['my-app-logs'] | where message contains "panic:"`,
+ *   intervalMinutes: 1,
+ *   rangeMinutes: 1,
+ *   notifierIds: [pagerduty.id],
+ * });
+ * ```
+ *
+ * @example AnomalyDetection: deviation vs. last 7 days
+ * ```typescript
+ * yield* Axiom.Monitor("traffic-anomaly", {
+ *   name: "Traffic anomaly",
+ *   type: "AnomalyDetection",
+ *   aplQuery: `['my-app-traces'] | summarize count() by bin_auto(_time)`,
+ *   compareDays: 7,
+ *   tolerance: 25,             // %
+ *   intervalMinutes: 15,
+ *   rangeMinutes: 15,
+ *   notifierIds: [slack.id],
+ * });
+ * ```
+ */
+export const Monitor = Resource<Monitor>("Axiom.Monitor");
+
+export const MonitorProvider = () =>
+  Provider.effect(
+    Monitor,
+    Effect.gen(function* () {
+      const create = yield* Operations.createMonitor;
+      const update = yield* Operations.updateMonitor;
+      const get = yield* Operations.getMonitor;
+      const del = yield* Operations.deleteMonitor;
+
+      return {
+        stables: ["id"],
+        diff: Effect.fn(function* ({ news, output }) {
+          if (!isResolved(news)) return undefined;
+          if (output && news.type !== output.type) {
+            return { action: "replace" } as const;
+          }
+          return undefined;
+        }),
+        create: Effect.fn(function* ({ news }) {
+          return yield* create(news);
+        }),
+        update: Effect.fn(function* ({ news, output }) {
+          return yield* update({ ...news, id: output.id });
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* del({ id: output.id }).pipe(
+            Effect.catchTag("NotFound", () => Effect.void),
+          );
+        }),
+        read: Effect.fn(function* ({ output }) {
+          if (!output?.id) return undefined;
+          return yield* get({ id: output.id }).pipe(
+            Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
+          );
+        }),
+      };
+    }),
+  );