@usearete/automations 0.0.0-stage → 0.44.0

package/dist/postgres.cjs

@@ -0,0 +1,757 @@
+'use strict';
+
+const ACTIVE_STEP_STATES$1 = [
+    'running',
+    'signed',
+    'submitted',
+    'submitted_unknown',
+];
+const TERMINAL_STEP_STATES = [
+    'completed',
+    'chain_failed',
+    'expired',
+    'skipped',
+    'rejected',
+    'refused',
+    'failed',
+];
+const TERMINAL_DELIVERY_STATES = ['done', 'failed'];
+
+/** An append-view cursor `{epoch}:{offset}` as numbers, or `null` when it is not one. */
+function parseCursor(cursor) {
+    // The epoch is opaque (the server uses a UUID per tape lifetime); the
+    // offset follows the last colon.
+    const at = cursor.lastIndexOf(':');
+    const epoch = cursor.slice(0, at);
+    const offset = cursor.slice(at + 1);
+    if (at <= 0 || !/^\d+$/.test(offset))
+        return null;
+    return { epoch, offset: BigInt(offset) };
+}
+class StoreDeploymentError extends Error {
+    constructor(bound, requested) {
+        super(`this store belongs to deployment ${bound}, not ${requested}; use one store per deployment`);
+        this.name = 'StoreDeploymentError';
+    }
+}
+
+/**
+ * Versioned SQL migrations for the Postgres store. Every object lives in
+ * one schema (`arete_automation` by default); nothing outside it is
+ * created, altered or read. Times are milliseconds since the epoch.
+ */
+const ACTIVE_STEP_STATES = "('running', 'signed', 'submitted', 'submitted_unknown')";
+const MIGRATIONS = [
+    {
+        version: 1,
+        name: 'initial',
+        sql: (s) => `
+CREATE TABLE ${s}.meta (
+  key text PRIMARY KEY,
+  value text NOT NULL
+);
+
+CREATE TABLE ${s}.deliveries (
+  id text PRIMARY KEY,
+  accepted_at bigint NOT NULL
+);
+
+CREATE TABLE ${s}.jobs (
+  id text PRIMARY KEY,
+  seq bigserial NOT NULL,
+  kind text NOT NULL CHECK (kind IN ('delivery', 'step')),
+  state text NOT NULL,
+  wallet text,
+  deployment_id text,
+  step text,
+  data jsonb NOT NULL,
+  outcome jsonb,
+  attempts integer NOT NULL DEFAULT 0,
+  not_before bigint NOT NULL,
+  lease_worker text,
+  lease_until bigint,
+  created_at bigint NOT NULL,
+  updated_at bigint NOT NULL,
+  CHECK (kind = 'delivery' OR wallet IS NOT NULL)
+);
+
+-- At most one active step job per wallet: the store's per-wallet serialization.
+CREATE UNIQUE INDEX jobs_one_active_step_per_wallet ON ${s}.jobs (wallet)
+  WHERE kind = 'step' AND state IN ${ACTIVE_STEP_STATES};
+
+CREATE INDEX jobs_claimable ON ${s}.jobs (not_before, seq)
+  WHERE state IN ('queued', 'running', 'signed', 'submitted', 'submitted_unknown');
+
+CREATE INDEX jobs_completed_steps ON ${s}.jobs (wallet, deployment_id, step, updated_at)
+  WHERE kind = 'step' AND state = 'completed';
+
+CREATE INDEX jobs_finished ON ${s}.jobs (updated_at)
+  WHERE state IN ('done', 'failed', 'completed', 'chain_failed', 'expired', 'skipped', 'rejected', 'refused');
+
+CREATE TABLE ${s}.consents (
+  wallet text NOT NULL,
+  deployment_id text NOT NULL,
+  -- '' for a grant that covers every instance.
+  instance_id text NOT NULL,
+  steps text[] NOT NULL,
+  expires_at bigint NOT NULL,
+  revoked_at bigint,
+  grant_json jsonb NOT NULL,
+  PRIMARY KEY (wallet, deployment_id, instance_id)
+);
+
+CREATE INDEX consents_active ON ${s}.consents (deployment_id, expires_at) WHERE revoked_at IS NULL;
+
+CREATE TABLE ${s}.consent_nonces (
+  nonce text PRIMARY KEY,
+  expires_at bigint NOT NULL,
+  used_at bigint
+);
+
+CREATE TABLE ${s}.ledger (
+  id bigserial PRIMARY KEY,
+  job_id text NOT NULL,
+  wallet text NOT NULL,
+  deployment_id text NOT NULL,
+  asset text NOT NULL,
+  amount numeric(39, 0) NOT NULL CHECK (amount >= 0),
+  recorded_at bigint NOT NULL,
+  voided_at bigint
+);
+
+CREATE INDEX ledger_window ON ${s}.ledger (wallet, deployment_id, asset, recorded_at) WHERE voided_at IS NULL;
+CREATE INDEX ledger_job ON ${s}.ledger (job_id);
+
+CREATE TABLE ${s}.source_state (
+  source text NOT NULL,
+  key text NOT NULL,
+  hash text NOT NULL,
+  value jsonb,
+  generation integer NOT NULL,
+  pending jsonb,
+  observed text,
+  version integer NOT NULL,
+  updated_at bigint NOT NULL,
+  PRIMARY KEY (source, key)
+);
+
+CREATE TABLE ${s}.source_cursors (
+  source text PRIMARY KEY,
+  cursor text NOT NULL,
+  updated_at bigint NOT NULL
+);
+
+CREATE TABLE ${s}.source_leases (
+  source text PRIMARY KEY,
+  holder text NOT NULL,
+  until bigint NOT NULL
+);
+`,
+    },
+];
+const LATEST_SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;
+const DEFAULT_SCHEMA = 'arete_automation';
+/** A schema name: lower case letters, digits and underscores. */
+function validSchema(schema) {
+    if (!/^[a-z_][a-z0-9_]{0,62}$/.test(schema)) {
+        throw new TypeError(`'${schema}' is not a valid schema name (lower case letters, digits and underscores)`);
+    }
+    return schema;
+}
+/** A valid name as a quoted identifier, so reserved words (`user`, `select`) work too. */
+function quoted(name) {
+    return `"${name}"`;
+}
+/**
+ * The migrations as files for your own migration tool (Flyway, Prisma,
+ * Drizzle, Knex, Atlas): `0001_initial.sql` and so on. Each creates the
+ * schema if needed and records its version, as `migrate()` does.
+ */
+function migrationFiles(schema = DEFAULT_SCHEMA) {
+    const s = quoted(validSchema(schema));
+    return MIGRATIONS.map((migration) => ({
+        name: `${String(migration.version).padStart(4, '0')}_${migration.name}.sql`,
+        sql: [
+            `-- @usearete/automations migration ${migration.version}: ${migration.name}`,
+            `CREATE SCHEMA IF NOT EXISTS ${s};`,
+            `CREATE TABLE IF NOT EXISTS ${s}.schema_migrations (version integer PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now());`,
+            migration.sql(s).trim(),
+            `INSERT INTO ${s}.schema_migrations (version) VALUES (${migration.version});`,
+            '',
+        ].join('\n'),
+    }));
+}
+/**
+ * Grants for the runtime role: read and write rows, no DDL. Run as the role
+ * that owns the schema, after migrating.
+ */
+function runtimeRoleGrants(role, schema = DEFAULT_SCHEMA) {
+    const s = quoted(validSchema(schema));
+    if (!/^[a-z_][a-z0-9_]{0,62}$/.test(role))
+        throw new TypeError(`'${role}' is not a valid role name`);
+    role = quoted(role);
+    return [
+        `GRANT USAGE ON SCHEMA ${s} TO ${role};`,
+        `GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA ${s} TO ${role};`,
+        `GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA ${s} TO ${role};`,
+        `REVOKE CREATE ON SCHEMA ${s} FROM ${role};`,
+        '',
+    ].join('\n');
+}
+
+/**
+ * The Postgres store. It runs in your existing database, in its own schema,
+ * through the pool (or client) you pass: it opens no connections of its
+ * own and creates nothing outside its schema.
+ *
+ * Migrations never run at startup. Run `store.migrate()` (with a role that
+ * may create objects) or apply the SQL from `migrationFiles()` with your
+ * own tool; a store whose database is behind refuses to run.
+ */
+class SchemaVersionError extends Error {
+    found;
+    expected;
+    constructor(found, expected, schema) {
+        super(`the ${schema} schema is at version ${found}, and this package needs ${expected}; run store.migrate() or apply migrationFiles()`);
+        this.name = 'SchemaVersionError';
+        this.found = found;
+        this.expected = expected;
+    }
+}
+const UNIQUE_VIOLATION = '23505';
+const ACTIVE = `('${ACTIVE_STEP_STATES$1.join("', '")}')`;
+const FINISHED = `('${[...TERMINAL_STEP_STATES, ...TERMINAL_DELIVERY_STATES].join("', '")}')`;
+/**
+ * A pool hands out clients. Clients have `connect()` too (to open their
+ * connection), so a pool is recognized by its pool counters.
+ */
+function isPool(executor) {
+    return typeof executor.connect === 'function' && 'totalCount' in executor;
+}
+function code(error) {
+    return error?.code;
+}
+/** JSON for a jsonb parameter: undefined fields become null so a merge can clear them. */
+function json(value) {
+    return JSON.stringify(value, (_key, item) => (item === undefined ? null : typeof item === 'bigint' ? item.toString() : item));
+}
+/** Progress fields given as undefined or null are cleared; the rest are merged. */
+function clearedKeys(progress) {
+    return Object.entries(progress)
+        .filter(([, value]) => value === undefined || value === null)
+        .map(([key]) => key);
+}
+function progressPatch(progress) {
+    return Object.fromEntries(Object.entries(progress).filter(([, value]) => value !== undefined && value !== null));
+}
+/**
+ * Operations queued per client. A client runs one statement at a time, but
+ * two operations sharing it would interleave: one's savepoint release would
+ * also release the other's, and a statement could land inside another
+ * operation's savepoint and roll back with it. So operations on one client
+ * run one after another, across every store built over that client.
+ */
+const clientQueues = new WeakMap();
+function onClient(client, operation) {
+    const previous = clientQueues.get(client) ?? Promise.resolve();
+    const run = previous.then(operation, operation);
+    clientQueues.set(client, run.then(() => undefined, () => undefined));
+    return run;
+}
+/** `store` with each operation queued on `client`. */
+function queuedOn(client, store) {
+    const wrap = (section) => Object.fromEntries(Object.entries(section).map(([name, value]) => [
+        name,
+        typeof value === 'function' ? (...args) => onClient(client, () => value(...args)) : value,
+    ]));
+    return {
+        ...wrap(store),
+        using: store.using,
+        deliveries: wrap(store.deliveries),
+        jobs: wrap(store.jobs),
+        consent: wrap(store.consent),
+        sources: wrap(store.sources),
+        ledger: wrap(store.ledger),
+    };
+}
+const num = (value) => Number(value);
+const numOrNull = (value) => (value === null || value === undefined ? null : Number(value));
+function rowToJob(row) {
+    const base = {
+        id: row.id,
+        attempts: num(row.attempts),
+        notBefore: num(row.not_before),
+        lease: row.lease_worker === null ? null : { worker: row.lease_worker, until: num(row.lease_until) },
+        createdAt: num(row.created_at),
+        updatedAt: num(row.updated_at),
+        outcome: row.outcome ?? null,
+    };
+    if (row.kind === 'delivery') {
+        return { ...base, kind: 'delivery', state: row.state, delivery: row.data.delivery };
+    }
+    const progress = Object.fromEntries(Object.entries(row.data.progress ?? {}).filter(([, value]) => value !== null));
+    return {
+        ...base,
+        kind: 'step',
+        state: row.state,
+        deliveryId: row.data.deliveryId,
+        deploymentId: row.data.deploymentId,
+        request: row.data.request,
+        progress: { generation: 0, ...progress },
+    };
+}
+function rowToGrant(row) {
+    return { ...row.grant_json, steps: row.steps, revokedAt: numOrNull(row.revoked_at) };
+}
+function rowToSource(row) {
+    return {
+        source: row.source,
+        key: row.key,
+        hash: row.hash,
+        value: row.value,
+        generation: num(row.generation),
+        pending: row.pending ?? null,
+        observed: row.observed ?? null,
+        version: num(row.version),
+        updatedAt: num(row.updated_at),
+    };
+}
+function postgresStore(executor, options = {}) {
+    const internal = options;
+    if (options.executor === 'pool' && typeof executor.connect !== 'function') {
+        throw new TypeError("executor: 'pool' needs an executor with connect()");
+    }
+    const clientMode = internal.client === true ||
+        options.executor === 'client' ||
+        (options.executor !== 'pool' && !isPool(executor));
+    const name = validSchema(options.schema ?? DEFAULT_SCHEMA);
+    const s = quoted(name);
+    let checked = null;
+    /** Run `fn` atomically: a transaction on a pool, a savepoint on a client. */
+    const atomic = async (fn) => {
+        if (!clientMode) {
+            const client = await executor.connect();
+            try {
+                await client.query('BEGIN');
+                const result = await fn(client);
+                await client.query('COMMIT');
+                return result;
+            }
+            catch (error) {
+                await client.query('ROLLBACK').catch(() => undefined);
+                throw error;
+            }
+            finally {
+                client.release();
+            }
+        }
+        const savepoint = `arete_${Math.random().toString(36).slice(2, 10)}`;
+        await executor.query(`SAVEPOINT ${savepoint}`);
+        try {
+            const result = await fn(executor);
+            await executor.query(`RELEASE SAVEPOINT ${savepoint}`);
+            return result;
+        }
+        catch (error) {
+            await executor.query(`ROLLBACK TO SAVEPOINT ${savepoint}`).catch(() => undefined);
+            throw error;
+        }
+    };
+    const schemaVersion = async () => {
+        // Look the table up first: querying a missing one would raise an error
+        // that leaves a caller's transaction aborted.
+        const { rows: found } = await executor.query('SELECT to_regclass($1) IS NOT NULL AS present', [`${s}.schema_migrations`]);
+        if (!found[0]?.present)
+            return 0;
+        const { rows } = await executor.query(`SELECT coalesce(max(version), 0) AS version FROM ${s}.schema_migrations`);
+        return num(rows[0]?.version ?? 0);
+    };
+    const checkVersion = async () => {
+        const found = await schemaVersion();
+        if (found < LATEST_SCHEMA_VERSION)
+            throw new SchemaVersionError(found, LATEST_SCHEMA_VERSION, name);
+    };
+    /** Every operation waits for one successful version check. */
+    const ready = async () => {
+        checked ??= checkVersion().catch((error) => {
+            checked = null;
+            throw error;
+        });
+        await checked;
+    };
+    const acceptIn = async (db, delivery, now) => {
+        const inserted = await db.query(`INSERT INTO ${s}.deliveries (id, accepted_at) VALUES ($1, $2) ON CONFLICT (id) DO NOTHING`, [delivery.id, now]);
+        if (inserted.rowCount !== 1)
+            return false;
+        // The delivery id may have been pruned while its job remains: a duplicate.
+        const job = await db.query(`INSERT INTO ${s}.jobs (id, kind, state, data, not_before, created_at, updated_at)
+       VALUES ($1, 'delivery', 'queued', $2::jsonb, $3, $3, $3)
+       ON CONFLICT (id) DO NOTHING`, [delivery.id, json({ delivery }), now]);
+        return job.rowCount === 1;
+    };
+    const claimOnce = async (db, { worker, leaseMs, now }) => {
+        const { rows } = await db.query(`WITH candidate AS (
+         SELECT j.id FROM ${s}.jobs j
+         WHERE j.not_before <= $1
+           AND (j.lease_until IS NULL OR j.lease_until <= $1)
+           AND (
+             (j.kind = 'delivery' AND j.state IN ('queued', 'running'))
+             OR (j.kind = 'step' AND j.state IN ${ACTIVE})
+             OR (j.kind = 'step' AND j.state = 'queued' AND NOT EXISTS (
+                   SELECT 1 FROM ${s}.jobs a
+                   WHERE a.kind = 'step' AND a.wallet = j.wallet AND a.id <> j.id AND a.state IN ${ACTIVE}))
+           )
+         ORDER BY j.not_before, j.seq
+         LIMIT 1
+         FOR UPDATE SKIP LOCKED
+       )
+       UPDATE ${s}.jobs j
+       SET state = CASE WHEN j.state = 'queued' THEN 'running' ELSE j.state END,
+           lease_worker = $2, lease_until = $3, updated_at = $1
+       FROM candidate WHERE j.id = candidate.id
+       RETURNING j.*`, [now, worker, now + leaseMs]);
+        return rows[0] ? rowToJob(rows[0]) : null;
+    };
+    const store = {
+        schema: name,
+        schemaVersion,
+        checkVersion,
+        using: (client) => postgresStore(client, { schema: name, executor: 'client', client: true }),
+        async bindDeployment(deploymentId) {
+            await ready();
+            await executor.query(`INSERT INTO ${s}.meta (key, value) VALUES ('deployment', $1) ON CONFLICT (key) DO NOTHING`, [
+                deploymentId,
+            ]);
+            const { rows } = await executor.query(`SELECT value FROM ${s}.meta WHERE key = 'deployment'`);
+            const bound = rows[0]?.value;
+            if (bound !== deploymentId)
+                throw new StoreDeploymentError(bound, deploymentId);
+        },
+        async migrate() {
+            return atomic(async (db) => {
+                await db.query('SELECT pg_advisory_xact_lock(hashtext($1))', [`@usearete/automations:${name}`]);
+                await db.query(`CREATE SCHEMA IF NOT EXISTS ${s}`);
+                await db.query(`CREATE TABLE IF NOT EXISTS ${s}.schema_migrations (version integer PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())`);
+                const { rows } = await db.query(`SELECT coalesce(max(version), 0) AS version FROM ${s}.schema_migrations`);
+                const from = num(rows[0].version);
+                for (const migration of MIGRATIONS) {
+                    if (migration.version <= from)
+                        continue;
+                    await db.query(migration.sql(s));
+                    await db.query(`INSERT INTO ${s}.schema_migrations (version) VALUES ($1)`, [migration.version]);
+                }
+                checked = null;
+                return { from, to: Math.max(from, LATEST_SCHEMA_VERSION) };
+            });
+        },
+        deliveries: {
+            async accept(delivery, now) {
+                await ready();
+                return atomic((db) => acceptIn(db, delivery, now));
+            },
+            async prune(before) {
+                await ready();
+                const result = await executor.query(`DELETE FROM ${s}.deliveries WHERE accepted_at < $1`, [before]);
+                return result.rowCount ?? 0;
+            },
+        },
+        jobs: {
+            async get(id) {
+                await ready();
+                const { rows } = await executor.query(`SELECT * FROM ${s}.jobs WHERE id = $1`, [id]);
+                return rows[0] ? rowToJob(rows[0]) : null;
+            },
+            async claimNext(input) {
+                await ready();
+                // A concurrent claim can start another job of the same wallet; the
+                // unique index refuses the second, which then looks again.
+                for (let attempt = 0; attempt < 10; attempt += 1) {
+                    try {
+                        // In its own transaction (a savepoint inside a caller's), so a lost
+                        // race never leaves the caller's transaction aborted.
+                        return await atomic((db) => claimOnce(db, input));
+                    }
+                    catch (error) {
+                        if (code(error) !== UNIQUE_VIOLATION)
+                            throw error;
+                    }
+                }
+                return null;
+            },
+            async transition(id, input) {
+                await ready();
+                try {
+                    return await atomic(async (db) => {
+                        const result = await db.query(`UPDATE ${s}.jobs SET
+                 state = $4,
+                 updated_at = $5,
+                 lease_worker = CASE WHEN $6::bigint IS NULL THEN NULL ELSE $3 END,
+                 lease_until = $6::bigint,
+                 not_before = coalesce($7::bigint, not_before),
+                 attempts = coalesce($8::integer, attempts),
+                 outcome = CASE WHEN $9::boolean THEN $10::jsonb ELSE outcome END,
+                 data = CASE WHEN $11::jsonb IS NULL THEN data
+                   ELSE jsonb_set(data, '{progress}', (coalesce(data->'progress', '{}'::jsonb) || $11::jsonb) - $12::text[]) END
+               WHERE id = $1 AND state = $2 AND lease_worker = $3`, [
+                            id,
+                            input.from,
+                            input.worker,
+                            input.to,
+                            input.now,
+                            input.keepLease?.until ?? null,
+                            input.notBefore ?? null,
+                            input.attempts ?? null,
+                            input.outcome !== undefined,
+                            input.outcome === undefined || input.outcome === null ? null : json(input.outcome),
+                            input.progress ? json(progressPatch(input.progress)) : null,
+                            input.progress ? clearedKeys(input.progress) : [],
+                        ]);
+                        if (result.rowCount !== 1)
+                            return false;
+                        if (input.ledger?.void) {
+                            await db.query(`UPDATE ${s}.ledger SET voided_at = $2
+                 WHERE job_id = $1 AND voided_at IS NULL AND NOT (asset = ANY ($3::text[]))`, [id, input.now, [...(input.ledger.keepAssets ?? [])]]);
+                        }
+                        for (const entry of input.ledger?.record ?? []) {
+                            await db.query(`INSERT INTO ${s}.ledger (job_id, wallet, deployment_id, asset, amount, recorded_at)
+                 VALUES ($1, $2, $3, $4, $5::numeric, $6)`, [id, entry.wallet, entry.deploymentId, entry.asset, entry.amount, entry.recordedAt ?? input.now]);
+                        }
+                        return true;
+                    });
+                }
+                catch (error) {
+                    // Another job of the wallet is active.
+                    if (code(error) === UNIQUE_VIOLATION)
+                        return false;
+                    throw error;
+                }
+            },
+            async renew(id, worker, until) {
+                await ready();
+                const result = await executor.query(`UPDATE ${s}.jobs SET lease_until = $3 WHERE id = $1 AND lease_worker = $2`, [id, worker, until]);
+                return result.rowCount === 1;
+            },
+            async completeDelivery(id, worker, steps, now) {
+                await ready();
+                return atomic(async (db) => {
+                    const done = await db.query(`UPDATE ${s}.jobs SET state = 'done', lease_worker = NULL, lease_until = NULL, updated_at = $3, outcome = NULL
+             WHERE id = $1 AND kind = 'delivery' AND state = 'running' AND lease_worker = $2`, [id, worker, now]);
+                    if (done.rowCount !== 1)
+                        return false;
+                    for (const step of steps) {
+                        await db.query(`INSERT INTO ${s}.jobs (id, kind, state, wallet, deployment_id, step, data, not_before, created_at, updated_at)
+               VALUES ($1, 'step', 'queued', $2, $3, $4, $5::jsonb, $6, $6, $6)
+               ON CONFLICT (id) DO NOTHING`, [
+                            step.id,
+                            step.request.wallet,
+                            step.deploymentId,
+                            step.request.step,
+                            json({ deliveryId: id, deploymentId: step.deploymentId, request: step.request, progress: { generation: 0 } }),
+                            now,
+                        ]);
+                    }
+                    return true;
+                });
+            },
+            async lastCompleted({ wallet, deploymentId, step }) {
+                await ready();
+                const { rows } = await executor.query(`SELECT max(updated_at) AS at FROM ${s}.jobs
+           WHERE kind = 'step' AND state = 'completed' AND wallet = $1 AND deployment_id = $2 AND step = $3`, [wallet, deploymentId, step]);
+                return numOrNull(rows[0]?.at);
+            },
+            async list(filter = {}) {
+                await ready();
+                const { rows } = await executor.query(`SELECT * FROM ${s}.jobs WHERE ($1::text IS NULL OR kind = $1) AND ($2::text IS NULL OR state = $2) ORDER BY seq`, [filter.kind ?? null, filter.state ?? null]);
+                return rows.map(rowToJob);
+            },
+            async prune(before) {
+                await ready();
+                const result = await executor.query(`DELETE FROM ${s}.jobs WHERE state IN ${FINISHED} AND updated_at < $1`, [before]);
+                return result.rowCount ?? 0;
+            },
+        },
+        consent: {
+            async put(grant) {
+                await ready();
+                await executor.query(`INSERT INTO ${s}.consents (wallet, deployment_id, instance_id, steps, expires_at, revoked_at, grant_json)
+           VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)
+           ON CONFLICT (wallet, deployment_id, instance_id) DO UPDATE SET
+             steps = excluded.steps, expires_at = excluded.expires_at,
+             revoked_at = excluded.revoked_at, grant_json = excluded.grant_json`, [
+                    grant.wallet,
+                    grant.deploymentId,
+                    grant.instanceId ?? '',
+                    [...grant.steps],
+                    grant.expiresAt,
+                    grant.revokedAt,
+                    json(grant),
+                ]);
+            },
+            async find({ wallet, deploymentId, step, instanceId, now }) {
+                await ready();
+                const { rows } = await executor.query(`SELECT * FROM ${s}.consents
+           WHERE wallet = $1 AND deployment_id = $2 AND (instance_id = '' OR instance_id = $3)
+             AND $4 = ANY (steps) AND revoked_at IS NULL AND expires_at > $5
+           ORDER BY instance_id <> '' DESC
+           LIMIT 1`, [wallet, deploymentId, instanceId ?? '', step, now]);
+                return rows[0] ? rowToGrant(rows[0]) : null;
+            },
+            async revoke({ wallet, deploymentId, steps, instanceId, now }) {
+                await ready();
+                return atomic(async (db) => {
+                    const { rows } = await db.query(`SELECT * FROM ${s}.consents
+             WHERE wallet = $1 AND deployment_id = $2 AND revoked_at IS NULL AND ($3::text IS NULL OR instance_id = $3)
+             FOR UPDATE`, [wallet, deploymentId, instanceId === undefined ? null : instanceId]);
+                    let changed = 0;
+                    for (const row of rows) {
+                        const current = row.steps;
+                        if (steps && !current.some((step) => steps.includes(step)))
+                            continue;
+                        const remaining = steps ? current.filter((step) => !steps.includes(step)) : [];
+                        const grant = { ...row.grant_json, steps: remaining.length > 0 ? remaining : current };
+                        await db.query(`UPDATE ${s}.consents SET steps = $4, revoked_at = $5, grant_json = $6::jsonb
+               WHERE wallet = $1 AND deployment_id = $2 AND instance_id = $3`, [
+                            row.wallet,
+                            row.deployment_id,
+                            row.instance_id,
+                            remaining.length > 0 ? remaining : current,
+                            remaining.length > 0 ? null : now,
+                            json(grant),
+                        ]);
+                        changed += 1;
+                    }
+                    return changed;
+                });
+            },
+            async list({ wallet }) {
+                await ready();
+                const { rows } = await executor.query(`SELECT * FROM ${s}.consents WHERE wallet = $1 ORDER BY deployment_id, instance_id`, [wallet]);
+                return rows.map(rowToGrant);
+            },
+            async active({ deploymentId, step, now }) {
+                await ready();
+                const { rows } = await executor.query(`SELECT * FROM ${s}.consents
+           WHERE deployment_id = $1 AND revoked_at IS NULL AND expires_at > $2 AND ($3::text IS NULL OR $3 = ANY (steps))
+           ORDER BY wallet, instance_id`, [deploymentId, now, step ?? null]);
+                return rows.map(rowToGrant);
+            },
+            async issueNonce(nonce, expiresAt) {
+                await ready();
+                await executor.query(`INSERT INTO ${s}.consent_nonces (nonce, expires_at) VALUES ($1, $2) ON CONFLICT (nonce) DO NOTHING`, [nonce, expiresAt]);
+            },
+            async useNonce(nonce, now) {
+                await ready();
+                const result = await executor.query(`UPDATE ${s}.consent_nonces SET used_at = $2 WHERE nonce = $1 AND used_at IS NULL AND expires_at > $2`, [nonce, now]);
+                return result.rowCount === 1;
+            },
+        },
+        sources: {
+            async get(source, key) {
+                await ready();
+                const { rows } = await executor.query(`SELECT * FROM ${s}.source_state WHERE source = $1 AND key = $2`, [source, key]);
+                return rows[0] ? rowToSource(rows[0]) : null;
+            },
+            async advance({ source, key, expectedVersion, next, deliver, now }) {
+                await ready();
+                try {
+                    return await atomic(async (db) => {
+                        let row;
+                        if (expectedVersion === null) {
+                            const inserted = await db.query(`INSERT INTO ${s}.source_state (source, key, hash, value, generation, pending, observed, version, updated_at)
+                 VALUES ($1, $2, $3, $4::jsonb, 1, $5::jsonb, $7, 1, $6)
+                 ON CONFLICT (source, key) DO NOTHING
+                 RETURNING *`, [source, key, next.hash, json(next.value), next.pending ? json(next.pending) : null, now, next.observed ?? null]);
+                            row = inserted.rows[0];
+                        }
+                        else {
+                            const updated = await db.query(`UPDATE ${s}.source_state SET
+                   generation = generation + CASE WHEN hash = $3 THEN 0 ELSE 1 END,
+                   hash = $3, value = $4::jsonb, pending = $5::jsonb, observed = $8, version = version + 1, updated_at = $6
+                 WHERE source = $1 AND key = $2 AND version = $7
+                 RETURNING *`, [source, key, next.hash, json(next.value), next.pending ? json(next.pending) : null, now, expectedVersion, next.observed ?? null]);
+                            row = updated.rows[0];
+                        }
+                        if (!row)
+                            return null;
+                        const state = rowToSource(row);
+                        if (deliver) {
+                            await acceptIn(db, {
+                                id: `view:${encodeURIComponent(source)}:${encodeURIComponent(key)}:${state.generation}`,
+                                name: deliver.name,
+                                source: 'view',
+                                payload: deliver.payload,
+                                receivedAt: now,
+                            }, now);
+                        }
+                        return state;
+                    });
+                }
+                catch (error) {
+                    if (code(error) === UNIQUE_VIOLATION)
+                        return null;
+                    throw error;
+                }
+            },
+            async cursor(source) {
+                await ready();
+                const { rows } = await executor.query(`SELECT cursor FROM ${s}.source_cursors WHERE source = $1`, [source]);
+                return rows[0]?.cursor ?? null;
+            },
+            async putCursor(source, cursor, now) {
+                await ready();
+                const order = parseCursor(cursor);
+                if (!order)
+                    throw new TypeError(`'${cursor}' is not an {epoch}:{offset} cursor`);
+                // Only forward within an epoch, atomically; a new epoch always moves on.
+                await executor.query(`INSERT INTO ${s}.source_cursors (source, cursor, updated_at) VALUES ($1, $2, $3)
+           ON CONFLICT (source) DO UPDATE SET cursor = excluded.cursor, updated_at = excluded.updated_at
+           WHERE ${s}.source_cursors.cursor !~ ':[0-9]+$'
+              OR regexp_replace(${s}.source_cursors.cursor, ':[0-9]+$', '') <> $4
+              OR substring(${s}.source_cursors.cursor from ':([0-9]+)$')::numeric < $5::numeric`, [source, cursor, now, order.epoch, order.offset.toString()]);
+            },
+            async acquireLease(source, holder, until, now) {
+                await ready();
+                const { rows } = await executor.query(`INSERT INTO ${s}.source_leases (source, holder, until) VALUES ($1, $2, $3)
+           ON CONFLICT (source) DO UPDATE SET holder = excluded.holder, until = excluded.until
+             WHERE ${s}.source_leases.holder = excluded.holder OR ${s}.source_leases.until <= $4
+           RETURNING holder`, [source, holder, until, now]);
+                return rows.length === 1;
+            },
+            async releaseLease(source, holder) {
+                await ready();
+                await executor.query(`DELETE FROM ${s}.source_leases WHERE source = $1 AND holder = $2`, [source, holder]);
+            },
+        },
+        ledger: {
+            async spent({ wallet, deploymentId, asset, since }) {
+                await ready();
+                const { rows } = await executor.query(`SELECT coalesce(sum(amount), 0)::text AS total FROM ${s}.ledger
+           WHERE wallet = $1 AND deployment_id = $2 AND asset = $3 AND voided_at IS NULL AND recorded_at >= $4`, [wallet, deploymentId, asset, since]);
+                return BigInt(rows[0]?.total ?? '0');
+            },
+            async list({ wallet }) {
+                await ready();
+                const { rows } = await executor.query(`SELECT * FROM ${s}.ledger WHERE wallet = $1 ORDER BY id`, [wallet]);
+                return rows.map((row) => ({
+                    jobId: row.job_id,
+                    wallet: row.wallet,
+                    deploymentId: row.deployment_id,
+                    asset: row.asset,
+                    amount: String(row.amount),
+                    recordedAt: num(row.recorded_at),
+                    voidedAt: numOrNull(row.voided_at),
+                }));
+            },
+        },
+    };
+    return clientMode ? queuedOn(executor, store) : store;
+}
+
+exports.DEFAULT_SCHEMA = DEFAULT_SCHEMA;
+exports.LATEST_SCHEMA_VERSION = LATEST_SCHEMA_VERSION;
+exports.MIGRATIONS = MIGRATIONS;
+exports.SchemaVersionError = SchemaVersionError;
+exports.migrationFiles = migrationFiles;
+exports.postgresStore = postgresStore;
+exports.runtimeRoleGrants = runtimeRoleGrants;
+//# sourceMappingURL=postgres.cjs.map