alchemy 2.0.0-beta.84 → 2.0.0-beta.85

package/src/Alchemist/Progress.ts

@@ -1,167 +0,0 @@
-import * as Clock from "effect/Clock";
-import * as Effect from "effect/Effect";
-import type { PlanStatusSession, ProgressEvent } from "../Report.ts";
-import { type ProgressReporter } from "../Report.ts";
-
-// The event contract itself lives in Report.ts (one flat `_tag` union, the
-// `Progress` reference the engine emits into). This module adds the
-// Alchemist-side plumbing: the OTEL span-event bridge routes wrap their
-// reporter with, and the adapter to the engine's apply-session contract.
-export {
-  Progress,
-  type ActionPlanned,
-  type ApplyEvent,
-  type NukeEvent,
-  type NukeScanStarted,
-  type NukeProviderScanStarted,
-  type NukePassStarted,
-  type NukeProviderScanned,
-  type NukeResourceDeleted,
-  type NukeResourceFailed,
-  type PlanEvent,
-  type PlanNodeEvent,
-  type PlanPhaseChanged,
-  type PlanningPhase,
-  type ProgressEvent,
-  type ProgressReporter,
-  type ProviderConfigureCompleted,
-  type ProviderConfigureStarted,
-  type ProviderEvent,
-  type ProviderRefreshCompleted,
-  type ProviderRefreshStarted,
-  type ResourceAnnotated,
-  type ResourceDiffStarted,
-  type ResourcePlanned,
-  type ResourceStatusChanged,
-  type StateBootstrapCompleted,
-  type StateBootstrapStarted,
-  type StateEvent,
-} from "../Report.ts";
-
-/**
- * The OTEL span-event shape of one {@link ProgressEvent}, or `undefined`
- * for events that are renderer-only. Per-node plan events are deliberately
- * excluded: a plan emits one per resource *including noops* on every
- * (re)plan — dev-watch replans would flood the collector with rows that
- * mostly say "noop", and the node's own `plan.diff.resource` span already
- * carries the diff. The phase markers are enough to know planning started
- * and where the time went.
- */
-const spanEventOf = (
-  event: ProgressEvent,
-): { name: string; attributes: Record<string, unknown> } | undefined => {
-  switch (event._tag) {
-    case "plan.phase":
-      return {
-        name: "alchemy.plan.phase",
-        attributes: { "alchemy.plan.phase": event.phase },
-      };
-    case "plan.resource.started":
-    case "plan.resource.completed":
-    case "plan.action.completed":
-      return undefined;
-    case "apply.resource.status":
-      return {
-        name: "alchemy.apply.resource.status",
-        attributes: {
-          "alchemy.resource.fqn": event.fqn,
-          "alchemy.resource.logical_id": event.id,
-          "alchemy.resource.type": event.type,
-          "alchemy.apply.resource.status": event.status,
-          ...(event.message === undefined ? {} : { "alchemy.apply.message": event.message }),
-        },
-      };
-    case "apply.resource.note":
-      return {
-        name: "alchemy.apply.resource.note",
-        attributes: {
-          "alchemy.resource.fqn": event.fqn,
-          "alchemy.resource.logical_id": event.id,
-          "alchemy.apply.message": event.message,
-          ...(event.kind === undefined ? {} : { "alchemy.apply.note.kind": event.kind }),
-        },
-      };
-    case "state.bootstrap.started":
-    case "state.bootstrap.completed":
-      return {
-        name: `alchemy.${event._tag}`,
-        attributes: { "alchemy.state_store.name": event.store },
-      };
-    case "nuke.scan.started":
-      return {
-        name: "alchemy.nuke.scan.started",
-        attributes: { "alchemy.nuke.providers": event.total },
-      };
-    case "nuke.pass.started":
-      return {
-        name: "alchemy.nuke.pass.started",
-        attributes: { "alchemy.nuke.pass": event.pass },
-      };
-    case "nuke.scan.provider.started":
-      return {
-        name: "alchemy.nuke.scan.provider.started",
-        attributes: { "alchemy.provider": event.provider },
-      };
-    case "nuke.scan.provider.completed":
-      return {
-        name: "alchemy.nuke.scan.provider.completed",
-        attributes: {
-          "alchemy.provider": event.provider,
-          "alchemy.nuke.resources": event.resources,
-          ...(event.error === undefined ? {} : { "alchemy.nuke.message": event.error }),
-        },
-      };
-    case "nuke.resource.deleted":
-      return {
-        name: "alchemy.nuke.resource.deleted",
-        attributes: { "alchemy.resource.display_name": event.resource },
-      };
-    case "nuke.resource.failed":
-      return {
-        name: "alchemy.nuke.resource.failed",
-        attributes: {
-          "alchemy.resource.display_name": event.resource,
-          "alchemy.nuke.message": event.message,
-        },
-      };
-    case "provider.configure.started":
-    case "provider.configure.completed":
-    case "provider.refresh.started":
-    case "provider.refresh.completed":
-      return {
-        name: `alchemy.${event._tag}`,
-        attributes: { "alchemy.provider": event.provider },
-      };
-  }
-};
-
-/**
- * Decorate a reporter so a {@link ProgressEvent} with a span-event shape is
- * also recorded on the currently active span before it reaches the
- * renderer. Emission happens inside the engine's instrumented fibers, so
- * apply events land on `apply.resource` / `provider.<op>` spans — giving
- * traces a within-span timeline of status transitions. A no-op when no
- * span is active (tracing disabled), and independent of whether a renderer
- * is attached, so `--yes` and CI runs still produce the events.
- */
-export const withSpanEvents =
-  (report: ProgressReporter): ProgressReporter =>
-  (event) => {
-    const spanEvent = spanEventOf(event);
-    if (spanEvent === undefined) return report(event);
-    return Effect.currentSpan.pipe(
-      Effect.flatMap((span) =>
-        Effect.flatMap(Clock.currentTimeNanos, (now) =>
-          Effect.sync(() => span.event(spanEvent.name, now, spanEvent.attributes)),
-        ),
-      ),
-      Effect.ignore,
-      Effect.andThen(report(event)),
-    );
-  };
-
-/** Adapt the ambient reporter to the engine's apply-session contract. */
-export const applySession = (report: ProgressReporter): PlanStatusSession => ({
-  emit: (event) => report(event),
-  done: () => Effect.void,
-});

package/src/Alchemist/Session.ts

@@ -1,415 +0,0 @@
-import { pathToFileURL } from "node:url";
-import * as Cause from "effect/Cause";
-import * as ConfigProvider from "effect/ConfigProvider";
-import * as Context from "effect/Context";
-import * as Duration from "effect/Duration";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Logger from "effect/Logger";
-import * as Option from "effect/Option";
-import * as Predicate from "effect/Predicate";
-import * as Schema from "effect/Schema";
-import * as Semaphore from "effect/Semaphore";
-import { AdoptPolicy } from "../AdoptPolicy.ts";
-import { AlchemyContext } from "../AlchemyContext.ts";
-import { ArtifactStore, createArtifactStore } from "../Artifacts.ts";
-import { AuthError, AuthProviders } from "../Auth/AuthProvider.ts";
-import { SuppressMissingProviderConfig } from "../Auth/Profile.ts";
-import { withProfileOverride } from "../Auth/Resolve.ts";
-import * as Contributions from "../Contributions.ts";
-import * as Stack from "../Stack.ts";
-import { Stage } from "../Stage.ts";
-import {
-  loadConfigProvider,
-  stackConfigLayer,
-  StackConfigOverrides,
-} from "../Util/ConfigProvider.ts";
-import { fileLogger } from "../Util/FileLogger.ts";
-import { DEFAULT_ENTRYPOINT, resolveStackEntrypoint, StackEntrypointError } from "./Entrypoint.ts";
-import { Progress } from "./Progress.ts";
-
-export { DEFAULT_ENTRYPOINT, resolveStackEntrypoint, StackEntrypointError };
-
-/** Stage used by routes that inspect a project without addressing a deployment. */
-export const PLACEHOLDER_STAGE = "placeholder";
-
-/**
- * The default export of an `alchemy.run.ts` entrypoint: the stack effect
- * `Alchemy.Stack(...)` returns, carrying the metadata the factory attaches.
- */
-export type StackModule = ReturnType<ReturnType<typeof Stack.make>> & {
-  readonly stackName: string;
-  readonly providers: Layer.Layer<never> | undefined;
-  readonly state: Layer.Layer<never> | undefined;
-  readonly secrets: Stack.StackSecrets | undefined;
-};
-
-export interface StackModuleLoader {
-  readonly import: (url: string) => Promise<{ readonly default?: unknown }>;
-}
-
-export const StackModuleLoader = Context.Reference<StackModuleLoader>(
-  "Alchemy/Alchemist/StackModuleLoader",
-  { defaultValue: () => ({ import: (url) => import(url) }) },
-);
-
-export const importStack = Effect.fn(function* (main: string) {
-  const absolutePath = yield* resolveStackEntrypoint(main);
-  const loader = yield* StackModuleLoader;
-  const module = yield* Effect.promise(() => loader.import(pathToFileURL(absolutePath).href));
-  if (
-    !Effect.isEffect(module.default) ||
-    !Predicate.hasProperty(module.default, "stackName") ||
-    typeof module.default.stackName !== "string"
-  ) {
-    return yield* new StackEntrypointError({
-      message: `Stack entrypoint '${main}' must export a default stack definition (export default Alchemy.Stack({...})).`,
-    });
-  }
-  // oxlint-disable-next-line effecttsgo/unsafe-effect-type-assertion -- default export shape validated at runtime above
-  return module.default as StackModule;
-});
-
-/**
- * Which project, stage, and credentials a route acts under. Every route that
- * touches the user's program takes one of these; the optional fields fall back
- * to the same defaults the CLI uses.
- */
-export interface Target {
-  /** Stack entrypoint. @default "alchemy.run.ts" */
-  readonly entrypoint?: string;
-  /** Stage the run addresses. @default "placeholder" (routes that never deploy) */
-  readonly stage?: string;
-  /** Profile whose credentials the run uses. Falls back to the active profile. */
-  readonly profile?: string;
-  /** `.env` file layered under the process environment. */
-  readonly envFile?: string;
-}
-
-/** A {@link Target} for a route that genuinely acts on one stack instance. */
-export interface StackTarget extends Target {
-  readonly entrypoint: string;
-  readonly stage: string;
-}
-
-export interface OpenOptions {
-  /** Run local (emulated) providers instead of the real cloud. */
-  readonly dev?: boolean;
-  /** Adopt pre-existing cloud resources instead of failing on conflict. */
-  readonly adopt?: boolean;
-  /** Upgrade an out-of-date state store without prompting. */
-  readonly updateStateStore?: boolean;
-}
-
-interface SessionServicesOptions {
-  readonly envFile: Option.Option<string>;
-  readonly profile?: string;
-  readonly logger?: Layer.Layer<never, never, never>;
-  readonly extra?: Layer.Layer<never, never, never>;
-}
-
-/** Shared config and logging services used by every stack/auth build path. */
-const sessionServices = Effect.fn("sessionServices")(function* (options: SessionServicesOptions) {
-  const commandConfig = yield* loadConfigProvider(options.envFile);
-
-  // `--env-file` only steers a stack's default secrets list and `--profile`
-  // pins the profile inside it; see stackConfigLayer.
-  return Layer.mergeAll(
-    Layer.succeed(StackConfigOverrides, {
-      envFile: Option.getOrUndefined(options.envFile),
-      profile: options.profile,
-    }),
-    ConfigProvider.layer(withProfileOverride(commandConfig, options.profile)),
-    options.logger ?? Logger.layer([fileLogger("out")], { mergeWithExisting: true }),
-    options.extra ?? Layer.empty,
-  );
-});
-
-interface RouteCacheService {
-  readonly open: (
-    target: Target,
-    options: OpenOptions,
-  ) => Effect.Effect<
-    Session,
-    Effect.Error<ReturnType<typeof openUncached>>,
-    Effect.Services<ReturnType<typeof openUncached>>
-  >;
-  readonly authProviders: (
-    options: CollectAuthProvidersOptions,
-  ) => Effect.Effect<
-    AuthProviders["Service"],
-    Effect.Error<ReturnType<typeof collectAuthProvidersUncached>>,
-    Effect.Services<ReturnType<typeof collectAuthProvidersUncached>>
-  >;
-}
-
-export interface CollectAuthProvidersOptions {
-  readonly main: string;
-  readonly envFile: Option.Option<string>;
-  readonly profile: string;
-}
-
-const RouteCache = Context.Reference<RouteCacheService>("Alchemy/Alchemist/RouteCache", {
-  defaultValue: () => ({
-    open: (target, options) => openUncached(target, options),
-    authProviders: collectAuthProvidersUncached,
-  }),
-});
-
-const stackSessionKey = (target: Target, options: OpenOptions) =>
-  JSON.stringify([
-    target.entrypoint ?? DEFAULT_ENTRYPOINT,
-    target.stage ?? PLACEHOLDER_STAGE,
-    target.profile ?? null,
-    target.envFile ?? null,
-    options.dev ?? false,
-    options.adopt ?? false,
-    options.updateStateStore ?? false,
-  ]);
-
-const authRegistryKey = (options: CollectAuthProvidersOptions) =>
-  JSON.stringify([options.main, Option.getOrNull(options.envFile), options.profile]);
-
-const cached = <A, E, R>(
-  lock: Semaphore.Semaphore,
-  entries: Map<string, Effect.Effect<A, E, R>>,
-  key: string,
-  load: Effect.Effect<A, E, R>,
-) =>
-  Semaphore.withPermits(
-    lock,
-    1,
-  )(
-    Effect.suspend(() => {
-      const existing = entries.get(key);
-      if (existing !== undefined) return Effect.succeed(existing);
-      return Effect.cached(load).pipe(
-        Effect.tap((effect) =>
-          Effect.sync(() => {
-            entries.set(key, effect);
-          }),
-        ),
-      );
-    }),
-  ).pipe(Effect.flatten);
-
-/** Memoize stack sessions and auth registries for one command or API scope. */
-export const routeCacheLayer = Layer.effect(
-  RouteCache,
-  Effect.sync((): RouteCacheService => {
-    const lock = Semaphore.makeUnsafe(1);
-    const sessions = new Map<string, ReturnType<typeof openUncached>>();
-    const registries = new Map<string, ReturnType<typeof collectAuthProvidersUncached>>();
-    return {
-      open: (target, options) =>
-        cached(lock, sessions, stackSessionKey(target, options), openUncached(target, options)),
-      authProviders: (options) =>
-        cached(lock, registries, authRegistryKey(options), collectAuthProvidersUncached(options)),
-    };
-  }),
-);
-
-/**
- * Import the user's stack module and build the services its resources run
- * under. This is the one place that decides what a stack run sees — plan,
- * apply, drift, logs, and state inspection all come through here.
- *
- * The session lives in the surrounding `Scope`; run stack-scoped effects by
- * providing `session.context` (`Effect.provide(effect, session.context)`).
- */
-const openUncached = Effect.fn("openStackSessionUncached")(function* (
-  target: Target,
-  options: OpenOptions = {},
-) {
-  // Phases are emitted here, at the actual work boundaries, rather than by
-  // callers around `open` — the import and the service build both happen
-  // inside this function, so only it can time them honestly.
-  const report = yield* Progress;
-  yield* report({ _tag: "plan.phase", phase: "importing-module" });
-  const stackEffect = yield* importStack(target.entrypoint ?? DEFAULT_ENTRYPOINT);
-  yield* report({ _tag: "plan.phase", phase: "resolving-services" });
-  const shared = yield* sessionServices({
-    envFile: Option.fromNullishOr(target.envFile),
-    profile: target.profile,
-  });
-  const services = Layer.mergeAll(
-    Layer.effect(
-      AlchemyContext,
-      Effect.map(AlchemyContext, (context) => ({
-        ...context,
-        dev: options.dev ?? context.dev,
-        adopt: options.adopt ?? false,
-        updateStateStore: options.updateStateStore ?? false,
-      })),
-    ),
-    Layer.succeedContext(
-      Context.make(AdoptPolicy, options.adopt ?? false).pipe(
-        Context.add(ArtifactStore, createArtifactStore()),
-        Context.add(
-          AuthProviders,
-          yield* Effect.serviceOption(AuthProviders).pipe(
-            Effect.map(Option.getOrElse((): AuthProviders["Service"] => ({}))),
-          ),
-        ),
-        Context.add(Stage, target.stage ?? PLACEHOLDER_STAGE),
-      ),
-    ),
-    shared,
-  );
-  const sessionContext = yield* Layer.build(services);
-  const stack = yield* Effect.provide(stackEffect, sessionContext);
-  return {
-    stack,
-    /**
-     * Everything a stack-scoped effect runs under: the stack's own providers
-     * and state store over this session's services.
-     */
-    context: Context.merge(sessionContext, stack.services),
-  };
-});
-
-/** An imported, fully-configured stack instance. */
-export type Session = Effect.Success<ReturnType<typeof openUncached>>;
-
-export const open = Effect.fn("openStackSession")(function* (
-  target: Target,
-  options: OpenOptions = {},
-) {
-  return yield* (yield* RouteCache).open(target, options);
-});
-
-const placeholderStack = (name: string) => ({
-  actions: {},
-  bindings: {},
-  name,
-  resources: {},
-  stage: PLACEHOLDER_STAGE,
-});
-
-export interface BuildStackProvidersOptions {
-  readonly main: string;
-  readonly envFile: Option.Option<string>;
-  readonly profile?: string;
-  readonly registry?: AuthProviders["Service"];
-  readonly logger?: Layer.Layer<never, never, never>;
-  readonly extra?: Layer.Layer<never, never, never>;
-}
-
-export const buildStackProviders = Effect.fn("buildStackProviders")(function* (
-  options: BuildStackProvidersOptions,
-) {
-  const authProviders = options.registry ?? {};
-  const stackEffect = yield* importStack(options.main);
-  const shared = yield* sessionServices(options);
-  const valueServices = Layer.succeedContext(
-    Context.make(AuthProviders, authProviders).pipe(
-      Context.add(Stage, PLACEHOLDER_STAGE),
-      Context.add(Stack.Stack, placeholderStack(stackEffect.stackName)),
-    ),
-  );
-  const context = yield* Layer.build(
-    (stackEffect.providers ?? Layer.empty).pipe(
-      Layer.provideMerge(stackEffect.state ?? Layer.empty),
-      Layer.provideMerge(stackConfigLayer(stackEffect.secrets)),
-      Layer.provideMerge(Layer.mergeAll(valueServices, shared)),
-    ),
-  );
-  return { authProviders, context, stackEffect };
-});
-
-/**
- * Every provider's auth provider, merged into one registering layer. One
- * provider whose auth fails to load is skipped with a warning, so it can't
- * take every other provider's auth down with it.
- */
-const contributedAuth = Effect.fn("contributedAuth")(function* () {
-  const layers = yield* Effect.forEach(
-    yield* Contributions.load(),
-    (provider) =>
-      provider.auth
-        ? Contributions.resolve(provider, "auth", provider.auth).pipe(
-            Effect.catch((error) => Effect.as(Effect.logWarning(error.message), undefined)),
-          )
-        : Effect.void,
-    { concurrency: "unbounded" },
-  );
-  return Layer.mergeAll(Layer.empty, ...layers.filter((layer) => layer !== undefined));
-});
-
-const buildContributedAuthProviders = Effect.fn("buildContributedAuthProviders")(
-  function* (options: {
-    readonly envFile: Option.Option<string>;
-    readonly profile: string;
-    readonly registry?: AuthProviders["Service"];
-  }) {
-    const authProviders = options.registry ?? {};
-    const shared = yield* sessionServices(options);
-    yield* Layer.build(
-      Layer.provide(
-        yield* contributedAuth(),
-        Layer.mergeAll(Layer.succeed(AuthProviders, authProviders), shared),
-      ),
-    );
-    return authProviders;
-  },
-);
-
-const isMissingProviderConfig = Schema.is(
-  Schema.Struct({ _tag: Schema.Literals(["MissingProviderConfig"]) }),
-);
-
-/**
- * Every auth provider reachable from the current project: the built-ins, plus
- * whatever the user's stack module registers when it is importable.
- */
-const collectAuthProvidersUncached = Effect.fn("collectAuthProvidersUncached")(
-  function* (options: CollectAuthProvidersOptions) {
-    const authProviders: AuthProviders["Service"] = {};
-    yield* buildContributedAuthProviders({
-      envFile: options.envFile,
-      profile: options.profile,
-      registry: authProviders,
-    });
-
-    const fs = yield* FileSystem.FileSystem;
-    const entrypointExists = yield* fs.exists(options.main);
-    const missingDefault = options.main === DEFAULT_ENTRYPOINT && !entrypointExists;
-    if (!entrypointExists && !missingDefault) {
-      return yield* AuthError.make({
-        message: `Stack entrypoint '${options.main}' does not exist.`,
-      });
-    }
-    if (!missingDefault) {
-      yield* buildStackProviders({ ...options, registry: authProviders }).pipe(
-        Effect.timeoutOption(Duration.seconds(15)),
-        Effect.catchCause((cause) => {
-          const suppressed = cause.reasons.some((reason) => {
-            const error = Cause.isFailReason(reason)
-              ? reason.error
-              : Cause.isDieReason(reason)
-                ? reason.defect
-                : undefined;
-            return isMissingProviderConfig(error);
-          });
-          return suppressed
-            ? Effect.void
-            : Effect.fail(
-                AuthError.make({
-                  message: `Could not load auth providers from '${options.main}'.`,
-                  cause,
-                }),
-              );
-        }),
-      );
-    }
-    return authProviders;
-  },
-  Effect.provideService(SuppressMissingProviderConfig, true),
-);
-
-export const collectAuthProviders = Effect.fn("collectAuthProviders")(function* (
-  options: CollectAuthProvidersOptions,
-) {
-  return yield* (yield* RouteCache).authProviders(options);
-});

package/src/Alchemist/routes/drift.ts

@@ -1,87 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as EngineDrift from "../../Drift.ts";
-import type { Plan } from "../../Plan.ts";
-import { applySession, Progress, withSpanEvents } from "../Progress.ts";
-import { open, type Session, type StackTarget } from "../Session.ts";
-import * as Stack from "./stack.ts";
-
-export interface DriftedResource {
-  readonly fqn: string;
-  readonly logicalId: string;
-  readonly resourceType: string;
-  readonly status: "in-sync" | "drifted" | "missing";
-  readonly actual?: unknown;
-}
-
-export interface DriftSnapshot {
-  readonly stack: { readonly name: string; readonly stage: string };
-  readonly resources: ReadonlyArray<DriftedResource>;
-  readonly repairPlan: {
-    readonly summary: Stack.PlanSummary;
-    readonly native: Plan;
-  };
-  /** The session drift was inspected under; {@link repair} runs in it. */
-  readonly session: Session;
-}
-
-/** Whether the drift check found anything worth repairing. */
-export const hasDrift = (snapshot: DriftSnapshot): boolean =>
-  snapshot.resources.some(
-    (resource) => resource.status === "drifted" || resource.status === "missing",
-  );
-
-const status = (action: string) =>
-  action === "unchanged"
-    ? ("in-sync" as const)
-    : action === "missing"
-      ? ("missing" as const)
-      : ("drifted" as const);
-
-/** Compare deployed state against the real cloud and plan the repair. */
-export const inspect = Effect.fn("Alchemist.drift.inspect")(function* (target: StackTarget) {
-  const report = withSpanEvents(yield* Progress);
-  // `open` emits importing-module / resolving-services at the real work
-  // boundaries; hand it the wrapped reporter so they land in traces too.
-  const session = yield* open(target).pipe(Effect.provideService(Progress, report));
-  const identity = {
-    name: session.stack.name,
-    stage: session.stack.stage,
-  };
-  const { result, plan } = yield* EngineDrift.plan(identity).pipe(
-    // The engine's phase and per-resource observation events flow through
-    // the same wrapped reporter; drift-flavored wording is the renderer's
-    // job (renderPlanning's computingLabel).
-    Effect.provideService(Progress, report),
-    Effect.provide(session.context),
-  );
-  yield* report({ _tag: "plan.phase", phase: "plan-ready" });
-  return {
-    stack: identity,
-    resources: Object.values(result.resources)
-      .filter((resource) => resource.action !== "skipped")
-      .map((resource) => ({
-        fqn: resource.fqn,
-        logicalId: resource.logicalId,
-        resourceType: resource.resourceType,
-        status: status(resource.action),
-        actual: resource.attr,
-      })),
-    repairPlan: { summary: Stack.summarize(plan), native: plan },
-    session,
-  } satisfies DriftSnapshot;
-});
-
-/**
- * Converge state back to the cloud's actual shape. Engine apply events are
- * reported through {@link Progress}.
- */
-export const repair = Effect.fn("Alchemist.drift.repair")(function* (snapshot: DriftSnapshot) {
-  const report = withSpanEvents(yield* Progress);
-  return yield* Effect.provide(
-    EngineDrift.repair(
-      { name: snapshot.stack.name, stage: snapshot.stack.stage },
-      { session: applySession(report) },
-    ),
-    snapshot.session.context,
-  );
-});