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

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
@@ -661,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* () {
@@ -709,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 &&
@@ -947,13 +967,14 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
                   }),
                   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),
 );