@absurd-sqlite/bun-worker 0.2.2-alpha.2 → 0.3.0-alpha.1

package/dist/sqlite.d.ts

@@ -1,15 +1,7 @@
 import { Database } from "bun:sqlite";
-import type { Queryable } from "@absurd-sqlite/sdk";
-import type { SQLiteRestBindParams } from "@absurd-sqlite/sdk";
-export declare class BunSqliteConnection implements Queryable {
-    private readonly db;
-    private readonly maxRetries;
-    private readonly baseRetryDelayMs;
-    constructor(db: Database);
-    query<R extends object = Record<string, any>>(sql: string, params?: SQLiteRestBindParams): Promise<{
-        rows: R[];
-    }>;
-    exec(sql: string, params?: SQLiteRestBindParams): Promise<void>;
-    private runWithRetry;
+import type { SQLiteConnectionOptions } from "@absurd-sqlite/sdk";
+import { SQLiteConnection } from "@absurd-sqlite/sdk";
+export declare class BunSqliteConnection extends SQLiteConnection {
+    constructor(db: Database, options?: SQLiteConnectionOptions);
 }
 //# sourceMappingURL=sqlite.d.ts.map

package/dist/sqlite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../src/sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAGV,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAE5B,qBAAa,mBAAoB,YAAW,SAAS;IACnD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAW;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAK;IAChC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAM;gBAE3B,EAAE,EAAE,QAAQ;IAIlB,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAChD,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC;QAAE,IAAI,EAAE,CAAC,EAAE,CAAA;KAAE,CAAC;IAiBnB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;YAWvD,YAAY;CAc3B"}
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../src/sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,KAAK,EAGV,uBAAuB,EAIxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,gBAAgB,EAAY,MAAM,oBAAoB,CAAC;AAEhE,qBAAa,mBAAoB,SAAQ,gBAAgB;gBAC3C,EAAE,EAAE,QAAQ,EAAE,OAAO,GAAE,uBAA4B;CAIhE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absurd-sqlite/bun-worker",
-  "version": "0.2.2-alpha.2",
+  "version": "0.3.0-alpha.1",
   "description": "Bun worker utilities for Absurd-SQLite",
   "type": "module",
   "main": "dist/index.js",
@@ -39,14 +39,14 @@
   "homepage": "https://github.com/b4fun/absurd-sqlite#readme",
   "dependencies": {
     "@absurd-sqlite/sdk": "next",
-    "absurd-sdk": "https://github.com/bcho/absurd/releases/download/sdks%2Ftypescript%2Fv0.0.7/typescript-sdk-v0.0.7.tgz",
-    "cac": "^6.7.14"
+    "cac": "^6.7.14",
+    "temporal-polyfill": "^0.3.0"
   },
   "devDependencies": {
-    "bun-types": "^1.3.5",
+    "bun-types": "^1.3.6",
     "typescript": "^5.9.3"
   },
   "engines": {
     "bun": ">=1.1.0"
   }
-}
+}

package/src/index.ts

@@ -1,16 +1,20 @@
-import { Absurd, type WorkerOptions } from "absurd-sdk";
 import { Database } from "bun:sqlite";
-import type { AbsurdClient } from "@absurd-sqlite/sdk";
+import {
+  Absurd,
+  type AbsurdClient,
+  type WorkerOptions,
+} from "@absurd-sqlite/sdk";
 import { cac } from "cac";
 
 import { BunSqliteConnection } from "./sqlite";
 
 export type { AbsurdClient } from "@absurd-sqlite/sdk";
-export type { WorkerOptions } from "absurd-sdk";
+export type { WorkerOptions } from "@absurd-sqlite/sdk";
 
 export {
   downloadExtension,
   type DownloadExtensionOptions,
+  Temporal,
 } from "@absurd-sqlite/sdk";
 
 /**
@@ -101,12 +105,10 @@ export default async function run(setupFunction: SetupFunction): Promise<void> {
   }
 
   const db = new Database(dbPath);
-  (db as unknown as { loadExtension(path: string): void }).loadExtension(
-    extensionPath
-  );
+  db.loadExtension(extensionPath);
 
   const conn = new BunSqliteConnection(db);
-  const absurd = new Absurd({ db: conn });
+  const absurd = new Absurd(conn);
 
   await setupFunction(absurd);
 

package/src/sqlite.ts

@@ -1,126 +1,166 @@
 import { Database } from "bun:sqlite";
 
-import type { Queryable } from "@absurd-sqlite/sdk";
 import type {
-  SQLiteBindParams,
   SQLiteBindValue,
-  SQLiteRestBindParams,
+  SQLiteColumnDefinition,
+  SQLiteConnectionOptions,
+  SQLiteDatabase,
+  SQLiteStatement,
+  SQLiteValueCodec,
 } from "@absurd-sqlite/sdk";
+import { SQLiteConnection, Temporal } from "@absurd-sqlite/sdk";
 
-export class BunSqliteConnection implements Queryable {
-  private readonly db: Database;
-  private readonly maxRetries = 5;
-  private readonly baseRetryDelayMs = 50;
+export class BunSqliteConnection extends SQLiteConnection {
+  constructor(db: Database, options: SQLiteConnectionOptions = {}) {
+    const valueCodec = buildValueCodec(options.valueCodec);
+    super(new BunSqliteDatabase(db), { ...options, valueCodec });
+  }
+}
+
+class BunSqliteDatabase implements SQLiteDatabase {
+  constructor(private readonly db: Database) {}
 
-  constructor(db: Database) {
-    this.db = db;
+  prepare<Result extends object = Record<string, any>>(
+    sql: string
+  ): SQLiteStatement<Result> {
+    const statement = this.db.prepare(sql);
+    return new BunSqliteStatement(statement, isReadonlyQuery(sql));
   }
 
-  async query<R extends object = Record<string, any>>(
-    sql: string,
-    params?: SQLiteRestBindParams
-  ): Promise<{ rows: R[] }> {
-    const { sql: sqliteQuery, paramOrder } = rewritePostgresQuery(sql);
-    const sqliteParams = rewritePostgresParams(
-      normalizeParams(params),
-      paramOrder
-    );
+  close(): void {
+    this.db.close();
+  }
 
-    const statement = this.db.query(sqliteQuery);
-    const rows = await this.runWithRetry(() =>
-      statement.all(...sqliteParams).map((row) =>
-        decodeRowValues(row as Record<string, unknown>)
-      )
+  loadExtension(path: string): void {
+    (this.db as unknown as { loadExtension(path: string): void }).loadExtension(
+      path
     );
+  }
+}
+
+class BunSqliteStatement<Result extends object = Record<string, any>>
+  implements SQLiteStatement<Result>
+{
+  readonly readonly: boolean;
 
-    return { rows: rows as R[] };
+  constructor(
+    private readonly stmt: ReturnType<Database["prepare"]>,
+    readonlyFlag: boolean
+  ) {
+    this.readonly = readonlyFlag;
   }
 
-  async exec(sql: string, params?: SQLiteRestBindParams): Promise<void> {
-    const { sql: sqliteQuery, paramOrder } = rewritePostgresQuery(sql);
-    const sqliteParams = rewritePostgresParams(
-      normalizeParams(params),
-      paramOrder
-    );
+  columns(): SQLiteColumnDefinition[] {
+    const columnNames = this.stmt.columnNames ?? [];
+    const declaredTypes = this.stmt.declaredTypes ?? [];
+    return columnNames.map((name, index) => ({
+      name,
+      column: null,
+      table: null,
+      database: null,
+      type: normalizeColumnType(declaredTypes[index] ?? null),
+    }));
+  }
 
-    const statement = this.db.query(sqliteQuery);
-    await this.runWithRetry(() => statement.run(...sqliteParams));
-  }
-
-  private async runWithRetry<T>(operation: () => T): Promise<T> {
-    let attempt = 0;
-    while (true) {
-      try {
-        return operation();
-      } catch (err) {
-        if (!isRetryableSQLiteError(err) || attempt >= this.maxRetries) {
-          throw err;
-        }
-        attempt++;
-        await delay(this.baseRetryDelayMs * attempt);
-      }
-    }
+  all(...args: any[]): Result[] {
+    const normalizedArgs = normalizeStatementArgs(args);
+    return this.stmt.all(...normalizedArgs) as Result[];
+  }
+
+  run(...args: any[]): unknown {
+    const normalizedArgs = normalizeStatementArgs(args);
+    return this.stmt.run(...normalizedArgs);
   }
 }
 
-function rewritePostgresQuery(text: string): {
-  sql: string;
-  paramOrder: number[];
-} {
-  const paramOrder: number[] = [];
-  const sql = text
-    .replace(/\$(\d+)/g, (_, index) => {
-      paramOrder.push(Number(index));
-      return "?";
-    })
-    .replace(/absurd\.(\w+)/g, "absurd_$1");
-
-  return { sql, paramOrder };
+function buildValueCodec(
+  overrides?: SQLiteValueCodec
+): SQLiteValueCodec {
+  return {
+    encodeParam: overrides?.encodeParam ?? encodeColumnValue,
+    decodeColumn: overrides?.decodeColumn ?? decodeColumnValue,
+    decodeRow: overrides?.decodeRow ?? decodeRowValues,
+  };
 }
 
-function rewritePostgresParams<I = any>(
-  params: SQLiteBindValue[],
-  paramOrder: number[]
-): I[] {
-  if (paramOrder.length === 0) {
-    return params.map((value) => encodeColumnValue(value)) as I[];
+function normalizeStatementArgs(args: any[]): any[] {
+  if (args.length !== 1) {
+    return args;
+  }
+  const params = args[0];
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return args;
+  }
+  const normalized: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(params)) {
+    normalized[normalizeParamKey(key)] = value;
   }
+  return [normalized];
+}
 
-  return paramOrder.map((index) => {
-    const value = params[index - 1];
-    return encodeColumnValue(value) as I;
-  });
+function normalizeParamKey(key: string): string {
+  if (key.startsWith("$") || key.startsWith(":") || key.startsWith("@")) {
+    return key;
+  }
+  return `:${key}`;
 }
 
-function decodeRowValues<R extends object = any>(
-  row: Record<string, unknown>
-): R {
+function decodeRowValues<R extends object = any>(args: {
+  row: Record<string, unknown>;
+  columns?: SQLiteColumnDefinition[];
+  decodeColumn?: (args: {
+    value: unknown;
+    columnName: string;
+    columnType: string | null;
+  }) => unknown;
+}): R {
   const decodedRow: any = {};
-  for (const [columnName, rawValue] of Object.entries(row)) {
-    decodedRow[columnName] = decodeColumnValue(rawValue, columnName);
+  if (args.columns && args.decodeColumn) {
+    for (const column of args.columns) {
+      const columnName = column.name;
+      const rawValue = args.row[columnName];
+      decodedRow[columnName] = args.decodeColumn({
+        value: rawValue,
+        columnName,
+        columnType: column.type,
+      });
+    }
+    return decodedRow as R;
+  }
+
+  for (const [columnName, rawValue] of Object.entries(args.row)) {
+    decodedRow[columnName] = decodeColumnValue({
+      value: rawValue,
+      columnName,
+      columnType: null,
+    });
   }
 
   return decodedRow as R;
 }
 
-function decodeColumnValue<V = any>(
-  value: unknown | V,
-  columnName: string
-): V | null {
+function decodeColumnValue<V = any>(args: {
+  value: unknown | V;
+  columnName: string;
+  columnType: string | null;
+  verbose?: (...args: any[]) => void;
+}): V | null {
+  const { value, columnName, columnType } = args;
   if (value === null || value === undefined) {
     return null;
   }
 
-  if (isTimestampColumn(columnName)) {
-    if (typeof value === "number") {
-      return new Date(value) as V;
-    }
+  const isDateTime = columnType === "datetime" || isTimestampColumn(columnName);
+  if (isDateTime) {
     if (typeof value === "string") {
-      const parsed = Date.parse(value);
-      if (!Number.isNaN(parsed)) {
-        return new Date(parsed) as V;
-      }
+      return Temporal.Instant.from(value) as V;
+    }
+    if (typeof value === "number") {
+      return Temporal.Instant.fromEpochMilliseconds(value) as V;
     }
+    throw new Error(
+      `Expected datetime column ${columnName} to be a string or number, got ${typeof value}`
+    );
   }
 
   if (typeof value === "string") {
@@ -128,8 +168,7 @@ function decodeColumnValue<V = any>(
   }
 
   if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
-    const bytes =
-      value instanceof Uint8Array ? value : new Uint8Array(value);
+    const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
     const decoded = new TextDecoder().decode(bytes);
     return tryDecodeJson(decoded) ?? (value as V);
   }
@@ -145,7 +184,13 @@ function tryDecodeJson<V = any>(value: string): V | null {
   }
 }
 
-function encodeColumnValue(value: any): any {
+function encodeColumnValue(value: SQLiteBindValue): SQLiteBindValue {
+  if (value instanceof Temporal.Instant) {
+    return value.toString();
+  }
+  if (value instanceof Temporal.Duration) {
+    return value.toString();
+  }
   if (value instanceof Date) {
     return value.toISOString();
   }
@@ -159,60 +204,23 @@ function isTimestampColumn(columnName: string): boolean {
   return columnName.endsWith("_at");
 }
 
-function normalizeParams(
-  params?: SQLiteRestBindParams
-): SQLiteBindValue[] {
-  if (!params) {
-    return [];
-  }
-
-  if (params.length === 1 && isBindParams(params[0])) {
-    const inner = params[0];
-    if (Array.isArray(inner)) {
-      return inner;
-    }
-    return Object.values(inner);
-  }
-
-  return params as SQLiteBindValue[];
-}
-
-function isBindParams(value: unknown): value is SQLiteBindParams {
-  if (Array.isArray(value)) {
-    return true;
-  }
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const tag = Object.prototype.toString.call(value);
-  return tag === "[object Object]";
+function isReadonlyQuery(sql: string): boolean {
+  const trimmed = sql.trim().toLowerCase();
+  return (
+    trimmed.startsWith("select") ||
+    trimmed.startsWith("with") ||
+    trimmed.startsWith("pragma") ||
+    trimmed.startsWith("explain")
+  );
 }
 
-const sqliteRetryableErrorCodes = new Set(["SQLITE_BUSY", "SQLITE_LOCKED"]);
-const sqliteRetryableErrnos = new Set([5, 6]);
-
-function isRetryableSQLiteError(err: unknown): boolean {
-  if (!err || typeof err !== "object") {
-    return false;
-  }
-
-  const code = (err as any).code;
-  if (typeof code === "string") {
-    for (const retryableCode of sqliteRetryableErrorCodes) {
-      if (code.startsWith(retryableCode)) {
-        return true;
-      }
-    }
+function normalizeColumnType(value: string | null): string | null {
+  if (!value) {
+    return null;
   }
-
-  const errno = (err as any).errno;
-  if (typeof errno === "number" && sqliteRetryableErrnos.has(errno)) {
-    return true;
+  const lowered = value.toLowerCase();
+  if (lowered === "null") {
+    return null;
   }
-
-  return false;
-}
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return lowered;
 }

package/test/basic.test.ts

@@ -7,7 +7,7 @@ import {
   jest,
 } from "bun:test";
 import assert from "node:assert/strict";
-import type { Absurd } from "absurd-sdk";
+import { Temporal, type Absurd } from "@absurd-sqlite/sdk";
 import { createTestAbsurd, randomName, type TestContext } from "./setup";
 import { EventEmitter, once } from "events";
 import { waitFor } from "./wait-for";
@@ -171,7 +171,7 @@ describe("Basic SDK Operations", () => {
       const scheduledRun = await ctx.getRun(runID);
       expect(scheduledRun).toMatchObject({
         state: "sleeping",
-        available_at: wakeAt,
+        available_at: Temporal.Instant.fromEpochMilliseconds(wakeAt.getTime()),
         wake_event: null,
       });
 
@@ -189,7 +189,7 @@ describe("Basic SDK Operations", () => {
       const resumedRun = await ctx.getRun(runID);
       expect(resumedRun).toMatchObject({
         state: "running",
-        started_at: wakeAt,
+        started_at: Temporal.Instant.fromEpochMilliseconds(wakeAt.getTime()),
       });
     });
 
@@ -216,7 +216,9 @@ describe("Basic SDK Operations", () => {
       expect(running).toMatchObject({
         state: "running",
         claimed_by: "worker-a",
-        claim_expires_at: new Date(baseTime.getTime() + 30 * 1000),
+        claim_expires_at: Temporal.Instant.fromEpochMilliseconds(
+          baseTime.getTime() + 30 * 1000,
+        ),
       });
 
       await ctx.setFakeNow(new Date(baseTime.getTime() + 5 * 60 * 1000));
@@ -275,7 +277,9 @@ describe("Basic SDK Operations", () => {
       const runRow = await ctx.getRun(runID);
       expect(runRow).toMatchObject({
         claimed_by: "worker-clean",
-        claim_expires_at: new Date(base.getTime() + 60 * 1000),
+        claim_expires_at: Temporal.Instant.fromEpochMilliseconds(
+          base.getTime() + 60 * 1000,
+        ),
       });
 
       const beforeTTL = new Date(finishTime.getTime() + 30 * 60 * 1000);
@@ -482,7 +486,9 @@ describe("Basic SDK Operations", () => {
 
       const getExpiresAt = async (runID: string) => {
         const run = await ctx.getRun(runID);
-        return run?.claim_expires_at ? run.claim_expires_at.getTime() : 0;
+        return run?.claim_expires_at
+          ? run.claim_expires_at.epochMilliseconds
+          : 0;
       };
 
       absurd.workBatch("test-worker", claimTimeout);

package/test/events.test.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect, beforeAll, afterEach } from "bun:test";
-import type { Absurd } from "absurd-sdk";
+import { Temporal, type Absurd } from "@absurd-sqlite/sdk";
 import { createTestAbsurd, randomName, type TestContext } from "./setup";
-import { TimeoutError } from "absurd-sdk";
+import { TimeoutError } from "@absurd-sqlite/sdk";
 
 describe("Event system", () => {
   let ctx: TestContext;
@@ -21,7 +21,9 @@ describe("Event system", () => {
     const eventName = randomName("test_event");
 
     absurd.registerTask({ name: "waiter" }, async (params, ctx) => {
-      const payload = await ctx.awaitEvent(eventName, { timeout: 60 });
+      const payload = await ctx.awaitEvent(eventName, {
+        timeout: Temporal.Duration.from({ seconds: 60 }),
+      });
       return { received: payload };
     });
 
@@ -86,7 +88,7 @@ describe("Event system", () => {
     absurd.registerTask({ name: "timeout-waiter" }, async (_params, ctx) => {
       try {
         const payload = await ctx.awaitEvent(eventName, {
-          timeout: timeoutSeconds,
+          timeout: Temporal.Duration.from({ seconds: timeoutSeconds }),
         });
         return { timedOut: false, result: payload };
       } catch (err) {
@@ -109,7 +111,9 @@ describe("Event system", () => {
       wake_event: eventName,
     });
     const expectedWake = new Date(baseTime.getTime() + timeoutSeconds * 1000);
-    expect(sleepingRun?.available_at?.getTime()).toBe(expectedWake.getTime());
+    expect(sleepingRun?.available_at?.epochMilliseconds).toBe(
+      expectedWake.getTime(),
+    );
 
     await ctx.setFakeNow(new Date(expectedWake.getTime() + 1000));
     await absurd.workBatch("worker1", 120, 1);
@@ -170,13 +174,16 @@ describe("Event system", () => {
 
     absurd.registerTask({ name: "timeout-no-loop" }, async (_params, ctx) => {
       try {
-        await ctx.awaitEvent(eventName, { stepName: "wait", timeout: 10 });
+        await ctx.awaitEvent(eventName, {
+          stepName: "wait",
+          timeout: Temporal.Duration.from({ seconds: 10 }),
+        });
         return { stage: "unexpected" };
       } catch (err) {
         if (err instanceof TimeoutError) {
           const payload = await ctx.awaitEvent(eventName, {
             stepName: "wait",
-            timeout: 10,
+            timeout: Temporal.Duration.from({ seconds: 10 }),
           });
           return { stage: "resumed", payload };
         }

package/test/hooks.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect, beforeAll, afterEach } from "bun:test";
 import { AsyncLocalStorage } from "node:async_hooks";
-import type { Absurd, SpawnOptions } from "absurd-sdk";
+import type { Absurd, SpawnOptions } from "@absurd-sqlite/sdk";
 import { createTestAbsurd, randomName, type TestContext } from "./setup";
 
 describe("Hooks", () => {

package/test/idempotent.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect, beforeAll, afterEach } from "bun:test";
-import type { Absurd } from "absurd-sdk";
+import type { Absurd } from "@absurd-sqlite/sdk";
 import { createTestAbsurd, randomName, type TestContext } from "./setup";
 
 describe("Idempotent Task Spawning", () => {

package/test/index.test.ts

@@ -3,7 +3,7 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "bun:test";
-import { Absurd } from "absurd-sdk";
+import { Absurd } from "@absurd-sqlite/sdk";
 
 import { BunSqliteConnection } from "../src/sqlite";
 import { loadExtension } from "./setup";
@@ -29,7 +29,7 @@ describe("Absurd", () => {
   it("creates and lists queues using the sqlite extension", async () => {
     const db = createDatabaseWithMigrations();
     const conn = new BunSqliteConnection(db);
-    const absurd = new Absurd({ db: conn });
+    const absurd = new Absurd(conn);
 
     await absurd.createQueue("alpha");
     await absurd.createQueue("beta");
@@ -52,7 +52,7 @@ describe("Absurd", () => {
   it("closes workers without affecting the sqlite database", async () => {
     const db = createDatabaseWithMigrations();
     const conn = new BunSqliteConnection(db);
-    const absurd = new Absurd({ db: conn });
+    const absurd = new Absurd(conn);
 
     await absurd.close();
 

package/test/retry.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect, beforeAll, afterEach } from "bun:test";
-import type { Absurd } from "absurd-sdk";
+import { Temporal, type Absurd } from "@absurd-sqlite/sdk";
 import { createTestAbsurd, randomName, type TestContext } from "./setup";
 
 describe("Retry and cancellation", () => {
@@ -159,7 +159,7 @@ describe("Retry and cancellation", () => {
     const { taskID } = await absurd.spawn("duration-cancel", undefined, {
       maxAttempts: 4,
       retryStrategy: { kind: "fixed", baseSeconds: 30 },
-      cancellation: { maxDuration: 90 },
+      cancellation: { maxDuration: Temporal.Duration.from({ seconds: 90 }) },
     });
 
     await absurd.workBatch("worker1", 60, 1);
@@ -185,7 +185,7 @@ describe("Retry and cancellation", () => {
     });
 
     const { taskID } = await absurd.spawn("delay-cancel", undefined, {
-      cancellation: { maxDelay: 60 },
+      cancellation: { maxDelay: Temporal.Duration.from({ seconds: 60 }) },
     });
 
     await ctx.setFakeNow(new Date(baseTime.getTime() + 61 * 1000));
@@ -312,8 +312,8 @@ describe("Retry and cancellation", () => {
 
     await absurd.cancelTask(taskID);
     const second = await ctx.getTask(taskID);
-    expect(second?.cancelled_at?.getTime()).toBe(
-      first?.cancelled_at?.getTime(),
+    expect(second?.cancelled_at?.epochMilliseconds).toBe(
+      first?.cancelled_at?.epochMilliseconds,
     );
   });