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

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

@@ -638,6 +638,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 {
@@ -889,61 +890,60 @@ 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,