@lostgradient/weft 0.14.0 → 0.16.0

package/dist/server/operations/update-schedule.js

@@ -1,9 +1,15 @@
 import { z } from "zod";
-import { normalizeScheduleUpdateOptions } from "../../core/engine/validation/schedule.js";
 import { defineOperation } from "../operation-registry.js";
-import { readRestJsonBody } from "../rest-body.js";
-import { invalidParamsFault, isOperationFault, shapeRestFault } from "./operation-helpers.js";
-import { mapScheduleErrorToFault, validateScheduleInputCadence } from "./schedule-faults.js";
+import { shapeRestFault } from "./operation-helpers.js";
+import {
+  mapScheduleErrorToFault,
+  validateScheduleInputCadence,
+  validateScheduleMutableOptions
+} from "./schedule-faults.js";
+import {
+  extractSharedScheduleRestFields,
+  parseScheduleRestBodyRequestRecord
+} from "./schedule-rest-body.js";
 const updateScheduleInput = z.object({
   scheduleId: z.string().min(1),
   cronExpression: z.unknown().optional().describe("Cron expression. Supply exactly one of cronExpression or every; runtime validation requires a non-empty string."),
@@ -13,56 +19,6 @@ const updateScheduleInput = z.object({
   backfill: z.unknown().optional(),
   jitter: z.unknown().optional()
 });
-function isScheduleOverlapPolicy(value) {
-  return value === "skip" || value === "queue" || value === "cancel-running" || value === "allow";
-}
-function validateDescription(value) {
-  if (value === void 0)
-    return;
-  if (typeof value !== "string")
-    throw invalidParamsFault('Field "description" must be a string');
-  return value;
-}
-function validateOverlap(value) {
-  if (value === void 0)
-    return;
-  if (typeof value !== "string" || !isScheduleOverlapPolicy(value))
-    throw invalidParamsFault('Field "overlap" must be one of skip, queue, cancel-running, allow');
-  return value;
-}
-function validateBackfill(value) {
-  if (value === void 0)
-    return;
-  if (typeof value !== "boolean")
-    throw invalidParamsFault('Field "backfill" must be a boolean');
-  return value;
-}
-function formatJitterValidationMessage(message) {
-  const enginePrefix = "Invalid options.jitter: ", hasEnginePrefix = message.startsWith(enginePrefix), wireDetail = (hasEnginePrefix ? message.slice(enginePrefix.length) : message).replaceAll("options.jitter", 'Field "jitter"');
-  return hasEnginePrefix ? `Field "jitter" is invalid: ${wireDetail}` : wireDetail;
-}
-function validateJitter(value) {
-  if (value === void 0)
-    return;
-  if (typeof value !== "string" && typeof value !== "number")
-    throw invalidParamsFault('Field "jitter" must be a duration string or a number of milliseconds');
-  try {
-    normalizeScheduleUpdateOptions({ jitter: value });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw invalidParamsFault(formatJitterValidationMessage(message));
-  }
-  return value;
-}
-function validateScheduleUpdateOptions(input) {
-  const description = validateDescription(input.description), overlap = validateOverlap(input.overlap), backfill = validateBackfill(input.backfill), jitter = validateJitter(input.jitter);
-  return {
-    ...description !== void 0 ? { description } : {},
-    ...overlap !== void 0 ? { overlap } : {},
-    ...backfill !== void 0 ? { backfill } : {},
-    ...jitter !== void 0 ? { jitter } : {}
-  };
-}
 export const updateScheduleOperation = defineOperation({
   name: "weft.schedules.update",
   mcpExposable: !1,
@@ -77,7 +33,7 @@ export const updateScheduleOperation = defineOperation({
   transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
   unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
   invoke: async ({ input, engine }) => {
-    const typedEngine = engine, spec = validateScheduleInputCadence(input), options = validateScheduleUpdateOptions(input);
+    const typedEngine = engine, spec = validateScheduleInputCadence(input), options = validateScheduleMutableOptions(input);
     try {
       await typedEngine.updateSchedule(input.scheduleId, spec, options);
       return null;
@@ -100,25 +56,10 @@ export const updateScheduleOperation = defineOperation({
     jitter: { kind: "body-field", bodyField: "jitter" }
   },
   extractInput: async (request, pathParams, context) => {
-    let body;
-    try {
-      body = await readRestJsonBody(request, context);
-    } catch (error) {
-      if (isOperationFault(error))
-        throw error;
-      throw invalidParamsFault("Invalid JSON body");
-    }
-    if (typeof body !== "object" || body === null)
-      throw invalidParamsFault("Request body must be a JSON object");
-    const record = body;
+    const record = await parseScheduleRestBodyRequestRecord(request, context);
     return {
       scheduleId: pathParams.id ?? "",
-      cronExpression: Object.hasOwn(record, "cronExpression") ? record.cronExpression : void 0,
-      every: Object.hasOwn(record, "every") ? record.every : void 0,
-      description: record.description,
-      overlap: record.overlap,
-      backfill: record.backfill,
-      jitter: record.jitter
+      ...extractSharedScheduleRestFields(record)
     };
   },
   success: { kind: "empty", status: 204 },

package/dist/server/operations/workflow-events-sse.js

@@ -4,6 +4,13 @@ import { isAuthenticated } from "../principal.js";
 import {
   decodeCursor
 } from "../workflow-event-feed.js";
+import {
+  createReplayAwareClosableIterable,
+  isClosableAsyncIterable,
+  isReplayAwareClosableIterable,
+  workflowEventEnvelopeSchema,
+  workflowEventParameterizedAccess
+} from "./event-stream-contracts.js";
 import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
 import {
   createEventEnvelopeSSEStream,
@@ -19,15 +26,7 @@ const INITIAL_CURSOR = "-1", MAX_WORKFLOW_SSE_REPLAY_EVENTS = 1000, MAXIMUM_WORK
   selector: z.enum(["events", "tokens"]).default("events"),
   fromCursor: cursorSchema.optional(),
   lastEventId: cursorSchema.optional()
-}), workflowEventsSseOutputSchema = z.custom(isAsyncIterable, "Expected async iterable workflow event stream"), workflowEventEnvelopeSchema = z.object({
-  kind: z.string(),
-  workflowId: z.string(),
-  selector: z.enum(["events", "tokens"]),
-  sequence: z.number(),
-  cursor: z.string(),
-  emittedAtMs: z.number(),
-  payload: z.unknown()
-});
+}), workflowEventsSseOutputSchema = z.custom(isAsyncIterable, "Expected async iterable workflow event stream");
 export const workflowEventsSseOperation = defineOperation({
   name: "weft.workflows.events.sse",
   mcpExposable: !1,
@@ -39,20 +38,7 @@ export const workflowEventsSseOperation = defineOperation({
   inputSchema: workflowEventsSseInputSchema,
   outputSchema: workflowEventsSseOutputSchema,
   eventSchema: workflowEventEnvelopeSchema,
-  parameterizedAccess: {
-    discriminator: "selector",
-    defaultValue: "events",
-    variants: [
-      {
-        value: "events",
-        access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["events:read"] } }
-      },
-      {
-        value: "tokens",
-        access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["streams:read"] } }
-      }
-    ]
-  },
+  parameterizedAccess: workflowEventParameterizedAccess,
   producibleFaults: ["InvalidParams", "UnsupportedTransport"],
   access: { kind: "authenticated" },
   authorize: async ({ input, principal }) => {
@@ -97,12 +83,6 @@ function isAsyncIterable(value) {
     return !1;
   return typeof value[Symbol.asyncIterator] === "function";
 }
-function isClosableWorkflowEventsIterable(value) {
-  return "close" in value && typeof value.close === "function";
-}
-function isReplayAwareWorkflowEventsIterable(value) {
-  return isClosableWorkflowEventsIterable(value) && "replayComplete" in value && value.replayComplete instanceof Promise;
-}
 function createWorkflowEventsIterable(input, context) {
   const feed = context.workflowEventFeed;
   if (feed === void 0)
@@ -110,51 +90,33 @@ function createWorkflowEventsIterable(input, context) {
   const lease = context.acquireWorkflowStreamConnection?.(input.workflowId);
   if (lease === null)
     throw maximumWorkflowStreamsFault();
-  const controller = new AbortController, replayComplete = Promise.withResolvers();
-  let closed = !1;
-  const close = async () => {
-    if (closed)
-      return;
-    closed = !0;
-    controller.abort();
-    lease?.release();
-  }, fromCursor = input.lastEventId ?? input.fromCursor ?? INITIAL_CURSOR, subscribeOptions = {
-    workflowId: input.workflowId,
-    selector: input.selector,
-    fromCursor,
-    signal: controller.signal,
-    replayLimit: MAX_WORKFLOW_SSE_REPLAY_EVENTS,
-    onReplayComplete: () => replayComplete.resolve(),
-    createReplayLimitError: (count, limit) => invalidParamsFault(`Workflow event replay window is ${count} events; maximum is ${limit}. Supply a more recent fromCursor.`)
-  };
-  let source;
-  try {
-    source = feed.subscribe(subscribeOptions);
-  } catch (error) {
-    close();
-    throw error;
-  }
-  return {
-    async* [Symbol.asyncIterator]() {
-      try {
-        for await (const envelope of source)
-          yield envelope;
-      } finally {
-        await close();
-      }
-    },
-    replayComplete: replayComplete.promise,
-    close
-  };
+  const fromCursor = input.lastEventId ?? input.fromCursor ?? INITIAL_CURSOR, controller = new AbortController;
+  return createReplayAwareClosableIterable((onReplayComplete) => {
+    const subscribeOptions = {
+      workflowId: input.workflowId,
+      selector: input.selector,
+      fromCursor,
+      signal: controller.signal,
+      replayLimit: MAX_WORKFLOW_SSE_REPLAY_EVENTS,
+      onReplayComplete,
+      createReplayLimitError: (count, limit) => invalidParamsFault(`Workflow event replay window is ${count} events; maximum is ${limit}. Supply a more recent fromCursor.`)
+    };
+    return feed.subscribe(subscribeOptions);
+  }, {
+    close: () => {
+      controller.abort();
+      lease?.release();
+    }
+  });
 }
 function shapeWorkflowEventsSseSuccess(output, request) {
-  const close = isClosableWorkflowEventsIterable(output) ? () => output.close() : async () => {
+  const close = isClosableAsyncIterable(output) ? () => output.close() : async () => {
     return;
   };
   return new Response(createEventEnvelopeSSEStream({
     iterable: output,
     close,
-    ...isReplayAwareWorkflowEventsIterable(output) ? { ready: output.replayComplete } : {},
+    ...isReplayAwareClosableIterable(output) ? { ready: output.replayComplete } : {},
     signal: request.signal
   }), {
     status: 200,

package/dist/server/operations/workflow-events-subscription.js

@@ -4,6 +4,11 @@ import { isAuthenticated } from "../principal.js";
 import {
   decodeCursor
 } from "../workflow-event-feed.js";
+import {
+  createReplayAwareClosableIterable,
+  workflowEventEnvelopeSchema,
+  workflowEventParameterizedAccess
+} from "./event-stream-contracts.js";
 import { invalidParamsFault } from "./operation-helpers.js";
 const INITIAL_SUBSCRIPTION_CURSOR = "-1", MAX_WORKFLOW_SUBSCRIPTION_REPLAY_EVENTS = 1000, workflowEventsSubscriptionInput = z.object({
   workflowId: z.string().min(1),
@@ -24,30 +29,9 @@ export const workflowEventsSubscriptionOperation = defineOperation({
   inputSchema: workflowEventsSubscriptionInput,
   outputSchema: workflowEventsSubscriptionEnvelope,
   producibleFaults: ["InvalidParams"],
-  eventSchema: z.object({
-    kind: z.string(),
-    workflowId: z.string(),
-    selector: z.enum(["events", "tokens"]),
-    sequence: z.number(),
-    cursor: z.string(),
-    emittedAtMs: z.number(),
-    payload: z.unknown()
-  }),
+  eventSchema: workflowEventEnvelopeSchema,
   access: { kind: "authenticated" },
-  parameterizedAccess: {
-    discriminator: "selector",
-    defaultValue: "events",
-    variants: [
-      {
-        value: "events",
-        access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["events:read"] } }
-      },
-      {
-        value: "tokens",
-        access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["streams:read"] } }
-      }
-    ]
-  },
+  parameterizedAccess: workflowEventParameterizedAccess,
   authorize: async ({ input, principal }) => {
     const requiredScope = workflowSubscriptionScope(input.selector);
     if (!isAuthenticated(principal))
@@ -71,13 +55,11 @@ export const workflowEventsSubscriptionOperation = defineOperation({
       signal: controller.signal,
       replayLimit: MAX_WORKFLOW_SUBSCRIPTION_REPLAY_EVENTS,
       createReplayLimitError: (count, limit) => invalidParamsFault(`Workflow event replay window is ${count} events; maximum is ${limit}. Supply a more recent fromCursor.`)
-    }, iterable = feed.subscribe(subscribeOptions);
+    }, iterable = createReplayAwareClosableIterable((onReplayComplete) => feed.subscribe({ ...subscribeOptions, onReplayComplete }), { close: () => controller.abort() });
     return {
       envelope: { subscriptionId: `sub_${crypto.randomUUID()}`, cursor: startingCursor },
       iterable,
-      close: async () => {
-        controller.abort();
-      }
+      close: () => iterable.close()
     };
   }
 });

package/dist/server/rest-bindings.js

@@ -98,6 +98,7 @@ import {
   getWorkflowTimelineRestBinding
 } from "./operations/get-workflow-timeline.js";
 import { getWorkflowOperation, getWorkflowRestBinding } from "./operations/get-workflow.js";
+import { listAlertsOperation, listAlertsRestBinding } from "./operations/list-alerts.js";
 import {
   listCheckpointsOperation,
   listCheckpointsRestBinding
@@ -214,6 +215,7 @@ import {
 } from "./operations/workflow-events-sse.js";
 import { workflowEventsSubscriptionOperation } from "./operations/workflow-events-subscription.js";
 export const REST_BINDINGS = [
+  listAlertsRestBinding,
   startWorkflowRestBinding,
   startOrSignalWorkflowRestBinding,
   recoverAllRestBinding,
@@ -401,6 +403,7 @@ export function createLiveOperationRegistry(options) {
     buildTaskDiagnosticsOperationForRegistry(resolved),
     clearTaskDeadLetterOperation,
     listSchedulesOperation,
+    listAlertsOperation,
     getScheduleOperation,
     replayWorkflowOperation,
     storageCapabilities.storageCapabilitiesOperation,

package/dist/server/runtime/task-polling.js

@@ -33,8 +33,8 @@ function validateTaskResultBody(body) {
   if (status !== "completed" && status !== "failed")
     return Response.json({ error: 'status must be "completed" or "failed"' }, { status: 400 });
   const rawAttemptToken = body.attemptToken;
-  if (rawAttemptToken !== void 0 && (typeof rawAttemptToken !== "string" || rawAttemptToken === ""))
-    return Response.json({ error: "attemptToken must be a non-empty string when present" }, { status: 400 });
+  if (typeof rawAttemptToken !== "string" || rawAttemptToken === "")
+    return Response.json({ error: "attemptToken must be a non-empty string" }, { status: 400 });
   return {
     operationId,
     status,
@@ -190,7 +190,5 @@ export async function handleTaskResultRequest(context, options, request, url, pr
 function isLongPollCompletionAuthorized(inflightRecord, validated) {
   if (validated.workerId === void 0 || inflightRecord.workerId !== validated.workerId)
     return !1;
-  if (inflightRecord.attemptToken !== void 0 && validated.attemptToken !== inflightRecord.attemptToken)
-    return !1;
-  return !0;
+  return validated.attemptToken === inflightRecord.attemptToken;
 }

package/dist/server/task-state.d.ts

@@ -73,14 +73,8 @@ export interface InflightRecord extends TaskLifecycleFields {
     workflowId?: string | undefined;
     /** Durable token for the workflow run that dispatched this activity, when known. */
     workflowExecutionToken?: string | undefined;
-    /**
-     * Unique, unguessable token identifying this dispatch attempt. Rotated on every
-     * (re-)dispatch because each dispatch writes a fresh InflightRecord. The
-     * long-poll completion handler rejects a result whose echoed token does not
-     * match this value. Optional for back-compatible decoding of records written
-     * before this field existed; a missing token disables the check for that record.
-     */
-    attemptToken?: string | undefined;
+    /** Unique, unguessable token identifying this dispatch attempt. */
+    attemptToken: string;
 }
 /** Persisted record for a task in the resolved state. */
 export interface ResolvedRecord {

package/dist/server/task-state.js

@@ -1,12 +1,16 @@
 import { decode, encode } from "../core/codec.js";
 import { KEYS } from "../storage/interface.js";
 import { buildResolvedRecord } from "./task-resolved-record.js";
-export async function getTaskState(storage, operationId) {
+async function readTaskStateSnapshot(storage, operationId) {
   const [inflight, queued, resolved] = await Promise.all([
     storage.get(KEYS.operationInflight(operationId)),
     storage.get(KEYS.operationQueued(operationId)),
     storage.get(KEYS.operationResolved(operationId))
   ]);
+  return { inflight, queued, resolved };
+}
+export async function getTaskState(storage, operationId) {
+  const { inflight, queued, resolved } = await readTaskStateSnapshot(storage, operationId);
   if (inflight !== null)
     return "inflight";
   if (queued !== null)
@@ -16,11 +20,7 @@ export async function getTaskState(storage, operationId) {
   return null;
 }
 export async function getExclusiveTaskState(storage, operationId) {
-  const [inflight, queued, resolved] = await Promise.all([
-    storage.get(KEYS.operationInflight(operationId)),
-    storage.get(KEYS.operationQueued(operationId)),
-    storage.get(KEYS.operationResolved(operationId))
-  ]), states = [];
+  const { inflight, queued, resolved } = await readTaskStateSnapshot(storage, operationId), states = [];
   if (inflight !== null)
     states.push("inflight");
   if (queued !== null)
@@ -37,11 +37,14 @@ export function isQueuedRecord(value) {
   const record = value;
   return typeof record.operationId === "string" && typeof record.activityName === "string" && typeof record.queue === "string" && typeof record.attempt === "number" && typeof record.visibilityTimeout === "number" && typeof record.queuedAt === "number";
 }
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
 export function isInflightRecord(value) {
   if (value === null || typeof value !== "object")
     return !1;
   const record = value;
-  return typeof record.operationId === "string" && typeof record.activityName === "string" && typeof record.queue === "string" && typeof record.attempt === "number" && typeof record.visibilityTimeout === "number" && typeof record.workerId === "string" && typeof record.deadline === "number";
+  return typeof record.operationId === "string" && typeof record.activityName === "string" && typeof record.queue === "string" && typeof record.attempt === "number" && typeof record.visibilityTimeout === "number" && typeof record.workerId === "string" && typeof record.deadline === "number" && isNonEmptyString(record.attemptToken);
 }
 export function isResolvedRecord(value) {
   if (value === null || typeof value !== "object")

package/dist/service-worker/index.d.ts

@@ -8,6 +8,7 @@
  */
 import type { RegistryAgnosticEngine } from '../core/engine';
 import type { ServiceWorkerScheduler } from './scheduler.ts';
+import type { ServiceWorkerHandlerOptions } from './setup.ts';
 import type { MinimalExtendableEvent, MinimalFetchEvent, MinimalPeriodicSyncEvent } from './shared.ts';
 export { ServiceWorkerScheduler } from './scheduler.ts';
 export type { ServiceWorkerSchedulerOptions } from './scheduler.ts';
@@ -44,6 +45,8 @@ export interface ServiceWorkerOptions {
      */
     engine: RegistryAgnosticEngine;
     pathPrefix?: string;
+    /** Handler options supported by the Service Worker runtime. */
+    handlerOptions?: ServiceWorkerHandlerOptions;
 }
 /**
  * Create a fetch event handler that intercepts requests matching the given
@@ -127,4 +130,4 @@ export declare function createLifecycleHandlers(): {
     install: (event: MinimalExtendableEvent) => void;
     activate: (event: MinimalExtendableEvent) => void;
 };
-export { setupServiceWorker, type SetupServiceWorkerOptions, type SetupServiceWorkerResult, } from './setup.ts';
+export { setupServiceWorker, type ServiceWorkerHandlerOptions, type SetupServiceWorkerOptions, type SetupServiceWorkerResult, } from './setup.ts';

package/dist/service-worker/index.js

@@ -3,12 +3,12 @@ import { buildDelegatedRequest, DEFAULT_PERIODIC_SYNC_TAG, normalizePathPrefix }
 export { ServiceWorkerScheduler } from "./scheduler.js";
 export { buildDelegatedRequest, DEFAULT_PERIODIC_SYNC_TAG, normalizePathPrefix } from "./shared.js";
 export function createFetchHandler(options) {
-  const { engine } = options, pathPrefix = normalizePathPrefix(options.pathPrefix);
+  const { engine, handlerOptions } = options, pathPrefix = normalizePathPrefix(options.pathPrefix);
   return (event) => {
     const delegatedRequest = buildDelegatedRequest(event, pathPrefix);
     if (delegatedRequest === null)
       return;
-    event.respondWith(handleRequest(delegatedRequest, engine));
+    event.respondWith(handleRequest(delegatedRequest, engine, handlerOptions));
   };
 }
 export function createPeriodicSyncHandler(scheduler, tag) {

package/dist/service-worker/setup.d.ts

@@ -11,8 +11,26 @@
  * @module service-worker/setup
  */
 import { Engine, type RegistryAgnosticEngine } from '../core/engine';
+import type { HandlerOptions } from '../server/handler';
 import type { Storage as WeftStorage } from '../storage/interface';
 import { ServiceWorkerScheduler } from './scheduler';
+/**
+ * The subset of {@link HandlerOptions} that can be supplied by a Service
+ * Worker. Service Workers can inject request authorization and event-stream
+ * plumbing, but cannot provide server-owned registries or Bun runtime
+ * integrations.
+ *
+ * @example
+ * ```ts
+ * import type { ServiceWorkerHandlerOptions } from '@lostgradient/weft/service-worker';
+ *
+ * const handlerOptions: ServiceWorkerHandlerOptions = {
+ *   authContext: { method: 'public' },
+ * };
+ * void handlerOptions;
+ * ```
+ */
+export type ServiceWorkerHandlerOptions = Pick<HandlerOptions, 'authContext' | 'workflowEventFeed' | 'fleetEventFeed' | 'acquireWorkflowStreamConnection'>;
 /**
  * Options for {@link setupServiceWorker}. All fields are optional; the
  * helper supplies sensible defaults (`/weft/` path prefix, `'weft'`
@@ -58,6 +76,8 @@ export interface SetupServiceWorkerOptions {
      * engine's storage when both are provided.
      */
     storage?: WeftStorage;
+    /** Handler options supported by the Service Worker runtime. */
+    handlerOptions?: ServiceWorkerHandlerOptions;
     /**
      * Register workflows on the engine before listeners do real work.
      * Resolves before the helper returns. Rejection causes subsequent

package/dist/service-worker/setup.js

@@ -49,16 +49,16 @@ function resolveStorageAndEngine(options) {
   const storage = options.storage ?? new IndexedDBStorage(options.databaseName ?? DEFAULT_DATABASE_NAME);
   return { storage, engine: new Engine({ storage }) };
 }
-function buildFetchListener(pathPrefix, engine, registrationReady) {
+function buildFetchListener(pathPrefix, engine, registrationReady, handlerOptions) {
   return (event) => {
     const delegatedRequest = buildDelegatedRequest(event, pathPrefix);
     if (delegatedRequest === null)
       return;
-    event.respondWith(registrationReady.then(() => handleRequest(delegatedRequest, engine)).catch((error) => buildErrorResponse(error instanceof Error ? error : Error(String(error)))));
+    event.respondWith(registrationReady.then(() => handleRequest(delegatedRequest, engine, handlerOptions)).catch((error) => buildErrorResponse(error instanceof Error ? error : Error(String(error)))));
   };
 }
-function attachListeners(scope, pathPrefix, periodicSyncTag, engine, scheduler, registrationReady) {
-  const fetchListener = buildFetchListener(pathPrefix, engine, registrationReady), periodicSyncListener = (event) => {
+function attachListeners(scope, pathPrefix, periodicSyncTag, engine, scheduler, registrationReady, handlerOptions) {
+  const fetchListener = buildFetchListener(pathPrefix, engine, registrationReady, handlerOptions), periodicSyncListener = (event) => {
     if (event.tag !== periodicSyncTag)
       return;
     event.waitUntil(registrationReady.then(() => scheduler.tick()));
@@ -104,7 +104,7 @@ export function setupServiceWorker(options = {}) {
       await engine.recoverAll();
   }
   const registrationReady = Promise.resolve().then(runRegistrationAndRecovery);
-  attachListeners(scope, pathPrefix, periodicSyncTag, engine, scheduler, registrationReady);
+  attachListeners(scope, pathPrefix, periodicSyncTag, engine, scheduler, registrationReady, options.handlerOptions);
   const result = {
     engine,
     storage,