@convex-dev/workpool 0.3.1-alpha.1 → 0.3.1

package/src/client/index.ts

@@ -1,6 +1,7 @@
 import {
   createFunctionHandle,
   type DefaultFunctionArgs,
+  type FunctionArgs,
   type FunctionHandle,
   type FunctionReference,
   type FunctionType,
@@ -18,17 +19,15 @@ import {
   type VString,
 } from "convex/values";
 import type { ComponentApi } from "../component/_generated/component.js";
-import { DEFAULT_LOG_LEVEL, type LogLevel } from "../component/logging.js";
+import { type LogLevel } from "../component/logging.js";
 import {
   type Config,
-  DEFAULT_MAX_PARALLELISM,
   DEFAULT_RETRY_BEHAVIOR,
-  type OnComplete,
   type RetryBehavior,
   type RunResult,
   type OnCompleteArgs as SharedOnCompleteArgs,
   type Status,
-  vResultValidator,
+  vResult,
 } from "../component/shared.js";
 import {
   type RunMutationCtx,
@@ -37,16 +36,21 @@ import {
 } from "./utils.js";
 export { logLevel as vLogLevel, type LogLevel } from "../component/logging.js";
 export { retryBehavior as vRetryBehavior } from "../component/shared.js";
-export { vResultValidator, type RetryBehavior, type RunResult };
 
 export type WorkId = string & { __isWorkId: true };
-export const vWorkIdValidator = v.string() as VString<WorkId>;
+export const vWorkId = v.string() as VString<WorkId>;
 export {
+  vResult,
   DEFAULT_RETRY_BEHAVIOR,
-  /** @deprecated Use `vResultValidator` instead. */
-  vResultValidator as resultValidator,
-  /** @deprecated Use `vWorkIdValidator` instead. */
-  vWorkIdValidator as workIdValidator,
+  /** @deprecated Use `vResult` instead. */
+  vResult as resultValidator,
+  /** @deprecated Use `vWorkId` instead. */
+  vWorkId as workIdValidator,
+  // Older name, not deprecated yet
+  vWorkId as vWorkIdValidator,
+  vResult as vResultValidator,
+  type RetryBehavior,
+  type RunResult,
 };
 /** Equivalent to `vOnCompleteArgs(<your-context-validator>)`. */
 export const vOnComplete = vOnCompleteArgs(v.any());
@@ -234,7 +238,7 @@ export class Workpool {
   async cancel(ctx: RunMutationCtx, id: WorkId): Promise<void> {
     await ctx.runMutation(this.component.lib.cancel, {
       id,
-      logLevel: this.options.logLevel ?? DEFAULT_LOG_LEVEL,
+      logLevel: this.options.logLevel,
     });
   }
   /**
@@ -247,10 +251,11 @@ export class Workpool {
     options?: { limit?: number },
   ): Promise<void> {
     await ctx.runMutation(this.component.lib.cancelAll, {
-      logLevel: this.options.logLevel ?? DEFAULT_LOG_LEVEL,
+      logLevel: this.options.logLevel,
       ...options,
     });
   }
+
   /**
    * Gets the status of a work item.
    *
@@ -337,9 +342,9 @@ export function vOnCompleteArgs<
   V extends Validator<any, "required", any> = VAny,
 >(context?: V) {
   return v.object({
-    workId: vWorkIdValidator,
+    workId: vWorkId,
     context: (context ?? v.optional(v.any())) as V,
-    result: vResultValidator,
+    result: vResult,
   });
 }
 
@@ -355,7 +360,8 @@ export type RetryOption = {
 
 export type WorkpoolOptions = {
   /** How many actions/mutations can be running at once within this pool.
-   * Min 1, Suggested max: 100 on Pro, 20 on the free plan.
+   * Suggested max: 100 on Pro, 20 on free plan.
+   * If set to 0, no new work will be started.
    */
   maxParallelism?: number;
   /** How much to log. This is updated on each call to `enqueue*`,
@@ -495,23 +501,25 @@ async function enqueueArgs(
     typeof fn === "string" && fn.startsWith("function://")
       ? [fn, opts?.name ?? fn]
       : [await createFunctionHandle(fn), opts?.name ?? safeFunctionName(fn)];
-  const onComplete: OnComplete | undefined = opts?.onComplete
-    ? {
-        fnHandle: await createFunctionHandle(opts.onComplete),
-        context: opts.context,
-      }
-    : undefined;
   return {
     fnHandle,
     fnName,
-    onComplete,
+    onComplete: opts?.onComplete
+      ? {
+          fnHandle: await createFunctionHandle(opts.onComplete),
+          context: opts.context,
+        }
+      : undefined,
     runAt: getRunAt(opts),
     retryBehavior: opts?.retryBehavior,
     config: {
-      logLevel: opts?.logLevel ?? DEFAULT_LOG_LEVEL,
-      maxParallelism: opts?.maxParallelism ?? DEFAULT_MAX_PARALLELISM,
+      logLevel: opts?.logLevel,
+      maxParallelism: opts?.maxParallelism,
     },
-  };
+  } satisfies Omit<
+    FunctionArgs<ComponentApi["lib"]["enqueue"]>,
+    "fnArgs" | "fnType"
+  >;
 }
 
 function getRunAt(

package/src/component/_generated/api.ts

@@ -9,6 +9,7 @@
  */
 
 import type * as complete from "../complete.js";
+import type * as config from "../config.js";
 import type * as crons from "../crons.js";
 import type * as danger from "../danger.js";
 import type * as kick from "../kick.js";
@@ -29,6 +30,7 @@ import { anyApi, componentsGeneric } from "convex/server";
 
 const fullApi: ApiFromModules<{
   complete: typeof complete;
+  config: typeof config;
   crons: typeof crons;
   danger: typeof danger;
   kick: typeof kick;

package/src/component/_generated/component.ts

@@ -23,13 +23,25 @@ import type { FunctionReference } from "convex/server";
  */
 export type ComponentApi<Name extends string | undefined = string | undefined> =
   {
+    config: {
+      update: FunctionReference<
+        "mutation",
+        "internal",
+        {
+          logLevel?: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
+          maxParallelism?: number;
+        },
+        any,
+        Name
+      >;
+    };
     lib: {
       cancel: FunctionReference<
         "mutation",
         "internal",
         {
           id: string;
-          logLevel: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
+          logLevel?: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
         },
         any,
         Name
@@ -40,7 +52,7 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         {
           before?: number;
           limit?: number;
-          logLevel: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
+          logLevel?: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
         },
         any,
         Name
@@ -50,8 +62,8 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         "internal",
         {
           config: {
-            logLevel: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
-            maxParallelism: number;
+            logLevel?: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
+            maxParallelism?: number;
           };
           fnArgs: any;
           fnHandle: string;
@@ -73,8 +85,8 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         "internal",
         {
           config: {
-            logLevel: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
-            maxParallelism: number;
+            logLevel?: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
+            maxParallelism?: number;
           };
           items: Array<{
             fnArgs: any;

package/src/component/_generated/dataModel.ts

@@ -38,7 +38,7 @@ export type Doc<TableName extends TableNames> = DocumentByName<
  * Convex documents are uniquely identified by their `Id`, which is accessible
  * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
  *
- * Documents can be loaded using `db.get(id)` in query and mutation functions.
+ * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
  *
  * IDs are just strings at runtime, but this type can be used to distinguish them from other
  * strings when type checking.

package/src/component/complete.ts

@@ -4,11 +4,7 @@ import type { Id } from "./_generated/dataModel.js";
 import { internalMutation, type MutationCtx } from "./_generated/server.js";
 import { kickMainLoop } from "./kick.js";
 import { createLogger } from "./logging.js";
-import {
-  type OnCompleteArgs,
-  type RunResult,
-  vResultValidator,
-} from "./shared.js";
+import { type OnCompleteArgs, type RunResult, vResult } from "./shared.js";
 import { recordCompleted } from "./stats.js";
 
 export type CompleteJob = Infer<typeof completeArgs.fields.jobs.element>;
@@ -16,7 +12,7 @@ export type CompleteJob = Infer<typeof completeArgs.fields.jobs.element>;
 export const completeArgs = v.object({
   jobs: v.array(
     v.object({
-      runResult: vResultValidator,
+      runResult: vResult,
       workId: v.id("work"),
       attempt: v.number(),
     }),

package/src/component/config.test.ts

@@ -0,0 +1,31 @@
+import { convexTest } from "convex-test";
+import { assert, expect, test } from "vitest";
+import { DEFAULT_LOG_LEVEL } from "./logging.js";
+import schema from "./schema.js";
+import { modules } from "./setup.test.js";
+import { DEFAULT_MAX_PARALLELISM } from "./shared.js";
+import { getOrUpdateGlobals } from "./config.js";
+
+test("it updates the globals when they change", async () => {
+  const t = convexTest(schema, modules);
+  await t.run(async (ctx) => {
+    await getOrUpdateGlobals(ctx, {
+      maxParallelism: DEFAULT_MAX_PARALLELISM,
+      logLevel: DEFAULT_LOG_LEVEL,
+    });
+    const globals = await ctx.db.query("globals").unique();
+    expect(globals).not.toBeNull();
+    assert(globals);
+    expect(globals.maxParallelism).toBe(DEFAULT_MAX_PARALLELISM);
+    expect(globals.logLevel).toBe(DEFAULT_LOG_LEVEL);
+    await getOrUpdateGlobals(ctx, {
+      maxParallelism: DEFAULT_MAX_PARALLELISM + 1,
+      logLevel: "ERROR",
+    });
+    const after = await ctx.db.query("globals").unique();
+    expect(after).not.toBeNull();
+    assert(after);
+    expect(after.maxParallelism).toBe(DEFAULT_MAX_PARALLELISM + 1);
+    expect(after.logLevel).toBe("ERROR");
+  });
+});

package/src/component/config.ts

@@ -0,0 +1,72 @@
+import { mutation, type MutationCtx } from "./_generated/server.js";
+import { vConfig, DEFAULT_MAX_PARALLELISM, type Config } from "./shared.js";
+import { createLogger, DEFAULT_LOG_LEVEL } from "./logging.js";
+import { kickMainLoop } from "./kick.js";
+
+export const MAX_POSSIBLE_PARALLELISM = 200;
+export const MAX_PARALLELISM_SOFT_LIMIT = 100;
+
+export const update = mutation({
+  args: vConfig.partial(),
+  handler: async (ctx, args) => {
+    const { globals, previousValue } = await _getOrUpdateGlobals(ctx, args);
+    if (args.maxParallelism && args.maxParallelism > previousValue) {
+      await kickMainLoop(ctx, "kick", globals);
+    }
+  },
+});
+
+export function validateConfig(config: Partial<Config>) {
+  if (config.maxParallelism !== undefined) {
+    if (config.maxParallelism > MAX_POSSIBLE_PARALLELISM) {
+      throw new Error(`maxParallelism must be <= ${MAX_POSSIBLE_PARALLELISM}`);
+    } else if (config.maxParallelism > MAX_PARALLELISM_SOFT_LIMIT) {
+      createLogger(config.logLevel ?? DEFAULT_LOG_LEVEL).warn(
+        `maxParallelism should be <= ${MAX_PARALLELISM_SOFT_LIMIT}, but is set to ${config.maxParallelism}. This will be an error in a future version.`,
+      );
+    } else if (config.maxParallelism < 0) {
+      throw new Error("maxParallelism must be >= 0");
+    }
+  }
+}
+export async function getOrUpdateGlobals(
+  ctx: MutationCtx,
+  config?: Partial<Config>,
+) {
+  const { globals } = await _getOrUpdateGlobals(ctx, config);
+  return globals;
+}
+async function _getOrUpdateGlobals(
+  ctx: MutationCtx,
+  config?: Partial<Config>,
+) {
+  if (config) {
+    validateConfig(config);
+  }
+  const globals = await ctx.db.query("globals").unique();
+  const previousValue = globals?.maxParallelism ?? DEFAULT_MAX_PARALLELISM;
+  if (!globals) {
+    const id = await ctx.db.insert("globals", {
+      maxParallelism: config?.maxParallelism ?? DEFAULT_MAX_PARALLELISM,
+      logLevel: config?.logLevel ?? DEFAULT_LOG_LEVEL,
+    });
+    return { globals: (await ctx.db.get("globals", id))!, previousValue };
+  } else if (config) {
+    let updated = false;
+    if (
+      config.maxParallelism !== undefined &&
+      config.maxParallelism !== globals.maxParallelism
+    ) {
+      globals.maxParallelism = config.maxParallelism;
+      updated = true;
+    }
+    if (config.logLevel && config.logLevel !== globals.logLevel) {
+      globals.logLevel = config.logLevel;
+      updated = true;
+    }
+    if (updated) {
+      await ctx.db.replace("globals", globals._id, globals);
+    }
+  }
+  return { globals, previousValue };
+}

package/src/component/kick.test.ts

@@ -20,6 +20,7 @@ import {
   getNextSegment,
   toSegment,
 } from "./shared.js";
+import { getOrUpdateGlobals } from "./config.js";
 
 describe("kickMainLoop", () => {
   beforeEach(() => {
@@ -47,27 +48,6 @@ describe("kickMainLoop", () => {
     });
   });
 
-  test("it updates the globals when they change", async () => {
-    const t = convexTest(schema, modules);
-    await t.run(async (ctx) => {
-      await kickMainLoop(ctx, "enqueue");
-      const globals = await ctx.db.query("globals").unique();
-      expect(globals).not.toBeNull();
-      assert(globals);
-      expect(globals.maxParallelism).toBe(DEFAULT_MAX_PARALLELISM);
-      expect(globals.logLevel).toBe(DEFAULT_LOG_LEVEL);
-      await kickMainLoop(ctx, "enqueue", {
-        maxParallelism: DEFAULT_MAX_PARALLELISM + 1,
-        logLevel: "ERROR",
-      });
-      const after = await ctx.db.query("globals").unique();
-      expect(after).not.toBeNull();
-      assert(after);
-      expect(after.maxParallelism).toBe(DEFAULT_MAX_PARALLELISM + 1);
-      expect(after.logLevel).toBe("ERROR");
-    });
-  });
-
   test("does not kick when already running", async () => {
     const t = convexTest(schema, modules);
     await t.run(async (ctx) => {
@@ -249,8 +229,7 @@ describe("kickMainLoop", () => {
   test("preserves state between kicks with different sources", async () => {
     const t = convexTest(schema, modules);
     await t.run(async (ctx) => {
-      // Initial kick with custom config
-      await kickMainLoop(ctx, "enqueue", {
+      await getOrUpdateGlobals(ctx, {
         maxParallelism: 5,
         logLevel: "ERROR",
       });

package/src/component/kick.ts

@@ -1,11 +1,11 @@
 import { internal } from "./_generated/api.js";
 import { internalMutation, type MutationCtx } from "./_generated/server.js";
-import { createLogger, DEFAULT_LOG_LEVEL } from "./logging.js";
+import { getOrUpdateGlobals } from "./config.js";
+import { createLogger } from "./logging.js";
 import { INITIAL_STATE } from "./loop.js";
 import {
   boundScheduledTime,
   type Config,
-  DEFAULT_MAX_PARALLELISM,
   fromSegment,
   getCurrentSegment,
   getNextSegment,
@@ -20,9 +20,9 @@ import {
 export async function kickMainLoop(
   ctx: MutationCtx,
   source: "enqueue" | "cancel" | "complete" | "kick",
-  config?: Partial<Config>,
+  config?: Config,
 ): Promise<bigint> {
-  const globals = await getOrUpdateGlobals(ctx, config);
+  const globals = config ?? (await getOrUpdateGlobals(ctx, config));
   const console = createLogger(globals.logLevel);
   const runStatus = await getOrCreateRunStatus(ctx);
   const next = getNextSegment();
@@ -98,31 +98,3 @@ async function getOrCreateRunStatus(ctx: MutationCtx) {
   }
   return runStatus;
 }
-
-async function getOrUpdateGlobals(ctx: MutationCtx, config?: Partial<Config>) {
-  const globals = await ctx.db.query("globals").unique();
-  if (!globals) {
-    const id = await ctx.db.insert("globals", {
-      maxParallelism: config?.maxParallelism ?? DEFAULT_MAX_PARALLELISM,
-      logLevel: config?.logLevel ?? DEFAULT_LOG_LEVEL,
-    });
-    return (await ctx.db.get(id))!;
-  } else if (config) {
-    let updated = false;
-    if (
-      config.maxParallelism &&
-      config.maxParallelism !== globals.maxParallelism
-    ) {
-      globals.maxParallelism = config.maxParallelism;
-      updated = true;
-    }
-    if (config.logLevel && config.logLevel !== globals.logLevel) {
-      globals.logLevel = config.logLevel;
-      updated = true;
-    }
-    if (updated) {
-      await ctx.db.replace(globals._id, globals);
-    }
-  }
-  return globals;
-}

package/src/component/lib.test.ts

@@ -66,7 +66,7 @@ describe("lib", () => {
             logLevel: "WARN",
           },
         }),
-      ).rejects.toThrow("maxParallelism must be <= 100");
+      ).rejects.toThrow("maxParallelism must be <= 200");
     });
 
     it("should throw error if maxParallelism is too low", async () => {
@@ -78,11 +78,11 @@ describe("lib", () => {
           fnType: "mutation",
           runAt: Date.now(),
           config: {
-            maxParallelism: 0, // Less than minimum
+            maxParallelism: -1, // Less than minimum
             logLevel: "WARN",
           },
         }),
-      ).rejects.toThrow("maxParallelism must be >= 1");
+      ).rejects.toThrow("maxParallelism must be >= 0");
     });
   });
 

package/src/component/lib.ts

@@ -1,4 +1,4 @@
-import { type Infer, type ObjectType, v } from "convex/values";
+import { type ObjectType, v } from "convex/values";
 import { api } from "./_generated/api.js";
 import type { Id } from "./_generated/dataModel.js";
 import {
@@ -16,19 +16,17 @@ import {
 } from "./logging.js";
 import {
   boundScheduledTime,
-  config,
+  vConfig,
   fnType,
   getNextSegment,
   max,
-  onComplete,
+  vOnCompleteFnContext,
   retryBehavior,
   status as statusValidator,
   toSegment,
 } from "./shared.js";
 import { recordEnqueued } from "./stats.js";
-
-const MAX_POSSIBLE_PARALLELISM = 200;
-const MAX_PARALLELISM_SOFT_LIMIT = 100;
+import { getOrUpdateGlobals } from "./config.js";
 
 const itemArgs = {
   fnHandle: v.string(),
@@ -37,20 +35,20 @@ const itemArgs = {
   fnType,
   runAt: v.number(),
   // TODO: annotation?
-  onComplete: v.optional(onComplete),
+  onComplete: v.optional(vOnCompleteFnContext),
   retryBehavior: v.optional(retryBehavior),
 };
 const enqueueArgs = {
   ...itemArgs,
-  config,
+  config: vConfig.partial(),
 };
 export const enqueue = mutation({
   args: enqueueArgs,
   returns: v.id("work"),
   handler: async (ctx, { config, ...itemArgs }) => {
-    validateConfig(config);
-    const console = createLogger(config.logLevel);
-    const kickSegment = await kickMainLoop(ctx, "enqueue", config);
+    const globals = await getOrUpdateGlobals(ctx, config);
+    const console = createLogger(globals.logLevel);
+    const kickSegment = await kickMainLoop(ctx, "enqueue", globals);
     return await enqueueHandler(ctx, console, kickSegment, itemArgs);
   },
 });
@@ -73,29 +71,16 @@ async function enqueueHandler(
   return workId;
 }
 
-type Config = Infer<typeof config>;
-function validateConfig(config: Config) {
-  if (config.maxParallelism > MAX_POSSIBLE_PARALLELISM) {
-    throw new Error(`maxParallelism must be <= ${MAX_PARALLELISM_SOFT_LIMIT}`);
-  } else if (config.maxParallelism > MAX_PARALLELISM_SOFT_LIMIT) {
-    createLogger(config.logLevel).warn(
-      `maxParallelism should be <= ${MAX_PARALLELISM_SOFT_LIMIT}, but is set to ${config.maxParallelism}. This will be an error in a future version.`,
-    );
-  } else if (config.maxParallelism < 1) {
-    throw new Error("maxParallelism must be >= 1");
-  }
-}
-
 export const enqueueBatch = mutation({
   args: {
     items: v.array(v.object(itemArgs)),
-    config,
+    config: vConfig.partial(),
   },
   returns: v.array(v.id("work")),
   handler: async (ctx, { config, items }) => {
-    validateConfig(config);
-    const console = createLogger(config.logLevel);
-    const kickSegment = await kickMainLoop(ctx, "enqueue", config);
+    const globals = await getOrUpdateGlobals(ctx, config);
+    const console = createLogger(globals.logLevel);
+    const kickSegment = await kickMainLoop(ctx, "enqueue", globals);
     return Promise.all(
       items.map((item) => enqueueHandler(ctx, console, kickSegment, item)),
     );
@@ -105,12 +90,13 @@ export const enqueueBatch = mutation({
 export const cancel = mutation({
   args: {
     id: v.id("work"),
-    logLevel,
+    logLevel: v.optional(logLevel),
   },
   handler: async (ctx, { id, logLevel }) => {
-    const shouldCancel = await shouldCancelWorkItem(ctx, id, logLevel);
+    const globals = await getOrUpdateGlobals(ctx, { logLevel });
+    const shouldCancel = await shouldCancelWorkItem(ctx, id, globals.logLevel);
     if (shouldCancel) {
-      const segment = await kickMainLoop(ctx, "cancel", { logLevel });
+      const segment = await kickMainLoop(ctx, "cancel", globals);
       await ctx.db.insert("pendingCancelation", {
         workId: id,
         segment,
@@ -122,7 +108,7 @@ export const cancel = mutation({
 const PAGE_SIZE = 64;
 export const cancelAll = mutation({
   args: {
-    logLevel,
+    logLevel: v.optional(logLevel),
     before: v.optional(v.number()),
     limit: v.optional(v.number()),
   },
@@ -134,14 +120,15 @@ export const cancelAll = mutation({
       .withIndex("by_creation_time", (q) => q.lte("_creationTime", beforeTime))
       .order("desc")
       .take(pageSize);
+    const globals = await getOrUpdateGlobals(ctx, { logLevel });
     const shouldCancel = await Promise.all(
       pageOfWork.map(async ({ _id }) =>
-        shouldCancelWorkItem(ctx, _id, logLevel),
+        shouldCancelWorkItem(ctx, _id, globals.logLevel),
       ),
     );
     let segment = getNextSegment();
     if (shouldCancel.some((c) => c)) {
-      segment = await kickMainLoop(ctx, "cancel", { logLevel });
+      segment = await kickMainLoop(ctx, "cancel", globals);
     }
     await Promise.all(
       pageOfWork.map(({ _id }, index) => {

package/src/component/loop.ts

@@ -23,7 +23,7 @@ import {
 } from "./shared.js";
 import { generateReport, recordCompleted, recordStarted } from "./stats.js";
 
-const CANCELATION_BATCH_SIZE = 64; // the only queue that can get unbounded.
+const CANCELLATION_BATCH_SIZE = 64; // the only queue that can get unbounded.
 const SECOND = 1000;
 const MINUTE = 60 * SECOND;
 const RECOVERY_THRESHOLD_MS = 5 * MINUTE; // attempt to recover jobs this old.
@@ -75,7 +75,7 @@ export const main = internalMutation({
 
     // Read pendingCancelation, deleting from pendingStart. If it's still running, queue to cancel.
     console.time("[main] pendingCancelation");
-    await handleCancelation(ctx, state, segment, console, toCancel, globals);
+    await handleCancelation(ctx, state, segment, console, toCancel);
     console.timeEnd("[main] pendingCancelation");
 
     if (state.running.length === 0) {
@@ -415,7 +415,6 @@ async function handleCancelation(
   segment: bigint,
   console: Logger,
   toCancel: CompleteJob[],
-  { cancelationBatchSize }: Config,
 ) {
   const start = state.segmentCursors.cancelation - CURSOR_BUFFER_SEGMENTS;
   const canceled = await ctx.db
@@ -423,7 +422,7 @@ async function handleCancelation(
     .withIndex("segment", (q) =>
       q.gte("segment", start).lte("segment", segment),
     )
-    .take(cancelationBatchSize ?? CANCELATION_BATCH_SIZE);
+    .take(CANCELLATION_BATCH_SIZE);
   state.segmentCursors.cancelation = canceled.at(-1)?.segment ?? segment;
   if (canceled.length) {
     console.debug(`[main] attempting to cancel ${canceled.length}`);