effect-cf 0.40.3 → 0.41.1

package/src/Worker.ts

@@ -13,6 +13,7 @@ import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
 import { WorkerEnvironment, type WorkerEnv } from "./Environment";
 import { fromMessage, fromMessageBatch, type QueueHandler } from "./Queue";
 import * as RpcDefinition from "./RpcDefinition";
+import * as RpcTargets from "./RpcTargets";
 import type { ReceiverOptions, RpcInvocationInfo } from "./RpcTracing";
 import * as Entrypoint from "./internal/Entrypoint";
 import * as Runtime from "./internal/Runtime";
@@ -273,11 +274,13 @@ const renderFetchSuccess = <E, R, REvent, EventLayerError, EventLayerRequirement
             });
           });
     const telemetryMiddleware = HttpMiddleware.make((self) =>
-      Effect.gen(function* () {
-        yield* Effect.addFinalizer(() => scheduleTelemetryFlush);
+      RpcTargets.withScope(
+        Effect.gen(function* () {
+          yield* Effect.addFinalizer(() => scheduleTelemetryFlush);
 
-        return yield* self;
-      }),
+          return yield* self;
+        }),
+      ),
     );
     const handled =
       eventLayer === undefined
@@ -287,24 +290,26 @@ const renderFetchSuccess = <E, R, REvent, EventLayerError, EventLayerRequirement
               httpApp,
               handleResponse,
               HttpMiddleware.make((self) =>
-                Effect.provideService(
-                  Effect.gen(function* () {
-                    const context = yield* Layer.build(Layer.fresh(eventLayer));
-
-                    yield* Effect.addFinalizer(() =>
-                      Effect.provideContext(scheduleTelemetryFlush, context),
-                    );
-
-                    return yield* HttpMiddleware.tracer(self).pipe(
-                      // The tracer schedules span completion. Let it publish on
-                      // every exit with event references still installed, before
-                      // the exporter scope finalizes.
-                      Effect.onExit(() => Effect.yieldNow),
-                      Effect.provideContext(context),
-                    );
-                  }),
-                  References.TracerEnabled,
-                  tracerEnabled,
+                RpcTargets.withScope(
+                  Effect.provideService(
+                    Effect.gen(function* () {
+                      const context = yield* Layer.build(Layer.fresh(eventLayer));
+
+                      yield* Effect.addFinalizer(() =>
+                        Effect.provideContext(scheduleTelemetryFlush, context),
+                      );
+
+                      return yield* HttpMiddleware.tracer(self).pipe(
+                        // The tracer schedules span completion. Let it publish on
+                        // every exit with event references still installed, before
+                        // the exporter scope finalizes.
+                        Effect.onExit(() => Effect.yieldNow),
+                        Effect.provideContext(context),
+                      );
+                    }),
+                    References.TracerEnabled,
+                    tracerEnabled,
+                  ),
                 ),
               ),
             ).pipe(Effect.withTracerEnabled(false)),

package/src/Workflow.ts

@@ -1,3 +1,4 @@
+import * as RpcTargets from "./RpcTargets";
 import {
   WorkflowEntrypoint as CloudflareWorkflowEntrypoint,
   type WorkflowEvent as CloudflareWorkflowEvent,
@@ -151,7 +152,11 @@ const fromWorkflowStep = (step: CloudflareWorkflowStep): WorkflowStepService =>
                   A,
                   E,
                   Exclude<R, WorkflowStepContext>
-                > = Effect.scoped(Effect.provideService(effect, WorkflowStepContext, stepContext));
+                > = Effect.scoped(
+                  RpcTargets.withScope(
+                    Effect.provideService(effect, WorkflowStepContext, stepContext),
+                  ),
+                );
 
                 return runPromise(
                   exposeCloudflareNonRetryableError(Effect.provideContext(stepEffect, context)),

package/src/index.ts

@@ -29,6 +29,7 @@ export * as R2 from "./R2";
 export * as Rpc from "./Rpc";
 export * as RpcDefinition from "./RpcDefinition";
 export * as RpcTracing from "./RpcTracing";
+export * as RpcTargets from "./RpcTargets";
 export * as ServiceBinding from "./ServiceBinding";
 export * as Vectorize from "./Vectorize";
 export * as WebTransport from "./WebTransport";

package/src/internal/RpcTargets.ts

@@ -0,0 +1,10 @@
+import * as Context from "effect/Context";
+
+export interface Targets {
+  get<A extends object, Owner extends object>(owner: Owner, address: string, create: () => A): A;
+  invalidate<Target extends object>(target: Target): void;
+}
+
+export class CurrentTargets extends Context.Service<CurrentTargets, Targets>()(
+  "effect-cf/RpcTargets",
+) {}

package/src/internal/Runtime.ts

@@ -5,6 +5,7 @@ import * as ManagedRuntime from "effect/ManagedRuntime";
 import type { Scope, Tracer } from "effect";
 
 import { WorkerConfig, WorkerEnvironment, type WorkerEnv } from "../Environment";
+import * as RpcTargets from "../RpcTargets";
 import { provideEntrypointServices } from "./Entrypoint";
 
 /**
@@ -61,12 +62,14 @@ export function runEventPromise<A, E, R, REvent, EventLayerError, LayerError>(
   const [runtime, effect, eventLayer, parent] = args;
 
   if (eventLayer === undefined) {
-    const event = Effect.scoped(effect);
+    const event = Effect.scoped(RpcTargets.withScope(effect));
 
     return runtime.runPromise(parent === undefined ? event : Effect.withParentSpan(event, parent));
   }
 
-  const event = Effect.scoped(effect.pipe(Effect.provide(eventLayer, { local: true })));
+  const event = Effect.scoped(
+    RpcTargets.withScope(effect.pipe(Effect.provide(eventLayer, { local: true }))),
+  );
 
   return runtime.runPromise(parent === undefined ? event : Effect.withParentSpan(event, parent));
 }