@pikku/kysely 0.13.31 → 0.13.34

package/dist/src/schema/trigger-source.schema.js

@@ -7,17 +7,17 @@ export const triggerSourceSchema = {
     name: 'trigger-source',
     ownedBy: ['triggerSourceStore'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('pikkuTriggerSource')
-            .addColumn('name', 'text', (col) => col.primaryKey())
-            .addColumn('kind', 'text', (col) => col.notNull())
-            .addColumn('baseUrl', 'text')
-            .addColumn('labelPrefix', 'text')
+            .addColumn('name', ctx.key, (col) => col.primaryKey())
+            .addColumn('kind', ctx.text, (col) => col.notNull())
+            .addColumn('baseUrl', ctx.text)
+            .addColumn('labelPrefix', ctx.text)
             .addColumn('declared', 'boolean', (col) => col.defaultTo(true).notNull())
             .addColumn('enabled', 'boolean', (col) => col.defaultTo(false).notNull())
-            .addColumn('status', 'text')
-            .addColumn('state', 'text')
-            .addColumn('detail', 'text')
+            .addColumn('status', ctx.text)
+            .addColumn('state', ctx.text)
+            .addColumn('detail', ctx.text)
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
     ],
 };

package/dist/src/schema/virtual-user-schedule.schema.js

@@ -15,7 +15,7 @@ export const virtualUserScheduleSchema = {
     name: 'virtual-user-schedule',
     ownedBy: ['virtualUserScheduleStore'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('virtualUserSchedule')
             .addColumn('persona', 'varchar(255)', (col) => col.primaryKey())
             // 0 or 1 rather than a boolean, matching the run tables: a bare sqlite
@@ -23,8 +23,8 @@ export const virtualUserScheduleSchema = {
             // everywhere. Off by default, so creating the table spends nothing.
             .addColumn('enabled', 'integer', (col) => col.defaultTo(0).notNull())
             .addColumn('disposition', 'varchar(50)', (col) => col.notNull())
-            .addColumn('goals', 'text', (col) => col.defaultTo('[]').notNull())
-            .addColumn('budget', 'text')
+            .addColumn('goals', ctx.text, (col) => col.defaultTo(ctx.defaultText('[]')).notNull())
+            .addColumn('budget', ctx.text)
             // The gap to the next run is drawn between these rather than fixed, so
             // the persona does not keep an appointment.
             .addColumn('minIntervalMs', 'bigint', (col) => col.notNull())
@@ -35,7 +35,7 @@ export const virtualUserScheduleSchema = {
             .addColumn('lastRunId', 'varchar(36)')
             .addColumn('lastRunAt', 'timestamp'),
         // The only read that matters at speed: which rows are due, on every tick.
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_virtual_user_schedule_due')
             .on('virtualUserSchedule')
             .columns(['enabled', 'nextRunAt']),

package/dist/src/schema/virtual-user.schema.js

@@ -21,7 +21,7 @@ export const virtualUserSchema = {
     name: 'virtual-user',
     ownedBy: ['virtualUserRunStore'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('virtualUserRun')
             .addColumn('runId', 'varchar(36)', (col) => col.primaryKey())
             .addColumn('persona', 'varchar(255)', (col) => col.notNull())
@@ -30,29 +30,29 @@ export const virtualUserSchema = {
             // running | completed | failed. Not derived from `finishedAt` being
             // null: a crashed run has no finish time either, and "crashed" and
             // "still going" are not the same answer.
-            .addColumn('status', 'varchar(50)', (col) => col.defaultTo('running').notNull())
-            .addColumn('goals', 'text', (col) => col.defaultTo('[]').notNull())
-            .addColumn('memory', 'text', (col) => col.defaultTo('{}').notNull())
-            .addColumn('findings', 'text', (col) => col.defaultTo('[]').notNull())
+            .addColumn('status', 'varchar(50)', (col) => col.defaultTo(ctx.defaultText('running')).notNull())
+            .addColumn('goals', ctx.text, (col) => col.defaultTo(ctx.defaultText('[]')).notNull())
+            .addColumn('memory', ctx.text, (col) => col.defaultTo(ctx.defaultText('{}')).notNull())
+            .addColumn('findings', ctx.text, (col) => col.defaultTo(ctx.defaultText('[]')).notNull())
             // What the user set out to do and how far each one got. On the run row
             // rather than beside the steps: there are a handful of them, and every
             // read of the run wants them.
-            .addColumn('intents', 'text', (col) => col.defaultTo('[]').notNull())
+            .addColumn('intents', ctx.text, (col) => col.defaultTo(ctx.defaultText('[]')).notNull())
             // Counts the engine kept: steps, calls, mutations, tokens, elapsed.
-            .addColumn('tally', 'text')
+            .addColumn('tally', ctx.text)
             .addColumn('stoppedBy', 'varchar(255)')
             // Why the run itself failed, as opposed to what it found.
-            .addColumn('error', 'text')
+            .addColumn('error', ctx.text)
             .addColumn('startedBy', 'varchar(255)')
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('finishedAt', 'timestamp'),
         // The two reads: the run list newest-first, and one persona's history when
         // a finding needs comparing against what that persona found before.
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_virtual_user_run_created')
             .on('virtualUserRun')
             .column('createdAt'),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_virtual_user_run_persona')
             .on('virtualUserRun')
             .columns(['persona', 'createdAt']),
@@ -62,7 +62,7 @@ export const virtualUserSchema = {
         // created by the store at boot on whatever engine the project uses, and a
         // cascade that half the engines enforce differently is worse than the read
         // rule that a step with no run is orphaned.
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('virtualUserRunStep')
             .addColumn('runId', 'varchar(36)', (col) => col.notNull())
             // The engine's own step number, which is what the intent records point
@@ -72,7 +72,7 @@ export const virtualUserSchema = {
             .addColumn('intentId', 'varchar(255)')
             // The action as the engine scheduled it, including the `invalid` shape
             // for a turn the model got wrong — that turn is the interesting one.
-            .addColumn('action', 'text', (col) => col.notNull())
+            .addColumn('action', ctx.text, (col) => col.notNull())
             .addColumn('status', 'integer')
             // 0 or 1 rather than a boolean, because a bare sqlite driver cannot
             // bind one at all and `SerializePlugin` is not installed everywhere.
@@ -81,8 +81,8 @@ export const virtualUserSchema = {
             // raw: a truncated API response usually starts with a brace, which
             // `SerializePlugin` would read back as an object rather than the string
             // the engine actually saw.
-            .addColumn('response', 'text')
-            .addColumn('findingKinds', 'text')
+            .addColumn('response', ctx.text)
+            .addColumn('findingKinds', ctx.text)
             .addColumn('tokensIn', 'integer', (col) => col.defaultTo(0).notNull())
             .addColumn('tokensOut', 'integer', (col) => col.defaultTo(0).notNull())
             .addPrimaryKeyConstraint('pk_virtual_user_run_step', [

package/dist/src/schema/webhook.schema.js

@@ -4,34 +4,34 @@ export const webhookSchema = {
     name: 'webhook',
     ownedBy: ['webhookService'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('webhookDelivery')
-            .addColumn('deliveryId', 'text', (col) => col.primaryKey())
-            .addColumn('organizationId', 'text')
-            .addColumn('url', 'text', (col) => col.notNull())
-            .addColumn('event', 'text')
-            .addColumn('status', 'text', (col) => col.defaultTo('pending').notNull())
+            .addColumn('deliveryId', ctx.key, (col) => col.primaryKey())
+            .addColumn('organizationId', ctx.key)
+            .addColumn('url', ctx.text, (col) => col.notNull())
+            .addColumn('event', ctx.text)
+            .addColumn('status', ctx.text, (col) => col.defaultTo(ctx.defaultText('pending')).notNull())
             .addColumn('attempts', 'integer', (col) => col.defaultTo(0).notNull())
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('deliveredAt', 'timestamp'),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('webhookDeliveryAttempt')
-            .addColumn('attemptId', 'text', (col) => col.primaryKey())
-            .addColumn('deliveryId', 'text', (col) => col
-            .notNull()
-            .references('webhookDelivery.deliveryId')
-            .onDelete('cascade'))
+            .addColumn('attemptId', ctx.key, (col) => col.primaryKey())
+            .addColumn('deliveryId', ctx.key, (col) => ctx.references(col.notNull(), 'webhookDelivery.deliveryId'))
             .addColumn('attemptNumber', 'integer', (col) => col.notNull())
             .addColumn('statusCode', 'integer')
-            .addColumn('responseBody', 'text')
-            .addColumn('error', 'text')
-            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
+            .addColumn('responseBody', ctx.text)
+            .addColumn('error', ctx.text)
+            .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
+            .$call(ctx.foreignKeys('webhookDeliveryAttempt', {
+            deliveryId: 'webhookDelivery.deliveryId',
+        })),
+        (db, _types, ctx) => db.schema
             .createIndex('idx_webhook_delivery_org')
             .on('webhookDelivery')
             .column('organizationId'),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_webhook_delivery_attempt_delivery')
             .on('webhookDeliveryAttempt')
             .column('deliveryId'),

package/dist/src/schema/workflow.schema.js

@@ -18,70 +18,71 @@ export const workflowSchema = {
     name: 'workflow',
     ownedBy: ['workflowService', 'workflowRunService'],
     statements: [
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('workflowRuns')
-            .addColumn('workflowRunId', 'text', (col) => col.primaryKey())
-            .addColumn('workflow', 'text', (col) => col.notNull())
-            .addColumn('status', 'text', (col) => col.notNull())
-            .addColumn('input', 'text', (col) => col.notNull())
-            .addColumn('output', 'text')
-            .addColumn('error', 'text')
-            .addColumn('state', 'text', (col) => col.defaultTo('{}'))
+            .addColumn('workflowRunId', ctx.key, (col) => col.primaryKey())
+            .addColumn('workflow', ctx.key, (col) => col.notNull())
+            .addColumn('status', ctx.key, (col) => col.notNull())
+            .addColumn('input', ctx.text, (col) => col.notNull())
+            .addColumn('output', ctx.text)
+            .addColumn('error', ctx.text)
+            .addColumn('state', ctx.text, (col) => col.defaultTo(ctx.defaultText('{}')))
             .addColumn('inline', 'boolean', (col) => col.defaultTo(false))
-            .addColumn('graphHash', 'text')
+            .addColumn('graphHash', ctx.key)
             .addColumn('deterministic', 'boolean', (col) => col.defaultTo(false))
-            .addColumn('plannedSteps', 'text')
-            .addColumn('wire', 'text')
+            .addColumn('plannedSteps', ctx.text)
+            .addColumn('wire', ctx.text)
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull()),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createTable('workflowStep')
-            .addColumn('workflowStepId', 'text', (col) => col.primaryKey())
-            .addColumn('workflowRunId', 'text', (col) => col
-            .notNull()
-            .references('workflowRuns.workflowRunId')
-            .onDelete('cascade'))
-            .addColumn('stepName', 'text', (col) => col.notNull())
-            .addColumn('rpcName', 'text')
-            .addColumn('data', 'text')
-            .addColumn('status', 'text', (col) => col.notNull().defaultTo('pending'))
-            .addColumn('result', 'text')
-            .addColumn('error', 'text')
-            .addColumn('childRunId', 'text')
-            .addColumn('branchTaken', 'text')
+            .addColumn('workflowStepId', ctx.key, (col) => col.primaryKey())
+            .addColumn('workflowRunId', ctx.key, (col) => ctx.references(col.notNull(), 'workflowRuns.workflowRunId'))
+            .addColumn('stepName', ctx.key, (col) => col.notNull())
+            .addColumn('rpcName', ctx.text)
+            .addColumn('data', ctx.text)
+            .addColumn('status', ctx.key, (col) => col.notNull().defaultTo(ctx.defaultText('pending')))
+            .addColumn('result', ctx.text)
+            .addColumn('error', ctx.text)
+            .addColumn('childRunId', ctx.text)
+            .addColumn('branchTaken', ctx.text)
             .addColumn('retries', 'integer')
-            .addColumn('retryDelay', 'text')
-            .addColumn('fromStepName', 'text')
+            .addColumn('retryDelay', ctx.text)
+            .addColumn('fromStepName', ctx.text)
             .addColumn('currentAttempt', 'integer')
+            .addColumn('leaseExpiresAt', 'bigint')
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('updatedAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addUniqueConstraint('workflow_step_run_name_unique', [
             'workflowRunId',
             'stepName',
-        ]),
-        (db) => db.schema
+        ])
+            .$call(ctx.foreignKeys('workflowStep', {
+            workflowRunId: 'workflowRuns.workflowRunId',
+        })),
+        (db, _types, ctx) => db.schema
             .createTable('workflowStepHistory')
-            .addColumn('historyId', 'text', (col) => col.primaryKey())
-            .addColumn('workflowStepId', 'text', (col) => col
-            .notNull()
-            .references('workflowStep.workflowStepId')
-            .onDelete('cascade'))
-            .addColumn('status', 'text', (col) => col.notNull())
-            .addColumn('result', 'text')
-            .addColumn('error', 'text')
+            .addColumn('historyId', ctx.key, (col) => col.primaryKey())
+            .addColumn('workflowStepId', ctx.key, (col) => ctx.references(col.notNull(), 'workflowStep.workflowStepId'))
+            .addColumn('status', ctx.key, (col) => col.notNull())
+            .addColumn('result', ctx.text)
+            .addColumn('error', ctx.text)
             .addColumn('attempt', 'integer')
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addColumn('runningAt', 'timestamp')
             .addColumn('scheduledAt', 'timestamp')
             .addColumn('succeededAt', 'timestamp')
-            .addColumn('failedAt', 'timestamp'),
-        (db) => db.schema
+            .addColumn('failedAt', 'timestamp')
+            .$call(ctx.foreignKeys('workflowStepHistory', {
+            workflowStepId: 'workflowStep.workflowStepId',
+        })),
+        (db, _types, ctx) => db.schema
             .createTable('workflowVersions')
-            .addColumn('workflowName', 'text', (col) => col.notNull())
-            .addColumn('graphHash', 'text', (col) => col.notNull())
-            .addColumn('graph', 'text', (col) => col.notNull())
-            .addColumn('source', 'text', (col) => col.notNull())
-            .addColumn('status', 'text', (col) => col.notNull().defaultTo('active'))
+            .addColumn('workflowName', ctx.key, (col) => col.notNull())
+            .addColumn('graphHash', ctx.key, (col) => col.notNull())
+            .addColumn('graph', ctx.text, (col) => col.notNull())
+            .addColumn('source', ctx.key, (col) => col.notNull())
+            .addColumn('status', ctx.key, (col) => col.notNull().defaultTo(ctx.defaultText('active')))
             .addColumn('createdAt', 'timestamp', (col) => col.defaultTo(sql `CURRENT_TIMESTAMP`).notNull())
             .addPrimaryKeyConstraint('workflow_versions_pk', [
             'workflowName',
@@ -89,23 +90,23 @@ export const workflowSchema = {
         ]),
         // The indexes trail the tables so that a table is never indexed before it
         // exists, whatever order the declarations are read in.
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_workflow_runs_status_created')
             .on('workflowRuns')
             .columns(['status', 'createdAt']),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_workflow_runs_workflow_created')
             .on('workflowRuns')
             .columns(['workflow', 'createdAt']),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_workflow_step_run_status')
             .on('workflowStep')
             .columns(['workflowRunId', 'status']),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_workflow_step_history_step')
             .on('workflowStepHistory')
             .columns(['workflowStepId', 'createdAt']),
-        (db) => db.schema
+        (db, _types, ctx) => db.schema
             .createIndex('idx_workflow_versions_source_status')
             .on('workflowVersions')
             .columns(['source', 'status']),

package/knowledge/decisions/a-lease-is-taken-by-one-guarded-update.md

@@ -0,0 +1,30 @@
+---
+type: decision
+title: A lease is taken by one guarded UPDATE
+description: Acquire inserts the key's row already lapsed, takes it with a guarded UPDATE, and reads the row back, because that is the one shape that behaves the same on SQLite, Postgres and MySQL
+tags: [leases, kysely, mysql]
+---
+
+# A lease is taken by one guarded UPDATE
+
+`acquire` is three statements, in an order that looks roundabout:
+
+1. insert the key's row with `token = 0, expires_at = 0` — already lapsed —
+   ignoring a conflict;
+2. `UPDATE` it to this holder where it is this holder's or has lapsed, raising
+   `token` unless this holder is re-acquiring a live lease;
+3. read the row back and answer whether this holder now has it.
+
+The natural shape, `INSERT … ON CONFLICT DO UPDATE … WHERE`, does not exist on
+MySQL, whose `ON DUPLICATE KEY UPDATE` has no guard. Inserting the row lapsed
+means there is a single path to holding a key — the guarded update — whether the
+key is new or not.
+
+Two MySQL behaviours shape the rest. `SET` is evaluated left to right against
+values already assigned in the same statement, so `token` is assigned before
+`holder`: the re-acquire test has to see the previous holder. And MySQL reports
+rows _changed_, not rows _matched_, so a holder re-acquiring with an unchanged
+row would look like a loss; the row is read back instead of trusting the count.
+
+**What this rules out:** a dialect-specific upsert per database, and deciding
+the outcome from `numUpdatedRows`.

package/knowledge/decisions/index.md

@@ -8,8 +8,11 @@ description: How encrypted columns are wrapped, and which key wraps them
 
 <!-- pikku:knowledge-index -->
 
+- [A lease is taken by one guarded UPDATE](a-lease-is-taken-by-one-guarded-update.md) — Acquire inserts the key's row already lapsed, takes it with a guarded UPDATE, and reads the row back, because that is the one shape that behaves the same on SQLite, Postgres and MySQL
 - [Classification-driven encryption happens in a Kysely plugin](classification-driven-encryption-happens-in-a-plugin.md) — The existing column classification manifest drives a transparent query plugin, rather than encrypting the whole database file or asking call sites to encrypt
 - [KEKs are scoped by purpose as well as version](keks-are-scoped-by-purpose-as-well-as-version.md) — Rows carry a keyId, and the plugin resolves KEKs through a seam rather than holding one; v1 ships a single key, but scoping never becomes a migration
+- [Leases are judged by the database's clock](leases-are-judged-by-the-database-clock.md) — A lease and a step lease are written and compared in SQL against the server's own clock, stored as epoch milliseconds, so no worker's clock decides who holds anything
 - [The plugin is given a resolver, never a key](the-plugin-is-given-a-resolver-never-a-key.md) — Assembly order for classified columns — a plain Kysely handle, then a plugin that asks a `KEKResolver` per operation rather than being handed a key it holds for the life of the process
+- [Workflows own the lease table too](workflows-own-the-lease-table-too.md) — `leaseSchema` is owned by `workflowService` as well as `leaseService`, because the engine takes the run lease without any function ever naming leaseService
 
 <!-- /pikku:knowledge-index -->

package/knowledge/decisions/leases-are-judged-by-the-database-clock.md

@@ -0,0 +1,42 @@
+---
+type: decision
+title: Leases are judged by the database's clock
+description: A lease and a step lease are written and compared in SQL against the server's own clock, stored as epoch milliseconds, so no worker's clock decides who holds anything
+tags: [leases, workflows, kysely, clocks]
+---
+
+# Leases are judged by the database's clock
+
+A lease is only as good as the clock that decides it has lapsed. When each
+worker computed `new Date(Date.now() + ttl)` and compared against its own
+`Date.now()`, a worker whose clock ran an hour fast saw every live lease as
+expired and took it — a lease and a step claim both — and wrote leases that
+outlived their ttl by the same hour for everyone else.
+
+So both leases are computed in SQL: `expires_at` is set to _now + ttl_ and
+compared against _now_, where _now_ is the database's —
+`clock_timestamp()` on Postgres, `utc_timestamp(6)` on MySQL. There is one clock,
+and every worker reads it. The columns are `bigint` epoch milliseconds rather
+than `timestamp`, because the arithmetic then means the same thing in every
+dialect and no driver gets to reinterpret a time zone.
+
+On MySQL the epoch is counted from `utc_timestamp`, never
+`unix_timestamp(now())`. `now()` is local to the session's time zone, and when
+that zone falls back an hour, two real instants share one local time: the
+epoch stood still for an hour, then jumped, so a dead holder's lease lived an
+hour longer and every lease written in the repeated hour lapsed at once.
+
+`PgKyselyLeaseService`, `MySQLKyselyLeaseService` and the dialect workflow
+services override `nowMs()`; `KyselyLeaseService` and `KyselyWorkflowService`
+keep the process clock, which is only correct when every process shares a host,
+as they do on SQLite.
+
+**What this rules out:** comparing a lease in JavaScript after reading it — the
+claim used to pre-check `isStepLeaseLive` in the app, and that check is exactly
+where a skewed worker decided wrongly.
+
+**Testing it:** PGlite runs in-process and takes its clock from the JS
+`Date.now`, so skewing `Date.now` skews the database too and a skew test on
+PGlite proves nothing. The skew assertions live in
+`verifiers/workflows/src/tests/lease-db.assert.ts`, against real Postgres and
+MySQL servers.

package/knowledge/decisions/workflows-own-the-lease-table-too.md

@@ -0,0 +1,22 @@
+---
+type: decision
+title: Workflows own the lease table too
+description: `leaseSchema` is owned by `workflowService` as well as `leaseService`, because the engine takes the run lease without any function ever naming leaseService
+tags: [leases, workflows, schema]
+---
+
+# Workflows own the lease table too
+
+`pikku db generate` writes a schema for a project only when a service in
+`ownedBy` is one the inspector found the project's code reaching. The workflow
+engine takes `workflow-run:<id>` from `leaseService` on every orchestration pass,
+but no function destructures `leaseService` to make that happen, so a workflow
+project was never given `pikku_lease` — and registering a lease service then
+failed at boot against a table nothing had migrated.
+
+`leaseSchema` is therefore owned by `workflowService` as well. A workflow project
+gets the table whether or not it registers a lease service yet.
+
+**What this rules out:** making `leaseService` a required service of every
+workflow project. That would force the in-memory and single-process apps, which
+have nothing to serialise, to wire a lease they cannot use.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/kysely",
-  "version": "0.13.31",
+  "version": "0.13.34",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pikkujs/pikku.git",
@@ -26,7 +26,7 @@
     "prepublishOnly": "bun run build"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.130"
+    "@pikku/core": "^0.12.136"
   },
   "dependencies": {
     "kysely": "^0.29.5"