alchemy 2.0.0-beta.4 → 2.0.0-beta.41

package/src/Platform.ts

@@ -7,14 +7,13 @@ import type { Scope } from "effect/Scope";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import { SingleShotGen } from "effect/Utils";
 import type { PolicyLike } from "./Binding.ts";
-import {
-  ExecutionContext,
-  type BaseExecutionContext,
-} from "./ExecutionContext.ts";
+import type { ExecutionContext } from "./ExecutionContext.ts";
 import type { HttpEffect } from "./Http.ts";
 import type { InputProps } from "./Input.ts";
 import type { Provider, ProviderCollectionLike } from "./Provider.ts";
 import { Resource, type ResourceLike } from "./Resource.ts";
+import type { Rpc } from "./Rpc.ts";
+import { RuntimeContext, type BaseRuntimeContext } from "./RuntimeContext.ts";
 import { Self } from "./Self.ts";
 import type { Stack, StackServices } from "./Stack.ts";
 import type { Stage } from "./Stage.ts";
@@ -28,16 +27,19 @@ export interface PlatformProps {
   isExternal?: boolean;
 }
 
-export type Main<Services = never> = void | {
-  fetch: HttpEffect<Services | PlatformServices>;
-};
-
-export type Rpc<Shape> = {
-  "~alchemy/rpc": Shape;
+export type Main<InitServices = never> = void | {
+  fetch:
+    | HttpEffect<InitServices | PlatformServices>
+    | Effect.Effect<
+        HttpEffect<InitServices | PlatformServices>,
+        never,
+        InitServices | PlatformServices
+      >;
 };
 
 // services provided to the Resource
 export type PlatformServices =
+  | RuntimeContext
   | ExecutionContext
   | HttpClient
   | PolicyLike
@@ -52,10 +54,10 @@ export interface Platform<
   Resource extends ResourceLike<string, PlatformProps>,
   Services,
   MainShape,
-  ExecutionContext extends BaseExecutionContext,
+  RuntimeContext extends BaseRuntimeContext,
   BaseShape = {},
 > extends Effect.Effect<
-  Resource & ExecutionContext,
+  Resource & RuntimeContext,
   never,
   Services | PlatformServices
 > {
@@ -159,7 +161,7 @@ export interface Platform<
   ): Effect.Effect<
     Resource & Rpc<Shape>,
     never,
-    | Provider<Resource>
+    | Resource["Providers"]
     | PropsReq
     | Exclude<InitReq, Services | PlatformServices>
   >;
@@ -174,14 +176,14 @@ export const Platform = <
     string,
     | {
         env?: Record<string, any>;
-        exports?: string[];
+        exports?: string[] | Record<string, any>;
       }
     | undefined
   >,
 >(
   type: R["Type"],
   hooks: {
-    createExecutionContext: (id: string) => BaseExecutionContext;
+    createRuntimeContext: (id: string) => BaseRuntimeContext;
     onCreate?: (resource: R, props: any) => Effect.Effect<void>;
   },
   methods?: { [key: string]: any },
@@ -190,7 +192,7 @@ export const Platform = <
   type Impl = Effect.Effect<any>;
 
   const resource = Resource(type);
-  const PlatformContext = ExecutionContext(type);
+  const PlatformContext = RuntimeContext(type);
 
   const constructor = (
     id?: string,
@@ -239,8 +241,18 @@ export const Platform = <
               }),
             )
         ).pipe(
-          Effect.tap(
-            (resource) => hooks.onCreate?.(resource as R, props) ?? Effect.void,
+          Effect.tap((resource) =>
+            hooks.onCreate
+              ? Effect.flatMap(
+                  // `props` may itself be an Effect (e.g. when wrapped by
+                  // `Cloudflare.Vite` via `Effect.map`); resolve it before
+                  // handing it to the hook so `onCreate` always sees the
+                  // plain props object — the second call site (in
+                  // `cls.make`) already does this.
+                  Effect.isEffect(props) ? props : Effect.succeed(props ?? {}),
+                  (resolved) => hooks.onCreate!(resource as R, resolved),
+                )
+              : Effect.void,
           ),
         );
       return Object.assign(
@@ -257,7 +269,7 @@ export const Platform = <
           asEffect,
           // @ts-expect-error
           pipe: (...args: any[]) => asEffect().pipe(...args),
-          [Symbol.iterator]: () => new SingleShotGen({ asEffect }),
+          [Symbol.iterator]: () => new SingleShotGen(asEffect()),
         },
       );
     } else {
@@ -276,18 +288,18 @@ export const Platform = <
         `Platform<${type}<${id}>>`,
       );
       static [Symbol.iterator](): Iterator<
-        Effect.Yieldable<any, void, never, Self>,
+        Effect.Effect<void, never, Self>,
         Resource,
         void
       > {
-        return new SingleShotGen(this) as any;
+        return new SingleShotGen(this.asEffect()) as any;
       }
       static asEffect() {
-        return this.Self.asEffect();
+        return this.Self;
       }
       static pipe(...args: any[]) {
         // @ts-expect-error
-        return pipe(this.asEffect(), ...args);
+        return pipe(this, ...args);
       }
       static of = (shape: any) => shape;
       static make = (impl: Impl) => {
@@ -297,12 +309,12 @@ export const Platform = <
           Effect.flatMap(
             Effect.all([
               Effect.isEffect(props) ? props : Effect.succeed(props ?? {}),
-              Effect.sync(() => hooks.createExecutionContext(id)),
+              Effect.sync(() => hooks.createRuntimeContext(id)),
               Effect.context<never>(),
             ]),
             Effect.fnUntraced(function* ([
               props,
-              executionContext,
+              runtimeContext,
               outerServices,
             ]) {
               const instance = Object.assign(
@@ -315,22 +327,27 @@ export const Platform = <
                       Effect.succeed(resource),
                   ),
                 ),
-                executionContext,
+                runtimeContext,
               );
 
               yield* impl.pipe(
                 Effect.flatMap((impl) =>
-                  impl
-                    ? (executionContext.serve?.(impl.fetch) ??
-                      Effect.die("No serve handler"))
+                  impl?.fetch
+                    ? // Hand the full impl to `serve` so the runtime can
+                      // expose any non-handler methods on the impl shape
+                      // (e.g. RPC methods on a Cloudflare Worker) alongside
+                      // the standard `fetch` handler.
+                      (runtimeContext.serve?.(impl.fetch, {
+                        shape: impl as Record<string, unknown>,
+                      }) ?? Effect.die("No serve handler"))
                     : Effect.void,
                 ),
                 Effect.provide(
                   Layer.provideMerge(
                     Layer.mergeAll(
-                      Layer.succeed(Platform.Platform, executionContext),
-                      Layer.succeed(PlatformContext, executionContext),
-                      Layer.succeed(ExecutionContext, executionContext),
+                      Layer.succeed(Platform.Platform, runtimeContext),
+                      Layer.succeed(PlatformContext, runtimeContext),
+                      Layer.succeed(RuntimeContext, runtimeContext),
                       Layer.succeed(resource.Self, instance),
                       Layer.succeed(Platform.Self, instance),
                       Layer.succeed(Self, instance),
@@ -344,20 +361,20 @@ export const Platform = <
                 ...props,
                 env: {
                   ...props?.env,
-                  ...executionContext.env,
+                  ...runtimeContext.env,
                 },
-                exports: executionContext.exports
-                  ? yield* executionContext.exports
+                exports: runtimeContext.exports
+                  ? yield* runtimeContext.exports
                   : undefined,
               };
 
               return Object.assign(instance, {
-                ExecutionContext: executionContext,
+                RuntimeContext: runtimeContext,
               }) as R;
             }),
           ),
         );
-        const self = Self.asEffect() as any; // TODO(sam): why do we need to cast?
+        const self = Self as any; // TODO(sam): why do we need to cast?
 
         return Layer.provideMerge(
           Layer.mergeAll(
@@ -377,7 +394,7 @@ export const Platform = <
 
   const instance = Object.assign(constructor, resource, {
     Platform: Platform,
-    asEffect: () => resource.Self.asEffect(),
+    asEffect: () => resource.Self,
     ...methods,
   }) as any;
   return instance;

package/src/Provider.ts

@@ -5,7 +5,7 @@ import * as Option from "effect/Option";
 import type * as Stream from "effect/Stream";
 import type { Artifacts } from "./Artifacts.ts";
 import type { Policy } from "./Binding.ts";
-import type { ScopedPlanStatusSession } from "./Cli/index.ts";
+import type { ScopedPlanStatusSession } from "./Cli/Cli.ts";
 import type { Diff } from "./Diff.ts";
 import type { Input } from "./Input.ts";
 import type { InstanceId } from "./InstanceId.ts";
@@ -16,15 +16,16 @@ import type {
   ResourceLike,
 } from "./Resource.ts";
 
-export interface Provider<R extends ResourceLike = ResourceLike> {
+export interface Provider<
+  R extends ResourceLike = ResourceLike,
+> extends Effect.Effect<ProviderService<R>, never, Provider<R>> {
   asEffect: () => Effect.Effect<ProviderService<R>, never, Provider<R>>;
   [Symbol.iterator]: () => Effect.EffectIterator<Provider<R>>;
   of: <
     ReadReq = never,
     DiffReq = never,
     PrecreateReq = never,
-    CreateReq = never,
-    UpdateReq = never,
+    ReconcileReq = never,
     DeleteReq = never,
     TailReq = never,
     LogsReq = never,
@@ -35,8 +36,7 @@ export interface Provider<R extends ResourceLike = ResourceLike> {
         ReadReq,
         DiffReq,
         PrecreateReq,
-        CreateReq,
-        UpdateReq,
+        ReconcileReq,
         DeleteReq,
         TailReq,
         LogsReq
@@ -48,8 +48,7 @@ export interface Provider<R extends ResourceLike = ResourceLike> {
     ReadReq,
     DiffReq,
     PrecreateReq,
-    CreateReq,
-    UpdateReq,
+    ReconcileReq,
     DeleteReq,
     TailReq,
     LogsReq
@@ -88,8 +87,7 @@ export interface ProviderService<
   ReadReq = never,
   DiffReq = never,
   PrecreateReq = never,
-  CreateReq = never,
-  UpdateReq = never,
+  ReconcileReq = never,
   DeleteReq = never,
   TailReq = never,
   LogsReq = never,
@@ -156,23 +154,37 @@ export interface ProviderService<
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
   }): Effect.Effect<Res["Attributes"], any, PrecreateReq>;
-  create(input: {
-    id: string;
-    instanceId: string;
-    news: Props<Res>;
-    session: ScopedPlanStatusSession;
-    bindings: BindingData<Res>;
-    output?: Res["Attributes"];
-  }): Effect.Effect<Res["Attributes"], any, CreateReq>;
-  update(input: {
+  /**
+   * Reconciles the desired state of a Resource with the live cloud state.
+   *
+   * This unified lifecycle method replaces the previous `create` and `update`
+   * pair. The engine dispatches `reconcile` for both intents — initial
+   * provisioning and subsequent updates — and providers must defensively
+   * handle every combination of inputs:
+   *
+   * - `output === undefined` and `olds === undefined` — first reconciliation
+   *   for this logical resource. Treat as a create. Must remain idempotent
+   *   because state persistence can fail after a successful API call.
+   * - `output !== undefined` and `olds === undefined` — engine adopted an
+   *   existing cloud resource (via {@link read}). The provider has never
+   *   written this resource through Alchemy before, so cannot rely on prior
+   *   props as a baseline.
+   * - `output !== undefined` and `olds !== undefined` — standard update
+   *   path with a known prior state.
+   *
+   * Ownership has already been verified upstream — by the time `reconcile`
+   * runs, the engine has confirmed (via `read` returning a non-`Unowned`
+   * value, or by writing the resource itself) that mutation is safe.
+   */
+  reconcile(input: {
     id: string;
     instanceId: string;
     news: Props<Res>;
-    olds: Props<Res>;
-    output: Res["Attributes"];
+    olds: Props<Res> | undefined;
+    output: Res["Attributes"] | undefined;
     session: ScopedPlanStatusSession;
     bindings: BindingData<Res>;
-  }): Effect.Effect<Res["Attributes"], any, UpdateReq>;
+  }): Effect.Effect<Res["Attributes"], any, ReconcileReq>;
   delete(input: {
     id: string;
     instanceId: string;
@@ -189,8 +201,7 @@ export const effect = <
   ReadReq = never,
   DiffReq = never,
   PrecreateReq = never,
-  CreateReq = never,
-  UpdateReq = never,
+  ReconcileReq = never,
   DeleteReq = never,
   TailReq = never,
   LogsReq = never,
@@ -202,8 +213,7 @@ export const effect = <
       ReadReq,
       DiffReq,
       PrecreateReq,
-      CreateReq,
-      UpdateReq,
+      ReconcileReq,
       DeleteReq,
       TailReq,
       LogsReq
@@ -215,7 +225,7 @@ export const effect = <
   Provider<R>,
   never,
   Exclude<
-    Req | ReadReq | DiffReq | PrecreateReq | CreateReq | UpdateReq | DeleteReq,
+    Req | ReadReq | DiffReq | PrecreateReq | ReconcileReq | DeleteReq,
     LifecycleServices
   >
 > =>
@@ -227,8 +237,7 @@ export const succeed = <
   ReadReq = never,
   DiffReq = never,
   PrecreateReq = never,
-  CreateReq = never,
-  UpdateReq = never,
+  ReconcileReq = never,
   DeleteReq = never,
   TailReq = never,
   LogsReq = never,
@@ -239,8 +248,7 @@ export const succeed = <
     ReadReq,
     DiffReq,
     PrecreateReq,
-    CreateReq,
-    UpdateReq,
+    ReconcileReq,
     DeleteReq,
     TailReq,
     LogsReq
@@ -249,7 +257,7 @@ export const succeed = <
   Provider<R>,
   never,
   Exclude<
-    ReadReq | DiffReq | PrecreateReq | CreateReq | UpdateReq | DeleteReq,
+    ReadReq | DiffReq | PrecreateReq | ReconcileReq | DeleteReq,
     LifecycleServices
   >
 > =>
@@ -310,7 +318,7 @@ export const collection = <
       yield* Effect.all(
         resources.map((resource) =>
           "Provider" in resource
-            ? resource.Provider.asEffect().pipe(
+            ? resource.Provider.pipe(
                 Effect.map((provider) => [resource.Type, provider] as const),
               )
             : Effect.succeed([
@@ -366,7 +374,10 @@ export const tryFindProviderByType: {
 } = Effect.fnUntraced(function* <R extends ResourceLike>(
   resourceType: R["Type"],
 ) {
-  const Tag = Provider<R>(resourceType) as Context.Service<Provider<R>, any>;
+  const Tag = Provider<R>(resourceType) as unknown as Context.Service<
+    Provider<R>,
+    any
+  >;
   const direct = yield* Effect.serviceOption(Tag);
   if (Option.isSome(direct)) {
     return direct;
@@ -381,7 +392,5 @@ export const tryFindProviderByType: {
       }
     }
   }
-
-  console.log(context.mapUnsafe.keys());
   return Option.none();
 }) as any;

package/src/Random.ts

@@ -20,7 +20,7 @@ export type Random = Resource<
 >;
 
 export const makeRandom = (id: string, props?: RandomProps) =>
-  Random(id, props).pipe(Effect.flatMap((rand) => rand.text.asEffect()));
+  Random(id, props).pipe(Effect.map((rand) => rand.text));
 
 /**
  * A deterministic-in-state random secret generator.
@@ -32,11 +32,17 @@ export const Random = Resource<Random>("Alchemy.Random");
 
 export const RandomProvider = () =>
   Provider.succeed(Random, {
-    create: Effect.fn(function* ({ news = {}, output }) {
+    reconcile: Effect.fn(function* ({ news = {}, output }) {
+      // Observe — there is no remote state. The cached `output.text` is
+      // the authoritative current value; once minted it is preserved
+      // across reconciles to keep the secret stable.
       if (output?.text) {
         return output;
       }
 
+      // Ensure — no observed value: mint a fresh random secret and
+      // return it. The next reconcile will see this in `output` and
+      // short-circuit above.
       const byteLength = news.bytes ?? 32;
       const text = yield* Effect.sync(() => {
         const bytes = new Uint8Array(byteLength);
@@ -50,9 +56,6 @@ export const RandomProvider = () =>
 
       return { text };
     }),
-    update: Effect.fn(function* ({ output }) {
-      return output;
-    }),
     delete: Effect.fn(function* () {
       return undefined;
     }),

package/src/Ref.ts

@@ -22,11 +22,16 @@ export interface RefMetadata<R extends ResourceLike> {
   stage?: string;
 }
 
-export const ref = <R extends ResourceLike>({
-  stack,
-  id,
-  stage,
-}: RefMetadata<R>): Ref<R> => {
+export const ref = <R extends ResourceLike>(
+  id: string,
+  {
+    stack,
+    stage,
+  }: {
+    stack?: string;
+    stage?: string;
+  } = {},
+): Ref<R> => {
   const ref = new Proxy(
     {},
     {

package/src/Resource.ts

@@ -3,10 +3,11 @@ import * as Option from "effect/Option";
 import { pipeArguments, type Pipeable } from "effect/Pipeable";
 import { SingleShotGen } from "effect/Utils";
 import { toFqn } from "./FQN.ts";
-import type { Input } from "./Input.ts";
+import type { Input, InputProps } from "./Input.ts";
 import { CurrentNamespace, type NamespaceNode } from "./Namespace.ts";
 import * as Output from "./Output.ts";
 import { Provider } from "./Provider.ts";
+import { ref as makeRef } from "./Ref.ts";
 import { RemovalPolicy } from "./RemovalPolicy.ts";
 import { Self } from "./Self.ts";
 import { Stack } from "./Stack.ts";
@@ -33,7 +34,7 @@ export type ResourceConstructor<R extends ResourceLike, Req = never> = {
   ): Effect.Effect<R, never, Req>;
   <PropsReq = never>(
     id: string,
-    props: Effect.Effect<Input<R["Props"]>, never, PropsReq>,
+    props: Effect.Effect<InputProps<R["Props"]>, never, PropsReq>,
   ): Effect.Effect<R, never, PropsReq | Req>;
 };
 
@@ -47,6 +48,10 @@ export type ResourceClassWithMethods<
   Effect.Effect<ResourceConstructor<R>> & {
     Self: Self<R>;
     Provider: Provider<R>;
+    ref(
+      id: string,
+      options?: { stage?: string; stack?: string },
+    ): Effect.Effect<R>;
   } & Methods;
 
 export type ResourceClass<R extends ResourceLike> = ResourceConstructor<
@@ -56,6 +61,10 @@ export type ResourceClass<R extends ResourceLike> = ResourceConstructor<
   Effect.Effect<ResourceConstructor<R>> & {
     Self: Self<R>;
     Provider: Provider<R>;
+    ref(
+      id: string,
+      options?: { stage?: string; stack?: string },
+    ): Effect.Effect<R>;
   };
 
 export type LogicalId = string;
@@ -228,29 +237,6 @@ export function Resource<R extends ResourceLike>(
         [Symbol.toPrimitive](this: typeof target, hint: string) {
           return hint === "number" ? NaN : this.toString();
         },
-        // TODO(sam): figure out a better way to log things in cloudflare, this breaks indentation and is bloated
-        // [nodeInspect](
-        //   depth: number,
-        //   options: { depth?: number | null } & Record<string, unknown>,
-        //   inspect: (value: unknown, opts?: unknown) => string,
-        // ) {
-        //   if (depth < 0) {
-        //     return target.toString();
-        //   }
-        //   const nextDepth =
-        //     options.depth == null ? null : Math.max(0, options.depth - 1);
-        //   return inspect(
-        //     {
-        //       Type: target.Type,
-        //       Namespace: target.Namespace,
-        //       FQN: target.FQN,
-        //       LogicalId: target.LogicalId,
-        //       Props: target.Props,
-        //       RemovalPolicy: target.RemovalPolicy,
-        //     },
-        //     { ...options, depth: nextDepth },
-        //   );
-        // },
       };
 
       const Resource: R = (stack.resources[fqn] = new Proxy(target, {
@@ -276,16 +262,29 @@ export function Resource<R extends ResourceLike>(
 
   const Service = {
     [Symbol.iterator]() {
-      return new SingleShotGen(this);
+      return new SingleShotGen(this.asEffect());
     },
     pipe() {
-      return pipeArguments(this.asEffect(), arguments);
+      return pipeArguments(this, arguments);
     },
     asEffect() {
       return Effect.succeed((id: string, props: R["Props"]) =>
         constructor(id, props),
       );
     },
+    /**
+     * Build a typed reference to a deployed instance of this resource
+     * — in the current stack/stage by default, or in another via
+     * `options`. Resolves to the same shape as `yield*
+     * MyResource("id", props)` so downstream code can read attributes
+     * (`ref.someAttr`) exactly the way it would for a locally-declared
+     * resource.
+     */
+    ref: (
+      id: string,
+      options?: { stage?: string; stack?: string },
+    ): Effect.Effect<R> =>
+      Effect.succeed(Output.of(makeRef<R>(id, options)) as unknown as R),
     Type: type,
     Provider: ProviderTag,
     Self: self,

package/src/Rpc.ts

@@ -0,0 +1,25 @@
+import type * as Effect from "effect/Effect";
+
+export type Rpc<Shape> = {
+  "~alchemy/rpc": Shape;
+};
+
+/**
+ * Recover the user's RPC `Shape` from any of the forms a caller might pass
+ * to {@link toPromiseApi}:
+ *
+ *   - the Worker class value's type, e.g. `typeof Backend`, which extends
+ *     `Effect.Effect<Worker & Rpc<Shape>, …>`
+ *   - the unwrapped `Worker & Rpc<Shape>` type
+ *   - a bare `Shape` (when the caller types it explicitly)
+ */
+export declare namespace Rpc {
+  export type Shape<W> =
+    W extends Effect.Effect<infer R, any, any>
+      ? R extends Rpc<infer Shape>
+        ? Shape
+        : R
+      : W extends Rpc<infer Shape>
+        ? Shape
+        : W;
+}

package/src/Runtime.ts

@@ -0,0 +1,38 @@
+/**
+ * Runtime helpers consumed by generated bundle entrypoints (Cloudflare
+ * Workers, Cloudflare Containers, AWS Lambda, …).
+ *
+ * Anything exported here runs *inside* the deployed function — keep the
+ * surface tiny and dependency-light.
+ */
+
+import * as Layer from "effect/Layer";
+
+/**
+ * Resolve the user's default-export entrypoint into a `Layer` for the
+ * bundled runtime.
+ *
+ * `entrypoint` may be any of:
+ *   - a `Layer` factory (`{ build: (...) => ... }`) — used as-is
+ *   - an effect-class with `asEffect()` (Alchemy `Platform`/`Worker` shape)
+ *   - a plain `Effect`
+ *
+ * Centralized so the inline ternary doesn't have to be re-emitted into
+ * every bundle template (and accidentally rewritten to `x : x` by a bulk
+ * replace, which silently swaps the class in for the Effect and bricks
+ * every deployed worker/lambda).
+ */
+export const makeEntrypointLayer = (
+  tag: any,
+  entrypoint: any,
+): Layer.Layer<any> => {
+  if (typeof entrypoint?.build === "function") {
+    return entrypoint;
+  }
+  return Layer.effect(
+    tag,
+    typeof entrypoint?.asEffect === "function"
+      ? entrypoint.asEffect()
+      : entrypoint,
+  );
+};

package/src/RuntimeContext.ts

@@ -0,0 +1,37 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { HttpEffect } from "./Http.ts";
+import type { Output } from "./Output.ts";
+import { GenericService } from "./Util/service.ts";
+
+export interface BaseRuntimeContext {
+  Type: string;
+  id: string;
+  env: Record<string, any>;
+  get<T>(key: string): Effect.Effect<T>;
+  set(id: string, output: Output): Effect.Effect<string>;
+  exports?: Effect.Effect<Record<string, any>>;
+  serve?<Req = never>(
+    handler: HttpEffect<Req>,
+    options?: { shape?: Record<string, unknown> },
+  ): Effect.Effect<void, never, Req>;
+  shape?: () => Record<string, unknown>;
+}
+
+export interface RuntimeContext<
+  Ctx extends BaseRuntimeContext = BaseRuntimeContext,
+> extends Context.Service<`RuntimeContext<${Ctx["Type"]}>`, Ctx> {}
+
+/**
+ * Context of the runtime environment.
+ *
+ * E.g. the context of a running Worker, Task, Process, Function
+ */
+export const RuntimeContext = GenericService<{
+  <Ctx extends BaseRuntimeContext>(type: Ctx["Type"]): RuntimeContext<Ctx>;
+}>()("Alchemy::RuntimeContext");
+
+export const CurrentRuntimeContext = Effect.serviceOption(RuntimeContext).pipe(
+  Effect.map(Option.getOrUndefined),
+);