cairnq 0.8.0 → 0.10.0

package/dist/store/postgres.js

@@ -1,45 +1,12 @@
+import { SchemaMismatch } from "../errors.js";
 import { loadMigrations, loadStatements } from "../sql.js";
 import { checkProtocolVersion, COMMENT, NAMED, statementParams, TaskStore, } from "./base.js";
-// `pg` is an optional dependency: the SDK is SQLite-first, so it's loaded lazily
-// the first time a PostgresStore connects. Absent -> a clear install hint.
-let pgModule = null;
-async function loadPg() {
-    if (pgModule)
-        return pgModule;
-    let mod;
-    try {
-        mod = (await import("pg"));
-    }
-    catch {
-        throw new Error("PostgresStore requires the 'pg' package — install it (e.g. `npm i pg`)");
-    }
-    const pg = (mod.default ?? mod);
-    // Postgres returns bigint (int8, OID 20) as a string to avoid precision loss.
-    // Every cairnq bigint is an epoch-ms or a counter, all within Number's safe
-    // integer range, so parse to number once (globally) to match the Task model
-    // (*_ms typed as number, same as the SQLite SDK). Set before any query runs.
-    pg.types.setTypeParser(pg.types.builtins.INT8, (v) => (v == null ? null : Number(v)));
-    pgModule = pg;
-    return pg;
-}
-/**
- * Roll back on the way out of a failed transaction, without letting the rollback
- * become the error the caller sees. A dropped connection fails both the statement
- * and the rollback, and it is the first one that says what went wrong.
- */
-async function rollbackQuietly(client) {
-    try {
-        await client.query("rollback");
-    }
-    catch {
-        // Already rolled back, or the connection is gone. Either way the original
-        // error is the one worth propagating.
-    }
-}
+import { ListenUnavailable } from "./pg-executor.js";
+import { createPoolExecutor } from "./pg-pool.js";
 // Notification channels, emitted by the 0003_notify trigger.
 const QUEUED_CHANNEL = "cairnq_queued";
 const DONE_CHANNEL = "cairnq_done";
-// Backoff between attempts to (re)connect the LISTEN connection after a
+// Backoff between attempts to (re)establish the LISTEN subscription after a
 // transient failure. Doubles per failure up to the cap; polling covers the gap.
 const LISTENER_RETRY_MS = 1_000;
 const LISTENER_RETRY_MAX_MS = 30_000;
@@ -82,27 +49,38 @@ export function toPositional(sql, params) {
  * PostgresStore — the Postgres dialect of the shared cairnq-protocol SQL.
  *
  * Everything protocol-shaped lives in TaskStore; this file is only what Postgres
- * does differently: a `pg` Pool, `:name` -> `$n` translation, and time taken from
- * the DB clock (`now()`) instead of from the SDK, which is what makes this backend
- * multi-host — unlike SQLite it coordinates API and worker processes across
- * machines, with no shared clock to agree on. claim uses FOR UPDATE SKIP LOCKED
- * and needs no claimable_probe, because PG readers don't block writers. JSON
- * columns are jsonb (bound as JSON text, read back as objects by rowToTask).
+ * does differently: `:name` -> `$n` translation, the migration ledger, LISTEN
+ * policy, and time taken from the DB clock (`now()`) instead of from the SDK,
+ * which is what makes this backend multi-host — unlike SQLite it coordinates API
+ * and worker processes across machines, with no shared clock to agree on. claim
+ * uses FOR UPDATE SKIP LOCKED and needs no claimable_probe, because PG readers
+ * don't block writers. JSON columns are jsonb (bound as JSON text, read back as
+ * objects by rowToTask).
+ *
+ * What it deliberately does NOT own is the connection. Given a DSN it builds a
+ * `pg` pool (see pg-pool.ts); given a PgExecutor it runs inside the caller's
+ * session instead — no second driver, no second pool, and the caller's writes and
+ * cairnq's can share one transaction.
  */
 export class PostgresStore extends TaskStore {
-    dsn;
     opts;
-    pool = null;
+    dsn;
+    /** The caller's executor, if one was injected — never closed by this store. */
+    provided;
+    /** Set once migrations have run and the protocol version checked out. */
+    executor = null;
     connecting = null;
     statements;
     // ------------------------------------------------------- LISTEN/NOTIFY state
-    // One dedicated connection LISTENs on both channels (see 0003_notify.sql and
-    // the claimWake/taskDoneWake contract on TaskStore). Failure to establish or
-    // keep it silently degrades the store to the base class's plain polling.
+    // The executor subscribes one dedicated connection to both channels (see
+    // 0003_notify.sql and the claimWake/taskDoneWake contract on TaskStore).
+    // Failure to establish or keep it silently degrades the store to the base
+    // class's plain polling. Held as the unsubscribe function, not the connection:
+    // whose connection it is, is the executor's business.
     listener = null;
     listenerConnecting = null;
-    /** LISTEN is off for good: the store was closed, or the server accepted a
-     * connection but refused LISTEN (e.g. a transaction-mode pooler) —
+    /** LISTEN is off for good: the store was closed, the executor does not support
+     * it, or the server refused it (e.g. a transaction-mode pooler) —
      * deterministic, so retrying would fail the same way every time. */
     listenerUnavailable = false;
     /** A failure to even connect is transient (network blip, server restarting):
@@ -115,10 +93,19 @@ export class PostgresStore extends TaskStore {
     pendingQueues = new Set();
     /** Wake callbacks by key: "queued" (broadcast) or "done:<task id>". */
     waiters = new Map();
-    constructor(dsn, opts = {}) {
+    /** watch() subscribers. Separate from `waiters`: a waiter is one-shot and
+     * consumes the notification, a subscriber is standing and only observes. */
+    subscribers = new Set();
+    /**
+     * `source` is either a libpq connection string — this store then owns a `pg`
+     * pool and requires the optional `pg` package — or a PgExecutor the caller
+     * already has, which this store uses and never closes.
+     */
+    constructor(source, opts = {}) {
         super();
-        this.dsn = dsn;
         this.opts = opts;
+        this.dsn = typeof source === "string" ? source : null;
+        this.provided = typeof source === "string" ? null : source;
         this.statements = loadStatements("postgres");
     }
     async connect() {
@@ -127,18 +114,20 @@ export class PostgresStore extends TaskStore {
     async close() {
         this.listenerUnavailable = true; // no revival after close
         this.dropListener();
-        if (this.pool) {
-            const p = this.pool;
-            this.pool = null;
-            this.connecting = null;
-            await p.end();
-        }
+        const executor = this.executor;
+        this.executor = null;
+        this.connecting = null;
+        // An injected executor belongs to the caller, whose other work would not
+        // survive cairnq closing it.
+        if (executor && !this.provided)
+            await executor.close();
     }
     async ensure() {
-        if (this.pool)
+        if (this.executor)
             return;
-        // Cache the in-flight connect so concurrent calls share one pool. On failure,
-        // clear it so a later call retries instead of re-awaiting a rejected promise.
+        // Cache the in-flight connect so concurrent calls share one executor. On
+        // failure, clear it so a later call retries instead of re-awaiting a
+        // rejected promise.
         if (!this.connecting) {
             this.connecting = this.doConnect().catch((e) => {
                 this.connecting = null;
@@ -148,68 +137,105 @@ export class PostgresStore extends TaskStore {
         await this.connecting;
     }
     async doConnect() {
-        const pg = await loadPg();
-        const pool = new pg.Pool({ connectionString: this.dsn, max: this.opts.max });
+        const executor = this.provided ??
+            (await createPoolExecutor(this.dsn, { max: this.opts.max, schema: this.opts.schema }));
         try {
-            const client = await pool.connect();
-            try {
-                await this.applyMigrations(client);
-                checkProtocolVersion(await this.readProtocolVersion(client));
-            }
-            finally {
-                client.release();
-            }
+            // Before migrations, which would otherwise create the very installation
+            // this is trying to warn about.
+            await this.checkSchema(executor);
+            await this.applyMigrations(executor);
+            checkProtocolVersion(await this.readProtocolVersion(executor));
         }
         catch (e) {
-            await pool.end(); // never leak a pool when connect fails
+            // Never leak an executor we created; never close one we were handed.
+            if (!this.provided)
+                await executor.close().catch(() => { });
             throw e;
         }
-        this.pool = pool; // publish only a fully-migrated, version-checked pool
-        // Warm the LISTEN connection in the background so the first idle sleep is
+        this.executor = executor; // publish only a fully-migrated, version-checked executor
+        // Warm the LISTEN subscription in the background so the first idle sleep is
         // already wakeable. Fire-and-forget: failure just means polling.
         this.listenerReady();
     }
-    async applyMigrations(client) {
-        await client.query("create table if not exists cairnq_migrations " +
+    /**
+     * Refuse a connection pointed somewhere other than the deployment's cairnq.
+     *
+     * Two shapes, because `schema` means "the schema cairnq's tables live in" and
+     * cairnq can either arrange that (it built the connection) or only check it
+     * (the caller's executor did):
+     *
+     * - `schema` configured -> assert the connection actually resolves there. On
+     *   the DSN path this is a cheap self-check; on an injected executor it is the
+     *   only way to state the expectation at all.
+     * - `schema` not configured -> the dangerous case is being about to create a
+     *   SECOND installation while one already exists elsewhere in this database,
+     *   which is exactly what a mismatched pair of SDKs does. Joining an existing
+     *   installation is fine no matter what else is around, so the check is
+     *   deliberately narrow: it fires only when this schema has no cairnq and some
+     *   other schema does.
+     *
+     * That narrowness is what keeps it from crying wolf. Two applications each
+     * running their own cairnq in their own schema are legitimate; the second one
+     * to be set up trips this once, and saying `schema` explicitly — which such a
+     * deployment should be doing anyway — is both the fix and the confirmation.
+     */
+    async checkSchema(executor) {
+        // One row per installation; the statement's LEFT JOIN guarantees at least
+        // one, so current_schema is readable even where cairnq lives nowhere yet.
+        const rows = await executor.query(this.statements.installations, []);
+        const current = rows[0]?.current_schema ?? null;
+        const installations = rows
+            .map((r) => r.schema)
+            .filter((s) => s != null);
+        const wanted = this.opts.schema;
+        if (wanted != null) {
+            if (current !== wanted) {
+                throw new SchemaMismatch(`cairnq is configured for schema ${JSON.stringify(wanted)} but this ` +
+                    `connection resolves to ${JSON.stringify(current)} — check the ` +
+                    `connection's search_path`);
+            }
+            return;
+        }
+        // A search_path naming nothing that exists: there is no "here" to compare
+        // against, and the migrations are about to fail with a clearer message.
+        if (current === null)
+            return;
+        if (installations.length === 0 || installations.includes(current))
+            return;
+        throw new SchemaMismatch(`cairnq tables already exist in schema ${installations.map((s) => JSON.stringify(s)).join(", ")} ` +
+            `of this database, but this connection resolves to ${JSON.stringify(current)}, where there are ` +
+            `none. Connecting would create a second, parallel installation that the other one can never see ` +
+            `— an API and a worker split this way agree about everything except where, and no task crosses. ` +
+            `Point this process at the same schema (\`schema\` option, or \`options=-c search_path=...\` in the ` +
+            `DSN), or pass \`schema\` explicitly to confirm a separate installation is what you meant.`);
+    }
+    async applyMigrations(executor) {
+        await executor.exec("create table if not exists cairnq_migrations " +
             "(name text primary key, applied_at_ms bigint not null)");
         for (const { name, sql } of loadMigrations("postgres")) {
             // Check and apply inside one transaction, with the table lock taken up
             // front: two processes cold-starting together would otherwise both see a
             // migration as unapplied and both run it.
-            try {
-                await client.query("begin");
-                await client.query("lock table cairnq_migrations in exclusive mode");
-                const applied = await client.query("select 1 from cairnq_migrations where name = $1", [
-                    name,
-                ]);
-                if (applied.rowCount === 0) {
-                    await client.query(sql); // multi-statement DDL (simple-query, no params)
-                    await client.query("insert into cairnq_migrations (name, applied_at_ms) values " +
+            await executor.tx(async (s) => {
+                await s.exec("lock table cairnq_migrations in exclusive mode");
+                const applied = await s.query("select 1 from cairnq_migrations where name = $1", [name]);
+                if (applied.length === 0) {
+                    await s.exec(sql); // multi-statement DDL (simple-query, no params)
+                    await s.query("insert into cairnq_migrations (name, applied_at_ms) values " +
                         "($1, (extract(epoch from now()) * 1000)::bigint)", [name]);
                 }
-                await client.query("commit");
-            }
-            catch (e) {
-                await rollbackQuietly(client);
-                throw e;
-            }
+            });
         }
     }
-    // Takes an explicit client: during doConnect the pool is not published yet, so
-    // this cannot go through fetch(). The statement binds nothing, so it runs as-is.
-    async readProtocolVersion(client) {
-        const res = await client.query(this.statements.protocol_version);
-        return res.rows.length ? Number(res.rows[0].value) : 0;
+    // Takes an explicit session: during doConnect the executor is not published
+    // yet, so this cannot go through fetch(). The statement binds nothing.
+    async readProtocolVersion(s) {
+        const rows = await s.query(this.statements.protocol_version, []);
+        return rows.length ? Number(rows[0].value) : 0;
     }
     async protocolVersion() {
         await this.ensure();
-        const client = await this.pool.connect();
-        try {
-            return await this.readProtocolVersion(client);
-        }
-        finally {
-            client.release();
-        }
+        return this.readProtocolVersion(this.executor);
     }
     // ------------------------------------------------------------ wake channel
     async claimWake(queues, timeoutMs) {
@@ -232,6 +258,15 @@ export class PostgresStore extends TaskStore {
             await this.wakeOn("queued", remaining);
         }
     }
+    subscribePush(onSignal) {
+        this.subscribers.add(onSignal);
+        this.listenerReady(); // an API-side watcher is often the only thing asking
+        return () => void this.subscribers.delete(onSignal);
+    }
+    warmPush() {
+        if (this.subscribers.size > 0)
+            this.listenerReady();
+    }
     taskDoneWake(taskId, timeoutMs) {
         if (!this.listenerReady())
             return super.taskDoneWake(taskId, timeoutMs);
@@ -258,7 +293,7 @@ export class PostgresStore extends TaskStore {
             peers.add(waiter);
         });
     }
-    /** True once the LISTEN connection is up; starts connecting it otherwise
+    /** True once the LISTEN subscription is up; starts establishing it otherwise
      * (respecting the transient-failure backoff). Callers fall back to plain
      * polling until it is ready (or forever, if it can't be established) —
      * correctness never depends on it. */
@@ -272,38 +307,38 @@ export class PostgresStore extends TaskStore {
     }
     async startListener() {
         try {
-            const pg = await loadPg();
-            // Built from the raw DSN: if `opts` ever grows connection-level settings
-            // (ssl, application_name), the listener must receive them too.
-            const client = new pg.Client({ connectionString: this.dsn });
+            const executor = this.executor ?? this.provided;
+            // Not connected yet: transient by definition — doConnect calls back in.
+            if (!executor)
+                return;
+            if (!executor.listen) {
+                this.listenerUnavailable = true; // this executor will never push
+                return;
+            }
+            let stop;
             try {
-                await client.connect();
+                stop = await executor.listen([QUEUED_CHANNEL, DONE_CHANNEL], (channel, payload) => this.onNotification(channel, payload), 
+                // A dropped listener degrades to polling; the next wake reconnects.
+                () => this.dropListener());
             }
-            catch {
-                // Could not even connect — transient. Schedule a backed-off retry;
+            catch (e) {
+                if (e instanceof ListenUnavailable) {
+                    // Deterministic (e.g. a transaction-mode pooler): off for good rather
+                    // than a reconnect loop that cannot succeed. Polling covers it.
+                    this.listenerUnavailable = true;
+                    return;
+                }
+                // Could not establish it — transient. Schedule a backed-off retry;
                 // polling covers the gap.
                 this.listenerRetryAt = Date.now() + this.listenerBackoffMs;
                 this.listenerBackoffMs = Math.min(LISTENER_RETRY_MAX_MS, this.listenerBackoffMs * 2);
                 return;
             }
-            client.on("notification", (msg) => this.onNotification(msg.channel, msg.payload));
-            // A dropped listener degrades to polling; the next wake call reconnects.
-            client.on("error", () => this.dropListener());
-            try {
-                await client.query(`listen ${QUEUED_CHANNEL}; listen ${DONE_CHANNEL}`);
-            }
-            catch {
-                // Connected, but LISTEN was refused (e.g. a transaction-mode pooler) —
-                // deterministic, so off for good. Polling covers it.
-                this.listenerUnavailable = true;
-                void client.end().catch(() => { });
-                return;
-            }
             if (this.listenerUnavailable) {
-                void client.end().catch(() => { }); // closed while we were connecting
+                stop(); // closed while we were subscribing
                 return;
             }
-            this.listener = client;
+            this.listener = stop;
             this.listenerBackoffMs = LISTENER_RETRY_MS;
         }
         catch {
@@ -320,9 +355,11 @@ export class PostgresStore extends TaskStore {
         if (channel === QUEUED_CHANNEL && payload) {
             this.pendingQueues.add(payload);
             key = "queued";
+            this.publish({ reason: "queued", queue: payload });
         }
         else if (channel === DONE_CHANNEL && payload) {
             key = `done:${payload}`;
+            this.publish({ reason: "done", taskId: payload });
         }
         else {
             return;
@@ -333,11 +370,23 @@ export class PostgresStore extends TaskStore {
             for (const w of set)
                 w();
     }
+    /** Hand a notification to every watch() subscriber. A throwing subscriber is
+     * its own problem: it must not cost the others their signal, nor take down the
+     * listener connection that delivered it. */
+    publish(signal) {
+        for (const s of [...this.subscribers]) {
+            try {
+                s(signal);
+            }
+            catch {
+                // Deliberately swallowed — see above.
+            }
+        }
+    }
     dropListener() {
-        const client = this.listener;
+        const stop = this.listener;
         this.listener = null;
-        if (client)
-            void client.end().catch(() => { });
+        stop?.();
         // Release everyone promptly; their fallback poll takes over.
         for (const set of [...this.waiters.values()])
             for (const w of [...set])
@@ -347,26 +396,21 @@ export class PostgresStore extends TaskStore {
     async fetch(name, params) {
         await this.ensure();
         const { text, values } = toPositional(this.statements[name], params);
-        return (await this.pool.query(text, values)).rows;
+        return this.executor.query(text, values);
     }
     async tx(fn) {
         await this.ensure();
-        const client = await this.pool.connect();
-        try {
-            await client.query("begin");
-            const out = await fn(async (name, params) => {
-                const { text, values } = toPositional(this.statements[name], params);
-                return (await client.query(text, values)).rows;
-            });
-            await client.query("commit");
-            return out;
-        }
-        catch (e) {
-            await rollbackQuietly(client);
-            throw e;
-        }
-        finally {
-            client.release();
-        }
+        return this.executor.tx((s) => fn(this.boundFetch(s)));
+    }
+    async txWithSession(fn) {
+        await this.ensure();
+        return this.executor.tx((s) => fn(this.boundFetch(s), s));
+    }
+    /** A Fetch that runs the protocol's statements on one particular session. */
+    boundFetch(s) {
+        return async (name, params) => {
+            const { text, values } = toPositional(this.statements[name], params);
+            return s.query(text, values);
+        };
     }
 }

package/dist/store/sqlite.js

@@ -1,9 +1,27 @@
 import { mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import Database from "better-sqlite3";
+import { createRequire } from "node:module";
 import { nowMs } from "../ids.js";
 import { loadMigrations, loadStatements } from "../sql.js";
 import { checkProtocolVersion, COMMENT, statementParams, TaskStore, } from "./base.js";
+// `better-sqlite3` is an optional dependency, matching `pg` on the Postgres side:
+// a Postgres-only deployment should not have to build a native module it never
+// loads, and importing this file must not pull one in. Required (not imported)
+// because ensure() is synchronous — the open path applies migrations and cannot
+// await — and createRequire gives a synchronous load from ESM.
+const require = createRequire(import.meta.url);
+let sqliteModule = null;
+function loadSqlite() {
+    if (sqliteModule)
+        return sqliteModule;
+    try {
+        sqliteModule = require("better-sqlite3");
+    }
+    catch {
+        throw new Error("SQLiteStore requires the 'better-sqlite3' package — install it (e.g. `npm i better-sqlite3`)");
+    }
+    return sqliteModule;
+}
 const WAL_RETRY_DELAY_MS = 50;
 const WAL_RETRY_BUDGET_MS = 5_000;
 const BUSY_RETRY_BASE_MS = 1;
@@ -221,7 +239,7 @@ export class SQLiteStore extends TaskStore {
         const memory = isMemory(this.path);
         if (!memory)
             mkdirSync(dirname(this.path), { recursive: true });
-        const db = new Database(this.path);
+        const db = new (loadSqlite())(this.path);
         // Only the synchronous part of the open path gets a real busy_timeout: the WAL
         // switch and the migrations cannot await a retry. See the class comment.
         db.pragma(`busy_timeout = ${this.busyBudgetMs}`);

package/dist/worker.d.ts

@@ -1,5 +1,6 @@
 import type { BackpressureOptions } from "./backpressure.js";
 import { TaskContext } from "./context.js";
+import type { PgExecutor } from "./store/pg-executor.js";
 import type { TaskStore } from "./store/base.js";
 import { type TaskDef } from "./task.js";
 export { retryDelayMs, DEFAULT_RETRY_BACKOFF_MS, DEFAULT_RETRY_BACKOFF_MAX_MS } from "./backoff.js";
@@ -97,7 +98,7 @@ export declare class Worker {
     private readonly queues;
     private readonly opts;
     private readonly handlers;
-    private readonly workerId;
+    private readonly ownId;
     /** Payload bytes charged to running handlers — see maxInFlightBytes. */
     private inFlightBytes;
     /** Calls in flight, for the names that cap their own concurrency. */
@@ -130,13 +131,17 @@ export declare class Worker {
         queues?: string[];
         busyTimeoutMs?: number;
     }): Worker;
-    /** Multi-host backend. `dsn` is a libpq connection string; requires the
-     * optional `pg` package. */
-    static postgres(dsn: string, opts?: WorkerOptions & {
+    /** Multi-host backend. `source` is a libpq connection string — which requires
+     * the optional `pg` package — or a PgExecutor over a driver the application
+     * already runs, which cairnq then shares instead of opening a second pool. */
+    static postgres(source: string | PgExecutor, opts?: WorkerOptions & {
         queues?: string[];
         max?: number;
+        schema?: string;
     }): Worker;
-    get id(): string;
+    /** This worker's id — what `worker_id` on a running task points at, and what
+     * the Python SDK calls `worker_id` too. */
+    get workerId(): string;
     task(handler: Handler): this;
     task(name: string, handler: Handler): this;
     task<P, R>(def: TaskDef<P, R>, handler: TypedHandler<P, R>): this;

package/dist/worker.js

@@ -72,7 +72,7 @@ export class Worker {
     queues;
     opts;
     handlers = new Map();
-    workerId = newId("worker");
+    ownId = newId("worker");
     /** Payload bytes charged to running handlers — see maxInFlightBytes. */
     inFlightBytes = 0;
     /** Calls in flight, for the names that cap their own concurrency. */
@@ -133,16 +133,19 @@ export class Worker {
         worker.ownsStore = true;
         return worker;
     }
-    /** Multi-host backend. `dsn` is a libpq connection string; requires the
-     * optional `pg` package. */
-    static postgres(dsn, opts = {}) {
-        const { queues = ["default"], max, ...rest } = opts;
-        const worker = new Worker(new PostgresStore(dsn, { max }), queues, rest);
+    /** Multi-host backend. `source` is a libpq connection string — which requires
+     * the optional `pg` package — or a PgExecutor over a driver the application
+     * already runs, which cairnq then shares instead of opening a second pool. */
+    static postgres(source, opts = {}) {
+        const { queues = ["default"], max, schema, ...rest } = opts;
+        const worker = new Worker(new PostgresStore(source, { max, schema }), queues, rest);
         worker.ownsStore = true;
         return worker;
     }
-    get id() {
-        return this.workerId;
+    /** This worker's id — what `worker_id` on a running task points at, and what
+     * the Python SDK calls `worker_id` too. */
+    get workerId() {
+        return this.ownId;
     }
     task(arg, second, third) {
         // Option form: (name | def, { batch?, concurrency?, resource? }, handler).
@@ -273,7 +276,7 @@ export class Worker {
         return out;
     }
     context(task, leaseMs) {
-        return new TaskContext(this.store, task, this.workerId, leaseMs, {
+        return new TaskContext(this.store, task, this.ownId, leaseMs, {
             retryBackoffMs: this.backoffMs,
             retryBackoffMaxMs: this.backoffMaxMs,
         });
@@ -379,7 +382,7 @@ export class Worker {
                 // Only what this worker can run. Queues do not partition work by task
                 // name, so another worker's tasks would otherwise be claimed here and
                 // failed for want of a handler.
-                { queues: this.queues, workerId: this.workerId, leaseMs, names }, async (claim) => {
+                { queues: this.queues, workerId: this.ownId, leaseMs, names }, async (claim) => {
                     const drawn = [];
                     let left = free;
                     // Resource units this poll has already drawn. resourceCalls only
@@ -611,7 +614,7 @@ export class Worker {
         try {
             // complete (not succeed): finalizes as canceled if a cancel was requested
             // while the handler ran, else succeeded.
-            await this.store.complete({ taskId: ctx.taskId, workerId: this.workerId, result });
+            await this.store.complete({ taskId: ctx.taskId, workerId: this.ownId, result });
             ctx.markSettled();
         }
         catch (err) {
@@ -744,7 +747,7 @@ export class Worker {
                 try {
                     const renewed = await this.store.heartbeatBatch({
                         taskIds: live.map((c) => c.taskId),
-                        workerId: this.workerId,
+                        workerId: this.ownId,
                         leaseMs,
                     });
                     for (const ctx of live) {
@@ -779,7 +782,7 @@ export class Worker {
         try {
             await this.store.fail({
                 taskId: ctx.taskId,
-                workerId: this.workerId,
+                workerId: this.ownId,
                 error: envelope,
                 retryable,
                 delayMs: failDelayMs(ctx.attempt, retryable, this.backoffMs, this.backoffMaxMs),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cairnq",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "SQLite-first, cross-language, storage-centered durable task runtime",
   "license": "MIT",
   "author": "Jannchie <jannchie@gmail.com>",
@@ -39,19 +39,21 @@
     "test": "vitest run",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
-  "dependencies": {
-    "better-sqlite3": "^13.0.2"
-  },
   "peerDependencies": {
+    "better-sqlite3": "^13.0.2",
     "pg": "^8.13.0"
   },
   "peerDependenciesMeta": {
+    "better-sqlite3": {
+      "optional": true
+    },
     "pg": {
       "optional": true
     }
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.11",
+    "better-sqlite3": "^13.0.2",
     "@types/node": "^22.7.0",
     "@types/pg": "^8.11.10",
     "pg": "^8.13.0",