alchemy 2.0.0-beta.65 → 2.0.0-beta.67

package/src/Apply.ts

@@ -1,4 +1,5 @@
 import * as Cause from "effect/Cause";
+import * as Data from "effect/Data";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
@@ -24,14 +25,17 @@ import { havePropsChanged, stripUnresolved } from "./Diff.ts";
 import type { Input } from "./Input.ts";
 import { generateInstanceId, InstanceId } from "./InstanceId.ts";
 import * as Output from "./Output.ts";
-import * as Data from "effect/Data";
 import {
   type ActionApply,
   type Apply,
   type Delete,
   type Plan,
 } from "./Plan.ts";
-import { missingProviderError, tryFindProviderByType } from "./Provider.ts";
+import {
+  findProviderByType,
+  missingProviderError,
+  tryFindProviderByType,
+} from "./Provider.ts";
 import type { ResourceBinding } from "./Resource.ts";
 import { Stack } from "./Stack.ts";
 import { Stage } from "./Stage.ts";
@@ -137,7 +141,10 @@ export const apply = <P extends Plan>(
   plan: P,
 ): Effect.Effect<
   Input.Resolve<P["output"]>,
-  Output.InvalidReferenceError | Output.MissingSourceError | StateStoreError,
+  | Output.InvalidReferenceError
+  | Output.MissingSourceError
+  | StateStoreError
+  | DestroyError,
   Cli | State | Stack | Stage
 > =>
   Effect.gen(function* () {
@@ -193,6 +200,16 @@ export const apply = <P extends Plan>(
 
     yield* session.done();
 
+    if (plan.destroy) {
+      // The destroy converged: every resource row was deleted above. Drop
+      // the rest of the stage's persisted state — notably the stack output
+      // record written by the last deploy — so `getOutput` returns
+      // undefined and `listStages` no longer reports the stage.
+      // https://github.com/alchemy-run/alchemy/issues/961
+      yield* state.deleteStack({ stack: stackName, stage });
+      return undefined;
+    }
+
     if (!plan.output) {
       return undefined;
     }
@@ -527,6 +544,7 @@ const executeNode = (
           resourceType: node.resource.Type,
           bindings: excludeDeletedBindings(node.bindings),
           removalPolicy: node.resource.RemovalPolicy,
+          providerMode: node.mode,
         });
         return id;
       } else if (node.action === "replace") {
@@ -553,6 +571,7 @@ const executeNode = (
           old: node.state,
           deleteFirst: node.deleteFirst,
           removalPolicy: node.resource.RemovalPolicy,
+          providerMode: node.mode,
         });
         return id;
       } else if (node.state?.instanceId) {
@@ -584,6 +603,7 @@ const executeNode = (
             bindings: excludeDeletedBindings(node.bindings),
             downstream: node.downstream,
             removalPolicy: node.resource.RemovalPolicy,
+            providerMode: node.mode,
           });
         }
 
@@ -634,6 +654,7 @@ const executeNode = (
             bindings: excludeDeletedBindings(node.bindings),
             downstream: node.downstream,
             removalPolicy: node.resource.RemovalPolicy,
+            providerMode: node.mode,
           });
           yield* storeAndSignal({
             output: attr,
@@ -704,6 +725,7 @@ const executeNode = (
           providerVersion: node.provider.version ?? 0,
           downstream: node.downstream,
           removalPolicy: node.resource.RemovalPolicy,
+          providerMode: node.mode,
         });
 
         tracker[fqn] = {
@@ -752,6 +774,9 @@ const executeNode = (
           string,
           any
         >;
+        const adopting =
+          node.adopting === true ||
+          (node.state.status === "updating" && node.state.adopting === true);
 
         yield* node.state.status === "replaced"
           ? commit<ReplacedResourceState>({
@@ -760,6 +785,7 @@ const executeNode = (
               ...node.state,
               attr: node.state.attr,
               props: news,
+              providerMode: node.mode,
             })
           : commit<UpdatingReourceState>({
               // For ordinary updates we snapshot the previously stable props/attrs
@@ -776,15 +802,18 @@ const executeNode = (
               downstream: node.downstream,
               old:
                 node.state.status === "updating" ? node.state.old : node.state,
+              adopting: adopting ? true : undefined,
               removalPolicy: node.resource.RemovalPolicy,
+              providerMode: node.mode,
             });
 
         yield* report("updating");
 
-        const previousProps =
-          node.state.status === "created" ||
-          node.state.status === "updated" ||
-          node.state.status === "replaced"
+        const previousProps = adopting
+          ? undefined
+          : node.state.status === "created" ||
+              node.state.status === "updated" ||
+              node.state.status === "replaced"
             ? node.state.props
             : node.state.old.props;
 
@@ -822,6 +851,7 @@ const executeNode = (
             ...node.state,
             attr,
             props: news,
+            providerMode: node.mode,
           });
         } else {
           yield* commit<UpdatedResourceState>({
@@ -837,6 +867,7 @@ const executeNode = (
             providerVersion: node.provider.version ?? 0,
             downstream: node.downstream,
             removalPolicy: node.resource.RemovalPolicy,
+            providerMode: node.mode,
           });
         }
 
@@ -891,6 +922,7 @@ const executeNode = (
             old: node.state,
             downstream: node.downstream,
             removalPolicy: node.resource.RemovalPolicy,
+            providerMode: node.mode,
           });
         } else {
           // Resume the same replacement generation after an interrupted apply.
@@ -918,7 +950,17 @@ const executeNode = (
           Effect.gen(function* () {
             const retain = node.resource.RemovalPolicy === "retain";
             if (old.attr !== undefined && !retain) {
-              yield* node.provider
+              // Delete each old generation with the provider variant of the
+              // mode that created it — after a local ⇄ live switch,
+              // `node.provider` (the new mode) cannot tear down the other
+              // runtime's instance. `providerMode: undefined` (legacy row or
+              // mode-agnostic provider) resolves to the provider as
+              // registered.
+              const oldProvider = yield* findProviderByType(
+                node.resource.Type,
+                old.providerMode,
+              );
+              yield* oldProvider
                 .delete({
                   id: logicalId,
                   fqn,
@@ -997,6 +1039,7 @@ const executeNode = (
             old: replState.old,
             deleteFirst: node.deleteFirst,
             removalPolicy: node.resource.RemovalPolicy,
+            providerMode: node.mode,
           });
           yield* storeAndSignal({
             output: attr,
@@ -1064,6 +1107,7 @@ const executeNode = (
             bindings: bindingOutputs,
             downstream: node.downstream,
             removalPolicy: node.resource.RemovalPolicy,
+            providerMode: node.mode,
           });
         } else {
           yield* commit<ReplacedResourceState>({
@@ -1085,6 +1129,7 @@ const executeNode = (
             old: replState.old,
             deleteFirst: node.deleteFirst,
             removalPolicy: node.resource.RemovalPolicy,
+            providerMode: node.mode,
           });
         }
 
@@ -1456,6 +1501,7 @@ const converge = Effect.fn(function* (
           downstream: node.downstream,
           namespace,
           removalPolicy: node.resource.RemovalPolicy,
+          providerMode: node.mode,
         } as UpdatedResourceState,
       });
 
@@ -1541,18 +1587,54 @@ const converge = Effect.fn(function* (
 
 // ── Phase 2: delete orphans and old replaced resources ─────────────────────
 
+/** A provider delete (or its attr-recovery read / state commit) that failed. */
+export interface DeleteFailure {
+  fqn: string;
+  logicalId: string;
+  resourceType: string;
+  cause: Cause.Cause<unknown>;
+}
+
 /**
- * Internal marker: this node's deletion was skipped because a DEPENDENT
- * resource (one that still references it) failed to delete. The dependent's
- * own failure is already recorded in the GC failure list, so nodes failing
- * with ONLY this marker are not re-recorded — they just keep their state so
- * the next destroy retries the whole chain.
+ * A delete that was never attempted because a dependent's delete failed (or
+ * was itself blocked). The resource may legitimately be undeletable while its
+ * dependents still exist, so skipping is not an error in its own right.
  */
-class DependentDeletionFailed extends Data.TaggedError(
-  "DependentDeletionFailed",
-)<{
+export interface BlockedDelete {
   fqn: string;
-}> {}
+  logicalId: string;
+  resourceType: string;
+  /** FQNs of the dependents whose failed/blocked deletes block this one. */
+  blockedBy: string[];
+}
+
+/**
+ * Aggregate raised at the end of the deletion phase when one or more
+ * resource deletes failed. Every resource whose delete did not depend on a
+ * failed one was still attempted — a single failure no longer strands
+ * unrelated siblings.
+ */
+export class DestroyError extends Data.TaggedError("DestroyError")<{
+  failures: ReadonlyArray<DeleteFailure>;
+  blocked: ReadonlyArray<BlockedDelete>;
+}> {
+  override get message(): string {
+    return [
+      `Failed to delete ${this.failures.length} resource(s)` +
+        (this.blocked.length > 0
+          ? ` (${this.blocked.length} more skipped because a dependent's delete failed)`
+          : "") +
+        ":",
+      ...this.failures.map(
+        (f) => `  ✗ ${f.fqn} (${f.resourceType}): ${Cause.pretty(f.cause)}`,
+      ),
+      ...this.blocked.map(
+        (b) =>
+          `  ⊘ ${b.fqn} (${b.resourceType}): skipped — blocked by failed delete of ${b.blockedBy.join(", ")}`,
+      ),
+    ].join("\n");
+  }
+}
 
 const collectGarbage = Effect.fn(function* (
   plan: Plan,
@@ -1563,12 +1645,6 @@ const collectGarbage = Effect.fn(function* (
   const stackName = stack.name;
   const stage = yield* Stage;
 
-  // GC failures are aggregated, never fail-fast: one resource that refuses
-  // to delete must not interrupt sibling deletions mid-flight (which would
-  // leave THEIR physical resources behind too). Every deletable resource is
-  // deleted, then the combined cause is raised at the end.
-  const failures: LifecycleFailure[] = [];
-
   // Task deletions are pure state drops — no body is invoked. Run them in
   // parallel before resource GC; tasks never have provider-side dependencies
   // to wait on.
@@ -1595,17 +1671,28 @@ const collectGarbage = Effect.fn(function* (
     { concurrency: "unbounded" },
   );
 
+  // Failures are collected — not propagated — so one bad delete never
+  // strands unrelated siblings. `unresolved` tracks every FQN whose delete
+  // failed or was blocked this run: later passes must not retry them (a
+  // still-`replaced` row would otherwise spin the drain loop forever) and
+  // dependencies scheduled in later passes must observe them as blocking.
+  const failures: DeleteFailure[] = [];
+  const blockedDeletes: BlockedDelete[] = [];
+  const unresolved = new Set<string>();
+
+  type DeleteOutcome = "deleted" | "failed" | "blocked";
+
   const deleteGraph = Effect.fn(function* (
     deletionGraph: Record<string, Delete | ReplacedResourceState | undefined>,
   ) {
     const deletions: {
-      [fqn in string]: Effect.Effect<void, StateStoreError, ArtifactStore>;
+      [fqn in string]: Effect.Effect<DeleteOutcome, never, ArtifactStore>;
     } = {};
 
     const deleteResource = (
       node: Delete | ReplacedResourceState,
       ancestors: ReadonlySet<string> = new Set(),
-    ): Effect.Effect<void, StateStoreError, ArtifactStore> =>
+    ): Effect.Effect<DeleteOutcome, never, ArtifactStore> =>
       Effect.gen(function* () {
         const isDeleteNode = (
           node: Delete | ReplacedResourceState,
@@ -1621,6 +1708,7 @@ const collectGarbage = Effect.fn(function* (
           props,
           attr: persistedAttr,
           provider,
+          providerMode,
         } = isDeleteNode(node)
           ? {
               // Use the persisted FQN verbatim — never recompute it from
@@ -1637,7 +1725,10 @@ const collectGarbage = Effect.fn(function* (
               downstream: node.downstream,
               props: node.state.props,
               attr: node.state.attr,
+              // Plan resolved this provider for the row's persisted
+              // `providerMode` (see the deletions builder in Plan.ts).
               provider: node.provider,
+              providerMode: node.state.providerMode,
             }
           : {
               fqn: node.fqn,
@@ -1650,9 +1741,12 @@ const collectGarbage = Effect.fn(function* (
               attr: node.old.attr,
               // A missing provider is fatal — plan already dies on zombie
               // rows (see the deletions builder in Plan.ts); this guards
-              // the replaced-chain generations that bypass plan.
+              // the replaced-chain generations that bypass plan. The old
+              // generation is torn down with the provider variant of the
+              // mode that created it (local ⇄ live replacements).
               provider: yield* tryFindProviderByType(
                 node.old.resourceType,
+                node.old.providerMode,
               ).pipe(
                 Effect.flatMap(
                   Option.match({
@@ -1664,6 +1758,7 @@ const collectGarbage = Effect.fn(function* (
                   }),
                 ),
               ),
+              providerMode: node.old.providerMode,
             };
 
         // Mutable: an attr-less row (interrupted create) may recover its
@@ -1707,28 +1802,66 @@ const collectGarbage = Effect.fn(function* (
 
         return yield* (deletions[fqn] ??= yield* Effect.cached(
           Effect.gen(function* () {
-            // Dependents (downstream) delete first. When one of them fails,
-            // this resource cannot safely be deleted this pass — its
-            // physical delete would hit a dependency violation. Replace the
-            // propagated cause with the DependentDeletionFailed marker so
-            // the catch below skips the delete WITHOUT re-recording the
-            // dependent's failure (it already recorded itself).
-            yield* Effect.all(
+            // Dependents (`downstream`) are deleted before this resource. A
+            // dependent whose delete failed (or was itself blocked) may make
+            // this resource legitimately undeletable (dependency violation),
+            // so it is skipped with a "blocked by" note instead of surfacing
+            // a spurious second error.
+            const dependents = yield* Effect.all(
               downstream.map((dep) =>
-                dep !== fqn && dep in deletionGraph && !ancestors.has(dep)
-                  ? deleteResource(
-                      deletionGraph[dep] as Delete | ReplacedResourceState,
-                      nextAncestors,
-                    )
-                  : Effect.void,
+                dep !== fqn && !ancestors.has(dep)
+                  ? dep in deletionGraph
+                    ? deleteResource(
+                        deletionGraph[dep] as Delete | ReplacedResourceState,
+                        nextAncestors,
+                      ).pipe(Effect.map((outcome) => ({ dep, outcome })))
+                    : // Not in this pass's graph — but it may have failed in
+                      // an earlier drain pass of the same destroy.
+                      Effect.sync(() => ({
+                        dep,
+                        outcome: unresolved.has(dep)
+                          ? ("failed" as const)
+                          : ("deleted" as const),
+                      }))
+                  : Effect.succeed({ dep, outcome: "deleted" as const }),
               ),
               { concurrency: "unbounded" },
-            ).pipe(
-              Effect.catchCause(() =>
-                Effect.fail(new DependentDeletionFailed({ fqn })),
+            );
+
+            const blockedBy = dependents
+              .filter(({ outcome }) => outcome !== "deleted")
+              .map(({ dep }) => dep);
+
+            if (blockedBy.length > 0) {
+              unresolved.add(fqn);
+              blockedDeletes.push({
+                fqn,
+                logicalId,
+                resourceType,
+                blockedBy,
+              });
+              yield* scopedSession.note(
+                `Skipping delete — blocked by failed delete of ${blockedBy.join(", ")}.`,
+              );
+              yield* report("skipped");
+              return "blocked" as const;
+            }
+
+            return yield* deleteResourceBody().pipe(
+              Effect.catchCause((cause) =>
+                Effect.gen(function* () {
+                  unresolved.add(fqn);
+                  failures.push({ fqn, logicalId, resourceType, cause });
+                  yield* report("fail");
+                  return "failed" as const;
+                }),
               ),
             );
+          }),
+        ));
 
+        function deleteResourceBody() {
+          return Effect.gen(function* () {
             if (isDeleteNode(node)) {
               yield* report("deleting");
               if (node.resource.RemovalPolicy === "retain") {
@@ -1738,7 +1871,8 @@ const collectGarbage = Effect.fn(function* (
                   fqn,
                 });
                 yield* report("retained");
-                return;
+                // Retention is intentional — it never blocks dependencies.
+                return "deleted" as const;
               }
             }
 
@@ -1822,6 +1956,7 @@ const collectGarbage = Effect.fn(function* (
                 providerVersion: provider.version ?? 0,
                 bindings: excludeDeletedBindings(node.bindings),
                 removalPolicy: node.resource.RemovalPolicy,
+                providerMode,
               });
             }
 
@@ -1879,6 +2014,7 @@ const collectGarbage = Effect.fn(function* (
                   old: node.old.old,
                   deleteFirst: node.deleteFirst,
                   removalPolicy: node.removalPolicy,
+                  providerMode: node.providerMode,
                 });
               } else {
                 // The old chain is fully drained, so the current replacement is now
@@ -1895,6 +2031,7 @@ const collectGarbage = Effect.fn(function* (
                   downstream: node.downstream,
                   bindings: excludeDeletedBindings(node.bindings),
                   removalPolicy: node.removalPolicy,
+                  providerMode: node.providerMode,
                 });
               }
               yield* scopedSession.note(
@@ -1903,42 +2040,19 @@ const collectGarbage = Effect.fn(function* (
                   : "Replaced resource cleanup complete.",
               );
             }
-          }).pipe(
-            Effect.catchCause((cause) =>
-              Effect.gen(function* () {
-                // Record only DIRECT failures. A cause consisting solely of
-                // the DependentDeletionFailed marker means the real failure
-                // was already recorded by the dependent that produced it.
-                const dependentOnly = cause.reasons.every(
-                  (reason) =>
-                    Cause.isFailReason(reason) &&
-                    reason.error instanceof DependentDeletionFailed,
-                );
-                if (!dependentOnly) {
-                  failures.push({
-                    fqn,
-                    logicalId,
-                    type: resourceType,
-                    cause,
-                  });
-                }
-                yield* report("fail");
-                // Keep the cached effect failed so resources that depend on
-                // this one skip their own physical delete too.
-                return yield* Effect.failCause(cause);
-              }),
-            ),
-          ),
-        ));
+            return "deleted" as const;
+          });
+        }
       });
 
     // Attempt every root. Per-node failures were recorded (and their state
-    // retained) by the catch above — swallow them here so one bad resource
-    // never interrupts sibling deletions mid-flight.
+    // retained) inside each node's delete effect — the effects resolve to
+    // outcomes and never fail, so one bad resource never interrupts sibling
+    // deletions mid-flight.
     yield* Effect.all(
       Object.values(deletionGraph)
         .filter((node) => node !== undefined)
-        .map((node) => deleteResource(node).pipe(Effect.ignore)),
+        .map((node) => deleteResource(node)),
       { concurrency: "unbounded" },
     );
   });
@@ -1948,10 +2062,15 @@ const collectGarbage = Effect.fn(function* (
   // chains that were re-committed as `replaced` while deleting older generations.
   let first = true;
   while (true) {
-    const remainingReplacedResources = yield* state.getReplacedResources({
+    const remainingReplacedResources = (yield* state.getReplacedResources({
       stack: stackName,
       stage,
-    });
+    }))
+      // A row whose drain already failed (or was blocked) this run stays
+      // `replaced` in state — retrying it in a later pass would loop forever.
+      // It stays behind for the next destroy; the aggregate error below
+      // reports it.
+      .filter((replaced) => !unresolved.has(replaced.fqn));
     if (!first && remainingReplacedResources.length === 0) {
       break;
     }
@@ -1968,17 +2087,14 @@ const collectGarbage = Effect.fn(function* (
       ),
     });
     first = false;
-    // A failed pass cannot make further progress — the failing rows stay
-    // `replaced`/`deleting` in state, so looping again would spin on the
-    // same failures forever. Stop and surface the aggregate below.
-    if (failures.length > 0) {
-      break;
-    }
   }
 
   if (failures.length > 0) {
-    return yield* Effect.failCause(
-      failures.map((f) => f.cause).reduce(Cause.combine),
+    // Every independent delete was still attempted; now surface everything
+    // that went wrong (and everything skipped as a consequence) as one
+    // typed aggregate. The destroy as a whole still fails.
+    return yield* Effect.fail(
+      new DestroyError({ failures, blocked: blockedDeletes }),
     );
   }
 });

package/src/Axiom/Telemetry.ts

@@ -0,0 +1,119 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import type { Input } from "../Input.ts";
+import * as Output from "../Output.ts";
+import { layerOtlp, type OtlpSignalOptions } from "../Telemetry.ts";
+import type { ApiToken } from "./ApiToken.ts";
+import type { Dataset } from "./Dataset.ts";
+
+/**
+ * A resource passed to the layer: either the module-scope declaration (an
+ * Effect that resolves to the instance, same as what capability bindings
+ * accept) or an already-yielded instance.
+ */
+export type ResourceInput<T> = T | Effect.Effect<T, never, any>;
+
+/**
+ * Options for {@link Telemetry}: an ingest {@link ApiToken} plus one
+ * {@link Dataset} per OTel signal to export.
+ */
+export interface AxiomTelemetryProps {
+  /**
+   * The ingest credential. Must have `ingest: ["create"]` capability on
+   * every dataset passed below.
+   */
+  token: ResourceInput<ApiToken>;
+  /** Dataset (kind `otel:traces:v1`) to export traces into. */
+  traces?: ResourceInput<Dataset> | undefined;
+  /** Dataset (kind `otel:logs:v1`) to export logs into. */
+  logs?: ResourceInput<Dataset> | undefined;
+  /** Dataset (kind `otel:metrics:v1`) to export metrics into. */
+  metrics?: ResourceInput<Dataset> | undefined;
+  /**
+   * The exported `service.name`.
+   * @default the deployed Function/Worker's physical name
+   */
+  serviceName?: Input<string> | undefined;
+}
+
+/**
+ * Resource declarations are Effects — yield them to get the instance with
+ * attribute Output accessors, same as `Binding.Service`'s callable does for
+ * capability bindings.
+ */
+const instance = <T>(resource: ResourceInput<T>): Effect.Effect<T> =>
+  Effect.isEffect(resource)
+    ? (resource as Effect.Effect<T>)
+    : Effect.succeed(resource);
+
+const signal = (
+  token: ApiToken,
+  dataset: Dataset | undefined,
+  urlAttr: "otelTracesEndpoint" | "otelLogsEndpoint" | "otelMetricsEndpoint",
+): OtlpSignalOptions | undefined =>
+  dataset === undefined
+    ? undefined
+    : {
+        url: dataset[urlAttr],
+        headers: {
+          Authorization: Output.map(
+            token.token,
+            (bearer) =>
+              Redacted.make(
+                `Bearer ${Redacted.value(bearer)}`,
+              ) as Redacted.Redacted<string>,
+          ),
+          "X-Axiom-Dataset": dataset.name,
+        },
+      };
+
+/**
+ * Export a Function/Worker's telemetry to Axiom.
+ *
+ * A binding layer over {@link layerOtlp | Alchemy.Telemetry.layerOtlp}:
+ * building it binds each dataset's OTLP endpoint and the ingest token's
+ * `Authorization` header (as a secret) onto the host, and at runtime the
+ * built-in exporter ships each signal to its dataset, flushed per event.
+ *
+ * Compose it into the Function/Worker's single `Effect.provide`:
+ *
+ * ```ts
+ * import * as Axiom from "alchemy/Axiom";
+ * import { Bucket } from "./bucket.ts";
+ * import { Ingest, Logs, Traces } from "./observability.ts";
+ *
+ * export default Cloudflare.Worker(
+ *   "Worker",
+ *   { main: import.meta.url },
+ *   Effect.gen(function* () {
+ *     // ...
+ *   }).pipe(
+ *     Effect.provide(
+ *       Layer.mergeAll(
+ *         Cloudflare.R2.ReadWriteBucketBinding,
+ *         Axiom.Telemetry({ token: Ingest, traces: Traces, logs: Logs }),
+ *       ),
+ *     ),
+ *   ),
+ * );
+ * ```
+ */
+export const Telemetry = (props: AxiomTelemetryProps): Layer.Layer<never> =>
+  Layer.unwrap(
+    Effect.gen(function* () {
+      // Declarations are yielded to instances (registering them on the
+      // Stack if the enclosing host is the first to reference them), so
+      // attribute accessors below produce real Outputs.
+      const token = yield* instance(props.token);
+      const traces = props.traces && (yield* instance(props.traces));
+      const logs = props.logs && (yield* instance(props.logs));
+      const metrics = props.metrics && (yield* instance(props.metrics));
+      return layerOtlp({
+        serviceName: props.serviceName,
+        traces: signal(token, traces, "otelTracesEndpoint"),
+        logs: signal(token, logs, "otelLogsEndpoint"),
+        metrics: signal(token, metrics, "otelMetricsEndpoint"),
+      });
+    }),
+  ) as Layer.Layer<never>;

package/src/Axiom/index.ts

@@ -7,6 +7,7 @@ export * from "./Dashboard.ts";
 export * from "./Dataset.ts";
 export * from "./Monitor.ts";
 export * from "./Notifier.ts";
+export * from "./Telemetry.ts";
 export * from "./Providers.ts";
 export * from "./View.ts";
 export * from "./VirtualField.ts";