@yielded/agent-platform-cloudflare 0.1.0-beta.173 → 0.1.0-beta.175

package/src/internal/browser-session-lifecycle.ts

@@ -49,7 +49,7 @@ export class BrowserRunSessionLifecycle extends Context.Service<
           !Schema.is(Account)(options.accountId) ||
           Redacted.value(options.apiToken).length === 0
         ) {
-          return yield* new BrowserRunCleanupError({ reason: "configuration" });
+          return yield* BrowserRunCleanupError.make({ reason: "configuration" });
         }
         const client = yield* HttpClient.HttpClient;
 
@@ -65,39 +65,38 @@ export class BrowserRunSessionLifecycle extends Context.Service<
             .pipe(
               // workerd supports manual/follow, not error. Reject every redirect below.
               Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" }),
-              Effect.mapError(
-                (cause) =>
-                  new BrowserRunCleanupError({
-                    reason: "provider",
-                    cause: browserFailure("browser.close.request", cause),
-                  }),
+              Effect.mapError((cause) =>
+                BrowserRunCleanupError.make({
+                  reason: "provider",
+                  cause: browserFailure("browser.close.request", cause),
+                }),
               ),
             );
 
           if (response.status === 401 || response.status === 403)
-            return yield* new BrowserRunCleanupError({
+            return yield* BrowserRunCleanupError.make({
               reason: "authorization",
               status: response.status,
             });
           if (response.status === 429)
-            return yield* new BrowserRunCleanupError({
+            return yield* BrowserRunCleanupError.make({
               reason: "rate-limited",
               status: response.status,
             });
           if (response.status !== 200 && response.status !== 404)
-            return yield* new BrowserRunCleanupError({
+            return yield* BrowserRunCleanupError.make({
               reason: "provider",
               status: response.status,
             });
           if (response.headers["content-type"]?.split(";", 1)[0]?.trim() !== "application/json")
-            return yield* new BrowserRunCleanupError({ reason: "malformed" });
+            return yield* BrowserRunCleanupError.make({ reason: "malformed" });
 
           const bytes = yield* Stream.runFoldEffect(
             response.stream,
             () => new Uint8Array(),
             (body, chunk) => {
               if (body.byteLength + chunk.byteLength > 16_384)
-                return Effect.fail(new BrowserRunCleanupError({ reason: "malformed" }));
+                return Effect.fail(BrowserRunCleanupError.make({ reason: "malformed" }));
               const combined = new Uint8Array(body.byteLength + chunk.byteLength);
 
               combined.set(body);
@@ -106,19 +105,18 @@ export class BrowserRunSessionLifecycle extends Context.Service<
               return Effect.succeed(combined);
             },
           ).pipe(
-            Effect.mapError(
-              (cause) =>
-                new BrowserRunCleanupError({
-                  reason: "malformed",
-                  cause: browserFailure("browser.close.response", cause),
-                }),
+            Effect.mapError((cause) =>
+              BrowserRunCleanupError.make({
+                reason: "malformed",
+                cause: browserFailure("browser.close.response", cause),
+              }),
             ),
           );
 
           const body = yield* Effect.try({
             try: () => new TextDecoder("utf-8", { fatal: true, ignoreBOM: false }).decode(bytes),
             catch: (cause) =>
-              new BrowserRunCleanupError({
+              BrowserRunCleanupError.make({
                 reason: "malformed",
                 cause: browserFailure("browser.close.decode", cause),
               }),
@@ -131,16 +129,15 @@ export class BrowserRunSessionLifecycle extends Context.Service<
 
             if (Option.isSome(absent)) return true;
 
-            return yield* new BrowserRunCleanupError({ reason: "malformed" });
+            return yield* BrowserRunCleanupError.make({ reason: "malformed" });
           }
           if (method === "DELETE") {
             const result = yield* Schema.decodeEffect(Schema.fromJsonString(Closed))(body).pipe(
-              Effect.mapError(
-                (cause) =>
-                  new BrowserRunCleanupError({
-                    reason: "malformed",
-                    cause: browserFailure("browser.close.response", cause),
-                  }),
+              Effect.mapError((cause) =>
+                BrowserRunCleanupError.make({
+                  reason: "malformed",
+                  cause: browserFailure("browser.close.response", cause),
+                }),
               ),
             );
 
@@ -148,17 +145,16 @@ export class BrowserRunSessionLifecycle extends Context.Service<
           }
 
           const result = yield* Schema.decodeEffect(Schema.fromJsonString(Metadata))(body).pipe(
-            Effect.mapError(
-              (cause) =>
-                new BrowserRunCleanupError({
-                  reason: "malformed",
-                  cause: browserFailure("browser.close.response", cause),
-                }),
+            Effect.mapError((cause) =>
+              BrowserRunCleanupError.make({
+                reason: "malformed",
+                cause: browserFailure("browser.close.response", cause),
+              }),
             ),
           );
 
           if (result.sessionId !== sessionId)
-            return yield* new BrowserRunCleanupError({ reason: "malformed" });
+            return yield* BrowserRunCleanupError.make({ reason: "malformed" });
 
           return result.endTime !== undefined && result.endTime > 0;
         });
@@ -166,7 +162,7 @@ export class BrowserRunSessionLifecycle extends Context.Service<
         const close = Effect.fnUntraced(
           function* (sessionId: Redacted.Redacted<string>) {
             const id = yield* Schema.decodeEffect(Identity)(Redacted.value(sessionId)).pipe(
-              Effect.mapError(() => new BrowserRunCleanupError({ reason: "configuration" })),
+              Effect.mapError(() => BrowserRunCleanupError.make({ reason: "configuration" })),
             );
 
             if (yield* request("DELETE", id)) return;
@@ -174,11 +170,11 @@ export class BrowserRunSessionLifecycle extends Context.Service<
               if (yield* request("GET", id)) return;
             }
 
-            return yield* new BrowserRunCleanupError({ reason: "pending" });
+            return yield* BrowserRunCleanupError.make({ reason: "pending" });
           },
           Effect.timeoutOrElse({
             duration: "10 seconds",
-            orElse: () => Effect.fail(new BrowserRunCleanupError({ reason: "timeout" })),
+            orElse: () => Effect.fail(BrowserRunCleanupError.make({ reason: "timeout" })),
           }),
           Effect.withTracerEnabled(false),
         );

package/src/internal/due-queue.ts

@@ -139,10 +139,9 @@ export const make = (storage: DurableObjectStorage) => {
 
   // Nine bindings per lane stay below Durable Object SQLite's 100-parameter limit.
   const write = (changes: ReadonlyArray<Change>) => {
-    const rows = decode(
-      sql
-        .exec(
-          `WITH changes (id, revision, dueAt, stalls, progressKey, notBefore, state, reported, expected_revision) AS (
+    const rows = sql
+      .exec(
+        `WITH changes (id, revision, dueAt, stalls, progressKey, notBefore, state, reported, expected_revision) AS (
             VALUES ${changes.map(() => "(?, ?, ?, ?, ?, ?, ?, ?, ?)").join(", ")}
           ) INSERT INTO platform_cloudflare_due_queue
             (id, revision, dueAt, stalls, progressKey, notBefore, state, reported)
@@ -152,24 +151,24 @@ export const make = (storage: DurableObjectStorage) => {
             notBefore = excluded.notBefore, state = excluded.state, reported = excluded.reported
           WHERE platform_cloudflare_due_queue.revision = (
             SELECT expected_revision FROM changes WHERE changes.id = excluded.id
-          ) RETURNING id, revision, dueAt, stalls, progressKey, notBefore, state, reported`,
-          ...changes.flatMap(({ before, after }) => [
-            after.id,
-            after.revision,
-            after.dueAt,
-            after.stalls,
-            after.progressKey,
-            after.notBefore,
-            after.state,
-            after.reported,
-            before?.revision ?? -1,
-          ]),
-        )
-        .toArray(),
-    );
+          ) RETURNING 1`,
+        ...changes.flatMap(({ before, after }) => [
+          after.id,
+          after.revision,
+          after.dueAt,
+          after.stalls,
+          after.progressKey,
+          after.notBefore,
+          after.state,
+          after.reported,
+          before?.revision ?? -1,
+        ]),
+      )
+      .toArray();
 
     // Partial revision acceptance must reject the enclosing source transaction.
     if (rows.length !== changes.length)
+      // oxlint-disable-next-line effect/no-untyped-throw, effect/no-native-error -- Native storage transaction must roll back partial revision acceptance; its Effect adapter maps the cause.
       throw new Error("Maintenance due revision changed during transaction");
   };
 
@@ -204,6 +203,7 @@ export const make = (storage: DurableObjectStorage) => {
       return result;
     } catch (cause) {
       if (frame !== undefined) finish(frame, false);
+      // oxlint-disable-next-line effect/no-untyped-throw -- Native transaction Promise must reject with the original failure after invalidating speculative state.
       throw cause;
     }
   };
@@ -302,6 +302,24 @@ export const make = (storage: DurableObjectStorage) => {
     );
   };
 
+  /** Native checkpoints fence the generation, not each source commit. Once progress
+   * resets a claimed lane, further native commits owe the same recovery opportunity.
+   * A new claim, deadline, or retry budget makes the next commit advance it again. */
+  const progressNative = (dueAt: number) => {
+    const row = read().find((row) => row.id === Native);
+
+    if (
+      row?.state === "pending" &&
+      row.dueAt !== null &&
+      row.dueAt <= dueAt &&
+      row.stalls === 0 &&
+      row.notBefore === 0 &&
+      row.reported === 0
+    )
+      return;
+    dirty(Native, dueAt, true);
+  };
+
   /** A strictly increasing source cursor; old or repeated notices cannot renew a budget. */
   const progress = (id: string, dueAt: number, cursor: bigint) => {
     Schema.decodeSync(Schema.BigInt.check(Schema.isGreaterThanOrEqualToBigInt(0n)))(cursor);
@@ -416,6 +434,7 @@ export const make = (storage: DurableObjectStorage) => {
     transaction,
     read,
     dirty,
+    progressNative,
     progress,
     register,
     claim,

package/src/internal/layers.ts

@@ -134,7 +134,7 @@ import * as DueQueue from "./due-queue.ts";
 import { LiveTextHub } from "./live-text.ts";
 import {
   guardedMessageDeliveryStoreLayer,
-  threadMessageDeliveryLayer,
+  lazyThreadMessageDeliveryLayer,
 } from "./message-delivery.ts";
 import { cloudflarePreparedInputAdmissionLayer } from "./prepared-admission.ts";
 import { ProgressWaitRegistry } from "./progress-wait.ts";
@@ -625,10 +625,14 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
         verifyOnOpen: config.verifyOnOpen,
       };
 
-      const infrastructure = Layer.mergeAll(
-        options.lifecyclePublication === undefined ? Layer.empty : lifecyclePublicationLayer,
-        storageConfigLayer(storageOptions),
-        Layer.effect(SqlClient)(SqlClient),
+      // Memoize these shared compositions within this Object's build, so repeated
+      // consumers reuse their contexts as well as the scoped leaf services.
+      const infrastructure = Layer.suspend(() =>
+        Layer.mergeAll(
+          options.lifecyclePublication === undefined ? Layer.empty : lifecyclePublicationLayer,
+          storageConfigLayer(storageOptions),
+          Layer.effect(SqlClient)(SqlClient),
+        ),
       );
 
       // Preserve the database owner's reader gate and rollback invalidators, while
@@ -638,6 +642,7 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
           const owner = yield* SqlStorageOwner;
           const mutations = yield* ThreadMutationGate;
 
+          // oxlint-disable-next-line effect/no-native-error -- Missing host SQL ownership is an assembly defect, not a recoverable workflow failure.
           if (owner === undefined) return yield* Effect.die(new Error("SQL owner unavailable"));
 
           return {
@@ -660,7 +665,7 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
         }),
       ).pipe(Layer.provide(sqlOwnerLayer));
 
-      const localInfrastructure = Layer.mergeAll(infrastructure, sourceOwner);
+      const localInfrastructure = Layer.suspend(() => Layer.mergeAll(infrastructure, sourceOwner));
 
       const sourceProgress = Layer.effect(SqlStorageProgress)(
         Effect.gen(function* () {
@@ -708,41 +713,57 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
 
       // The same local ports serve routed decorators and owner-side RPC execution.
       // The RPC executor must never receive routed ports and bounce requests between Objects.
-      const rawLocalPorts = Layer.mergeAll(threadStoreLayer, submissionLedgerLayer).pipe(
-        Layer.provide(localInfrastructure),
-        Layer.provide(sourceProgress),
+      const rawLocalPorts = Layer.suspend(() =>
+        Layer.mergeAll(threadStoreLayer, submissionLedgerLayer).pipe(
+          Layer.provide(localInfrastructure),
+          Layer.provide(sourceProgress),
+        ),
+      );
+
+      const base = Layer.suspend(() =>
+        Layer.mergeAll(DurableAlarmService.layer, ProgressWaitRegistry.layer),
       );
 
-      const base = Layer.mergeAll(DurableAlarmService.layer, ProgressWaitRegistry.layer);
       const wakes = cloudflareWakeSchedulerLayer.pipe(Layer.provide(base));
 
-      const messageStore = guardedMessageDeliveryStoreLayer.pipe(
-        Layer.provide(
-          doMessageDeliveryStoreLayer().pipe(
-            Layer.provide(localInfrastructure),
-            Layer.provide(sourceProgress),
+      const messageStore = Layer.suspend(() =>
+        guardedMessageDeliveryStoreLayer.pipe(
+          Layer.provide(
+            doMessageDeliveryStoreLayer().pipe(
+              Layer.provide(localInfrastructure),
+              Layer.provide(sourceProgress),
+            ),
           ),
+          Layer.provide(wakes),
         ),
-        Layer.provide(wakes),
       );
 
-      const messageRecovery = threadMessageDeliveryLayer.pipe(
-        // Four parallel attempts per wave. Native completion stops new wake-driven waves;
-        // retained retry deadlines schedule future alarms.
-        Layer.provide(MessageDeliveryDriver.layer({ batchSize: 4, concurrency: 4 })),
-        Layer.provide(cloudflarePreparedInputAdmissionLayer),
-        Layer.provide(CloudflareThreadClient.layer),
-        Layer.provide(messageStore),
-        Layer.provide(wakes),
+      const messageRecovery = Layer.suspend(() =>
+        lazyThreadMessageDeliveryLayer(
+          // Four parallel attempts per wave. Native completion stops new wake-driven waves;
+          // retained retry deadlines schedule future alarms.
+          MessageDeliveryDriver.layer({ batchSize: 4, concurrency: 4 }).pipe(
+            Layer.provide(cloudflarePreparedInputAdmissionLayer),
+            Layer.provide(CloudflareThreadClient.layer),
+            Layer.provide(messageStore),
+            Layer.provide(wakes),
+          ),
+        ).pipe(Layer.provide(messageStore)),
       );
 
-      const publication = (options.publication ?? ThreadPublication.layer).pipe(
-        Layer.provide(Layer.mergeAll(rawLocalPorts, Layer.effect(SqlClient)(SqlClient))),
-      );
+      const publication =
+        options.publication === undefined
+          ? ThreadPublication.layer
+          : options.publication.pipe(
+              Layer.provide(Layer.mergeAll(rawLocalPorts, Layer.effect(SqlClient)(SqlClient))),
+            );
 
-      const projection = (options.projection ?? ThreadProjectionMaintenance.layer).pipe(
-        Layer.provide(Layer.mergeAll(rawLocalPorts, Layer.effect(SqlClient)(SqlClient))),
-      );
+      const projection =
+        options.projection === undefined
+          ? ThreadProjectionMaintenance.layer
+          : options.projection.pipe(
+              Layer.provide(Layer.mergeAll(rawLocalPorts, Layer.effect(SqlClient)(SqlClient))),
+            );
 
       const localPorts =
         options.publication === undefined &&
@@ -889,71 +910,71 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
                 return Context.make(ThreadStore, observedStore).pipe(
                   Context.add(StorageOwner, storageOwner),
                   Context.add(SettlementPublisher, {
-                    publish: (input) =>
-                      Effect.gen(function* () {
-                        const { request } = yield* validatePublication(input);
-
-                        return yield* mutations
-                          .withMutation(
-                            sourceCommits
-                              .withPermit(
-                                settlementPublisher.publish(request).pipe(
-                                  Effect.tap((result) =>
-                                    result.replayed
-                                      ? Effect.void
-                                      : index
-                                          .applyCommitted(
-                                            request.append,
-                                            AppendResult.make({
-                                              firstSequence: result.tailSequence,
-                                              lastSequence: result.tailSequence,
-
-                                              replayed: false,
-                                            }),
-                                          )
-                                          .pipe(
-                                            Effect.catchCause((cause) =>
-                                              Cause.hasInterrupts(cause)
-                                                ? Effect.interrupt
-                                                : Effect.logError(
-                                                    "Thread projection deferred after settlement publication",
-                                                    cause,
-                                                  ),
-                                            ),
+                    publish: Effect.fnUntraced(function* (input) {
+                      const { request } = yield* validatePublication(input);
+
+                      return yield* mutations
+                        .withMutation(
+                          sourceCommits
+                            .withPermit(
+                              settlementPublisher.publish(request).pipe(
+                                Effect.tap((result) =>
+                                  result.replayed
+                                    ? Effect.void
+                                    : index
+                                        .applyCommitted(
+                                          request.append,
+                                          AppendResult.make({
+                                            firstSequence: result.tailSequence,
+                                            lastSequence: result.tailSequence,
+
+                                            replayed: false,
+                                          }),
+                                        )
+                                        .pipe(
+                                          Effect.catchCause((cause) =>
+                                            Cause.hasInterrupts(cause)
+                                              ? Effect.interrupt
+                                              : Effect.logError(
+                                                  "Thread projection deferred after settlement publication",
+                                                  cause,
+                                                ),
                                           ),
-                                  ),
+                                        ),
                                 ),
-                              )
-                              .pipe(Effect.tap(() => afterCommit)),
-                            {
-                              lanes: [
-                                ...(options.projection === undefined ? [] : [DueQueue.Projection]),
-                                ...(options.lifecyclePublication === undefined
-                                  ? []
-                                  : [DueQueue.Lifecycle]),
-                              ],
-                            },
-                          )
-                          .pipe(
-                            Effect.catchTag("DurableAlarmError", (cause) =>
-                              ThreadStoreError.make({
-                                operation: "prearm settlement publication",
-                                message: cause.message,
-                                cause,
-                              }),
-                            ),
-                          );
-                      }),
+                              ),
+                            )
+                            .pipe(Effect.tap(() => afterCommit)),
+                          {
+                            lanes: [
+                              ...(options.projection === undefined ? [] : [DueQueue.Projection]),
+                              ...(options.lifecyclePublication === undefined
+                                ? []
+                                : [DueQueue.Lifecycle]),
+                            ],
+                          },
+                        )
+                        .pipe(
+                          Effect.catchTag("DurableAlarmError", (cause) =>
+                            ThreadStoreError.make({
+                              operation: "prearm settlement publication",
+                              message: cause.message,
+                              cause,
+                            }),
+                          ),
+                        );
+                    }),
                   }),
                   Context.add(SubmissionLedger, {
                     ...ledger,
-                    ...(options.hostLanesForMutation === undefined
+                    ...(options.hostLanesForMutation === undefined &&
+                    options.lifecyclePublication === undefined
                       ? {}
                       : {
-                          admit: (request: AdmissionRequest) =>
+                          admit: (...args: Parameters<SubmissionLedger["Service"]["admit"]>) =>
                             observeMutation(
-                              { _tag: "Admission", request },
-                              ledger.admit(request),
+                              { _tag: "Admission", request: args[0] },
+                              ledger.admit(...args),
                               false,
                             ),
                         }),

package/src/internal/message-delivery.ts

@@ -5,7 +5,7 @@ import {
   MessageDeliveryStore,
 } from "@yielded/agent/message-delivery";
 import { WakeScheduler } from "@yielded/agent/wake-scheduler";
-import { Clock, Context, Effect, Layer, Option } from "effect";
+import { Clock, Context, Duration, Effect, Exit, Layer, Option } from "effect";
 
 import { DurableAlarmError, ThreadMessageDelivery, ThreadMutationGate } from "../Alarm.ts";
 import { ThreadObjectPlacement } from "../CloudflareBindings.ts";
@@ -76,45 +76,69 @@ export const guardedMessageDeliveryStoreLayer = Layer.effect(
   }),
 );
 
-/** Message progress shares the native alarm slot without blocking source runtime work. */
-export const threadMessageDeliveryLayer = Layer.effectContext(
-  Effect.gen(function* () {
-    const driver = yield* MessageDeliveryDriver;
-    const store = yield* MessageDeliveryStore;
+/** Build the driver in the Object's Scope only when retained delivery work is due. */
+export const lazyThreadMessageDeliveryLayer = <E, R>(
+  driver: Layer.Layer<MessageDeliveryDriver, E, R>,
+) =>
+  Layer.fromBuildMemo((memoMap, scope) =>
+    Effect.gen(function* () {
+      const context = yield* Effect.context<R>();
+      const store = yield* MessageDeliveryStore;
 
-    const failure = (operation: string) => () =>
-      DurableAlarmError.make({
-        operation,
-        message: "Durable message recovery remains pending",
-      });
+      // Failed builds release their Layer scopes; let a later wave build again.
+      const service = yield* Effect.cachedWithTTL(
+        Layer.buildWithMemoMap(driver, memoMap, scope).pipe(
+          Effect.provide(context),
+          Effect.map(Context.get(MessageDeliveryDriver)),
+          Effect.mapError((cause) =>
+            DurableAlarmError.make({
+              operation: "prepare message delivery",
+              message: "Durable message recovery remains pending",
+              cause,
+            }),
+          ),
+        ),
+        (exit) => (Exit.isSuccess(exit) ? Duration.infinity : Duration.zero),
+      );
 
-    const prepare = Effect.gen(function* () {
-      const deadline = yield* store.nextDeadline();
+      const failure = (operation: string) => () =>
+        DurableAlarmError.make({
+          operation,
+          message: "Durable message recovery remains pending",
+        });
 
-      if (deadline === null || deadline > (yield* Clock.currentTimeMillis))
-        return { timeoutMillis: 1, run: Effect.succeed(Option.fromNullishOr(deadline)) };
-      // The assembled driver has four permits: a wave is one parallel attempt window.
-      const keys = yield* store.due(yield* Clock.currentTimeMillis, 4);
-      const records = yield* Effect.forEach(keys, (key) => store.get(key));
+      const prepare = Effect.gen(function* () {
+        const deadline = yield* store.nextDeadline();
 
-      return {
-        timeoutMillis: Math.max(
-          1,
-          ...records.map((record) => record?.policy.attemptTimeoutMillis ?? 1),
-        ),
-        run: Effect.forEach(keys, (key) => driver.process(key), {
-          concurrency: 4,
-          discard: true,
-        }).pipe(
-          Effect.andThen(store.nextDeadline()),
-          Effect.map(Option.fromNullishOr),
-          Effect.mapError(failure("dispatch message delivery")),
-        ),
-      };
-    }).pipe(Effect.mapError(failure("prepare message delivery")));
+        if (deadline === null || deadline > (yield* Clock.currentTimeMillis))
+          return { timeoutMillis: 1, run: Effect.succeed(Option.fromNullishOr(deadline)) };
+        // The assembled driver has four permits: a wave is one parallel attempt window.
+        const keys = yield* store.due(yield* Clock.currentTimeMillis, 4);
+        const records = yield* Effect.forEach(keys, (key) => store.get(key));
 
-    return Context.make(ThreadMessageDelivery, {
-      prepare,
-    });
-  }),
+        return {
+          timeoutMillis: Math.max(
+            1,
+            ...records.map((record) => record?.policy.attemptTimeoutMillis ?? 1),
+          ),
+          run: Effect.flatMap(service, (driver) =>
+            Effect.forEach(keys, (key) => driver.process(key), {
+              concurrency: 4,
+              discard: true,
+            }),
+          ).pipe(
+            Effect.andThen(store.nextDeadline()),
+            Effect.map(Option.fromNullishOr),
+            Effect.mapError(failure("dispatch message delivery")),
+          ),
+        };
+      }).pipe(Effect.mapError(failure("prepare message delivery")));
+
+      return Context.make(ThreadMessageDelivery, { prepare });
+    }),
+  );
+
+/** Message progress shares the native alarm slot without blocking source runtime work. */
+export const threadMessageDeliveryLayer = lazyThreadMessageDeliveryLayer(
+  Layer.effect(MessageDeliveryDriver, MessageDeliveryDriver),
 );