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

package/src/Alarm.ts

@@ -217,7 +217,7 @@ type MaintenanceCheckpoint = {
   readonly mutations: Parameters<
     Parameters<ThreadMaintenanceAlarm["Service"]["transaction"]>[0]
   >[0];
-  readonly requireActive: Effect.Effect<void, DurableAlarmError>;
+  readonly isActive: (fiber: Fiber.Fiber<unknown, unknown>) => boolean;
 };
 
 const CurrentCheckpoint = Context.Reference<MaintenanceCheckpoint | undefined>(
@@ -232,31 +232,27 @@ const makeAlarmOperation = Effect.gen(function* () {
   const { ctx } = yield* DurableObjectContext;
   const queue = DueQueue.make(ctx.storage);
 
-  const transaction: SqlClient["withTransaction"] = (body) =>
+  const transaction = <A, E, R>(
+    body: (owner: Fiber.Fiber<unknown, unknown>) => Effect.Effect<A, E, R>,
+  ): Effect.Effect<A, E | SqlError, R> =>
     alarms
       .transaction(
         (mutations) =>
           Effect.withFiber((owner) => {
             let active = true;
 
-            const requireActive = Effect.withFiber((fiber) =>
-              active && fiber === owner
-                ? Effect.void
-                : Effect.fail(
-                    DurableAlarmError.make({
-                      operation: "enroll maintenance source",
-                      message: "Source intent requires its active transaction callback's fiber",
-                    }),
-                  ),
-            );
-
-            return body.pipe(
-              Effect.provideService(CurrentCheckpoint, { mutations, requireActive }),
-              Effect.ensuring(
-                Effect.sync(() => {
-                  active = false;
+            return Effect.onExitPrimitive(
+              body(owner).pipe(
+                Effect.provideService(CurrentCheckpoint, {
+                  mutations,
+                  isActive: (fiber) => active && fiber === owner,
                 }),
               ),
+              () => {
+                active = false;
+
+                return undefined;
+              },
             );
           }),
         { sqlClient: sql },
@@ -276,7 +272,9 @@ const makeAlarmOperation = Effect.gen(function* () {
       );
 
   const withTransaction = <A, E, R>(body: Effect.Effect<A, E, R>) =>
-    Effect.flatMap(Effect.serviceOption(sql.transactionService), (ambient) => {
+    Effect.withFiber((fiber) => {
+      const ambient = Context.getOption(fiber.context, sql.transactionService);
+
       if (ambient._tag === "Some" && !DueQueue.ownsTransaction(ctx.storage, ambient.value[1]))
         return Effect.fail(
           SqlError.make({
@@ -287,53 +285,53 @@ const makeAlarmOperation = Effect.gen(function* () {
             }),
           }),
         );
+      let frame: ReturnType<typeof queue.begin> | undefined;
 
       return Effect.uninterruptibleMask((restore) =>
-        Effect.suspend(() => {
-          let frame: ReturnType<typeof queue.begin> | undefined;
+        Effect.onExitPrimitive(
+          transaction((owner) => {
+            const current = Context.getOption(owner.context, sql.transactionService);
 
-          return transaction(
-            Effect.flatMap(Effect.serviceOption(sql.transactionService), (transaction) =>
-              Effect.gen(function* () {
-                if (transaction._tag === "None")
-                  return yield* SqlError.make({
+            if (current._tag === "None")
+              return SqlError.make({
+                reason: UnknownError.make({
+                  operation: "begin maintenance source transaction",
+                  message: "SQL transaction unavailable",
+                  cause: "SQL transaction unavailable",
+                }),
+              });
+            const started = queue.begin(current.value[1]);
+
+            frame = started;
+
+            return Effect.flatMap(restore(body), (value) =>
+              Effect.try({
+                try: () => {
+                  queue.flush(started);
+
+                  return value;
+                },
+                catch: (cause) =>
+                  SqlError.make({
                     reason: UnknownError.make({
-                      operation: "begin maintenance source transaction",
-                      message: "SQL transaction unavailable",
-                      cause: "SQL transaction unavailable",
-                    }),
-                  });
-                frame = queue.begin(transaction.value[1]);
-              }),
-            ).pipe(
-              Effect.andThen(restore(body)),
-              Effect.tap(() =>
-                Effect.try({
-                  try: () => {
-                    if (frame !== undefined) queue.flush(frame);
-                  },
-                  catch: (cause) =>
-                    SqlError.make({
-                      reason: UnknownError.make({
-                        cause,
-                        operation: "flush maintenance due queue",
-                        message: "Maintenance intent could not commit",
-                      }),
+                      cause,
+                      operation: "flush maintenance due queue",
+                      message: "Maintenance intent could not commit",
                     }),
-                }),
-              ),
-            ),
-          ).pipe(
-            Effect.onExit((exit) =>
-              Effect.sync(() => {
-                if (frame !== undefined) queue.finish(frame, Exit.isSuccess(exit));
+                  }),
               }),
-            ),
-            // A released permit can resume another transaction. Do not auto-yield
-            // between the driver's settlement and removing this transaction's frame.
-            Effect.provideService(Scheduler.PreventSchedulerYield, true),
-          );
-        }),
+            );
+          }),
+          (exit) => {
+            if (frame !== undefined) queue.finish(frame, Exit.isSuccess(exit));
+
+            return undefined;
+          },
+        ).pipe(
+          // A released permit can resume another transaction. Do not auto-yield
+          // between the driver's settlement and removing this transaction's frame.
+          Effect.provideService(Scheduler.PreventSchedulerYield, true),
+        ),
       );
     }).pipe(Effect.provideService(SqlClient, sql));
 
@@ -352,32 +350,33 @@ const makeAlarmOperation = Effect.gen(function* () {
           }),
         );
 
-      return tx.requireActive.pipe(
-        Effect.andThen(
-          Effect.suspend(() => {
-            let checkpoint: ReturnType<DurableObjectAlarm.AlarmScheduler["scheduleAlarm"]> =
-              Effect.void;
+      if (!tx.isActive(fiber))
+        return Effect.fail(
+          DurableAlarmError.make({
+            operation: "enroll maintenance source",
+            message: "Source intent requires its active transaction callback's fiber",
+          }),
+        );
 
-            const intent: CheckpointIntent = {
-              at: (at) => {
-                checkpoint = tx.mutations.scheduleAlarm(maintenanceAlarmInput(at));
-              },
-              earlier: (at) => {
-                checkpoint = tx.mutations.scheduleAlarmEarlier(maintenanceAlarmInput(at));
-              },
-              cancel: () => {
-                checkpoint = tx.mutations.cancelAlarm(maintenanceAlarmRef);
-              },
-            };
+      let checkpoint: ReturnType<DurableObjectAlarm.AlarmScheduler["scheduleAlarm"]> = Effect.void;
 
-            // The SQL/alarm callback already owns the native transaction; KV uses the same storage.
-            return Effect.tryPromise({
-              try: () => execute(ctx.storage, intent),
-              catch: alarmFailure(operation),
-            }).pipe(Effect.tap(() => checkpoint));
-          }),
-        ),
-      );
+      const intent: CheckpointIntent = {
+        at: (at) => {
+          checkpoint = tx.mutations.scheduleAlarm(maintenanceAlarmInput(at));
+        },
+        earlier: (at) => {
+          checkpoint = tx.mutations.scheduleAlarmEarlier(maintenanceAlarmInput(at));
+        },
+        cancel: () => {
+          checkpoint = tx.mutations.cancelAlarm(maintenanceAlarmRef);
+        },
+      };
+
+      // The SQL/alarm callback already owns the native transaction; KV uses the same storage.
+      return Effect.tryPromise({
+        try: () => execute(ctx.storage, intent),
+        catch: alarmFailure(operation),
+      }).pipe(Effect.tap(() => checkpoint));
     });
 
     return Effect.withFiber((fiber) => {
@@ -388,7 +387,7 @@ const makeAlarmOperation = Effect.gen(function* () {
 
       // Preserve eager writes and invalidation for an unwrapped host SQL transaction.
       return ambient._tag === "Some" && !DueQueue.buffering(ctx.storage)
-        ? transaction(commit).pipe(
+        ? transaction(() => commit).pipe(
             Effect.ensuring(Effect.sync(() => DueQueue.invalidate(ctx.storage))),
           )
         : withTransaction(commit);

package/src/internal/layers.ts

@@ -7,6 +7,7 @@ import {
 import { submissionLedgerLayer } from "@yielded/agent-storage-cloudflare/do-submission-ledger";
 import {
   threadStoreLayer,
+  journalLayer,
   storageConfigLayer,
   storageFailpointLayer,
   sqlOwnerLayer,
@@ -83,8 +84,15 @@ import {
   type WorkerStopCommand,
 } from "@yielded/agent/submission-ledger";
 import { ThreadProjectionMaintenance } from "@yielded/agent/thread-projection-maintenance";
-import type { ThreadReader } from "@yielded/agent/thread-store";
-import { AppendResult, ThreadStoreError, ThreadStore } from "@yielded/agent/thread-store";
+import {
+  type ThreadReader,
+  AppendResult,
+  type AppendRequest,
+  type ThreadStoreFailure,
+  PreparedAppend,
+  ThreadStoreError,
+  ThreadStore,
+} from "@yielded/agent/thread-store";
 import { ToolReconciler } from "@yielded/agent/tool-reconciler";
 import { type WakeScheduler } from "@yielded/agent/wake-scheduler";
 import {
@@ -715,6 +723,7 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
       // The RPC executor must never receive routed ports and bounce requests between Objects.
       const rawLocalPorts = Layer.suspend(() =>
         Layer.mergeAll(threadStoreLayer, submissionLedgerLayer).pipe(
+          Layer.provide(journalLayer),
           Layer.provide(localInfrastructure),
           Layer.provide(sourceProgress),
         ),
@@ -785,6 +794,54 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
                 // Publication remains outside this local source/index critical section.
                 const sourceCommits = yield* Semaphore.make(1);
 
+                const observeAppend = (
+                  request: AppendRequest,
+                  body: Effect.Effect<AppendResult, ThreadStoreFailure>,
+                ) =>
+                  mutations
+                    .withMutation(
+                      sourceCommits
+                        .withPermit(
+                          body.pipe(
+                            Effect.tap((result) =>
+                              index
+                                .applyCommitted(request, result)
+                                .pipe(
+                                  Effect.catchCause((cause) =>
+                                    Cause.hasInterrupts(cause)
+                                      ? Effect.interrupt
+                                      : Effect.logError(
+                                          "Thread projection deferred after source commit",
+                                          cause,
+                                        ),
+                                  ),
+                                ),
+                            ),
+                          ),
+                        )
+                        .pipe(Effect.tap(() => afterCommit)),
+                      {
+                        lanes: [
+                          ...(options.projection === undefined ? [] : [DueQueue.Projection]),
+                          ...(options.lifecyclePublication === undefined ||
+                          !request.batch.records.some((record) =>
+                            Schema.is(Schema.toType(LifecyclePublicationFact))(record.payload),
+                          )
+                            ? []
+                            : [DueQueue.Lifecycle]),
+                        ],
+                      },
+                    )
+                    .pipe(
+                      Effect.catchTag("DurableAlarmError", (cause) =>
+                        ThreadStoreError.make({
+                          operation: "prearm publication append",
+                          message: cause.message,
+                          cause,
+                        }),
+                      ),
+                    );
+
                 // Every runtime-owned producer prearms too: a crash between commit and invalidation
                 // leaves a NEW, uncertified generation. Source errors keep their native port types.
                 const observedStore = ThreadStore.of({
@@ -807,52 +864,7 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
                               ),
                         },
                       }),
-                  append: (request) =>
-                    mutations
-                      .withMutation(
-                        sourceCommits
-                          .withPermit(
-                            store
-                              .append(request)
-                              .pipe(
-                                Effect.tap((result) =>
-                                  index
-                                    .applyCommitted(request, result)
-                                    .pipe(
-                                      Effect.catchCause((cause) =>
-                                        Cause.hasInterrupts(cause)
-                                          ? Effect.interrupt
-                                          : Effect.logError(
-                                              "Thread projection deferred after source commit",
-                                              cause,
-                                            ),
-                                      ),
-                                    ),
-                                ),
-                              ),
-                          )
-                          .pipe(Effect.tap(() => afterCommit)),
-                        {
-                          lanes: [
-                            ...(options.projection === undefined ? [] : [DueQueue.Projection]),
-                            ...(options.lifecyclePublication === undefined ||
-                            !request.batch.records.some((record) =>
-                              Schema.is(Schema.toType(LifecyclePublicationFact))(record.payload),
-                            )
-                              ? []
-                              : [DueQueue.Lifecycle]),
-                          ],
-                        },
-                      )
-                      .pipe(
-                        Effect.catchTag("DurableAlarmError", (cause) =>
-                          ThreadStoreError.make({
-                            operation: "prearm publication append",
-                            message: cause.message,
-                            cause,
-                          }),
-                        ),
-                      ),
+                  append: (request) => observeAppend(request, store.append(request)),
                 });
 
                 const observeIntent = <A, Failure>(
@@ -906,6 +918,7 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
                   );
 
                 const stopWorker = ledger.stopWorker;
+                const appendInput = ledger.appendInput;
 
                 return Context.make(ThreadStore, observedStore).pipe(
                   Context.add(StorageOwner, storageOwner),
@@ -967,6 +980,14 @@ const sharedLayer = <A, E, R, PE = never, PR = never>(
                   }),
                   Context.add(SubmissionLedger, {
                     ...ledger,
+                    ...(appendInput === undefined
+                      ? {}
+                      : {
+                          appendInput: (submissionId, input) =>
+                            Effect.flatMap(PreparedAppend.capture(input), (request) =>
+                              observeAppend(request, appendInput(submissionId, request)),
+                            ),
+                        }),
                     ...(options.hostLanesForMutation === undefined &&
                     options.lifecyclePublication === undefined
                       ? {}