@nylorun/runtime 0.14.0-beta → 0.15.0-beta

package/dist/store/memory.js

@@ -1,810 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { randomUUID } from "node:crypto";
-import { MemoryRecord } from "../streams/relay/memory.js";
-import { buildEvent } from "./event.js";
-import { encodeCursor } from "./cursor.js";
-import { OwnershipLostError } from "./ownership.js";
-import { DOC_TABLES, } from "./types.js";
-/** Schema version the fake reports; it has no migrations. */
-export const MEMORY_SCHEMA_VERSION = 1;
-function emptyState() {
-    return {
-        docs: Object.fromEntries(DOC_TABLES.map((table) => [table, new Map()])),
-        sessionMeta: new Map(),
-        heads: new Map(),
-        basin: { current: 0, retired: [] },
-        endpoints: new Map(),
-        principals: new Map(),
-        vaults: new Map(),
-        credentials: new Map(),
-        audit: [],
-        idempotency: new Map(),
-        settings: new Map(),
-        signingKeys: new Map(),
-        subjectEpochs: new Map(),
-        subjectUsage: new Map(),
-        publishableKeys: new Map(),
-    };
-}
-const OWNERSHIP_KEYS = new Set(["owner", "epoch", "ownerExpiresAt"]);
-const OPEN_SESSION = new Set(["running", "runnable"]);
-const byId = (entries) => [...entries].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
-const copy = (value) => structuredClone(value);
-/**
- * The data behind in-memory Session Stores: what a database is to its connections. Several
- * `MemorySessionStore`s on one `MemoryStoreData` see each other's commits and serialize their
- * transactions together, as several processes on one Tenant schema would; it outlives them,
- * so a test can close a Tenant and open it again.
- */
-export class MemoryStoreData {
-    /** @internal */ state = emptyState();
-    /** @internal */ queue = Promise.resolve();
-    /** The record of committed events, read back by the stream relay. */
-    record = new MemoryRecord();
-}
-/**
- * In-memory `SessionStore` for unit tests. Not a supported profile.
- *
- * Transactions are serialized (one at a time), each works on a copy of the
- * state and replaces it on commit, so a throw rolls back everything: documents,
- * sequences, record rows and `afterCommit` callbacks. Commit listeners see
- * only this store's commits, as with a Postgres connection.
- */
-export class MemorySessionStore {
-    data;
-    tenantId;
-    active = new AsyncLocalStorage();
-    listeners = new Set();
-    now;
-    onError;
-    closed = false;
-    constructor(options, 
-    /** Shared with other stores on the same data; a fresh, private one by default. */
-    data = new MemoryStoreData()) {
-        this.data = data;
-        this.tenantId = options.tenantId;
-        this.now = options.now ?? (() => new Date());
-        this.onError =
-            options.onError ??
-                ((error) => queueMicrotask(() => {
-                    throw error;
-                }));
-    }
-    async tx(fn) {
-        if (this.closed)
-            throw new Error("SessionStore is closed");
-        if (this.active.getStore() === this)
-            throw new Error("Nested SessionStore.tx is not allowed");
-        const release = await this.acquire();
-        let t;
-        let result;
-        try {
-            const working = copy(this.data.state);
-            t = new MemoryTx(working, this.tenantId, this.now);
-            try {
-                result = await this.active.run(this, () => fn(t));
-            }
-            finally {
-                t.closed = true;
-            }
-            this.data.state = working;
-            for (const change of t.recordChanges)
-                if (change.kind === "rows")
-                    this.data.record.commit(change.rows);
-                else {
-                    this.data.record.deleteRows(this.tenantId);
-                    this.data.record.setGeneration(this.tenantId, change.generation);
-                }
-            if (t.events.length > 0) {
-                const commit = {
-                    events: t.events,
-                    generations: t.generations,
-                };
-                for (const listener of this.listeners) {
-                    try {
-                        listener(commit);
-                    }
-                    catch (error) {
-                        this.onError(error);
-                    }
-                }
-            }
-        }
-        finally {
-            release();
-        }
-        for (const callback of t.callbacks) {
-            try {
-                await callback();
-            }
-            catch (error) {
-                this.onError(error);
-            }
-        }
-        return result;
-    }
-    onCommit(listener) {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-    record() {
-        return this.data.record;
-    }
-    async health() {
-        return {
-            ok: !this.closed,
-            schemaVersion: MEMORY_SCHEMA_VERSION,
-            expectedSchemaVersion: MEMORY_SCHEMA_VERSION,
-        };
-    }
-    async close() {
-        this.closed = true;
-        await this.data.queue;
-    }
-    acquire() {
-        let release;
-        const next = new Promise((resolve) => (release = resolve));
-        const ready = this.data.queue.then(() => release);
-        this.data.queue = this.data.queue.then(() => next);
-        return ready;
-    }
-}
-class MemoryTx {
-    s;
-    tenantId;
-    now;
-    closed = false;
-    events = [];
-    generations = [];
-    recordChanges = [];
-    callbacks = [];
-    constructor(s, tenantId, now) {
-        this.s = s;
-        this.tenantId = tenantId;
-        this.now = now;
-    }
-    check() {
-        if (this.closed)
-            throw new Error("Tx used after its transaction ended");
-    }
-    // --- documents -----------------------------------------------------------
-    async get(table, id) {
-        this.check();
-        const raw = this.s.docs[table].get(id);
-        if (raw === undefined)
-            return undefined;
-        return (table === "sessions" ? this.session(id) : JSON.parse(raw));
-    }
-    async put(table, id, body) {
-        this.check();
-        let value = body;
-        if (table === "sessions" && body && typeof body === "object") {
-            value = Object.fromEntries(Object.entries(body).filter(([key]) => !OWNERSHIP_KEYS.has(key)));
-            if (!this.s.sessionMeta.has(id))
-                this.s.sessionMeta.set(id, {
-                    owner: null,
-                    epoch: 0,
-                    ownerExpiresAt: null,
-                });
-        }
-        const json = JSON.stringify(value);
-        if (json === undefined)
-            throw new Error("Document body must be JSON");
-        this.s.docs[table].set(id, json);
-    }
-    async delete(table, id) {
-        this.check();
-        this.s.docs[table].delete(id);
-        // The session's log head stays: a session created again with this id continues its log.
-        if (table === "sessions")
-            this.s.sessionMeta.delete(id);
-    }
-    session(id) {
-        const raw = this.s.docs.sessions.get(id);
-        const meta = this.s.sessionMeta.get(id);
-        if (raw === undefined || !meta)
-            return undefined;
-        return {
-            ...JSON.parse(raw),
-            owner: meta.owner,
-            epoch: meta.epoch,
-            ownerExpiresAt: meta.ownerExpiresAt,
-        };
-    }
-    docs(table) {
-        return byId(this.s.docs[table]).map(([id, raw]) => [
-            id,
-            JSON.parse(raw),
-        ]);
-    }
-    sessions() {
-        return byId(this.s.docs.sessions).map(([id]) => this.session(id));
-    }
-    // --- ordering ------------------------------------------------------------
-    async lockSession(id) {
-        this.check();
-        // Transactions are serialized, so the whole store is already locked.
-        return this.session(id);
-    }
-    async event(sessionId, turnId, type, payload) {
-        this.check();
-        const meta = this.s.sessionMeta.get(sessionId);
-        if (!meta)
-            throw new Error(`Session ${sessionId} not found`);
-        let head = this.s.heads.get(sessionId);
-        if (!head)
-            this.s.heads.set(sessionId, (head = { head: 0, generation: this.s.basin.current }));
-        const event = buildEvent({
-            tenantId: this.tenantId,
-            sessionId,
-            turnId,
-            seq: head.head,
-            epoch: meta.epoch,
-            time: this.now(),
-            type,
-            payload,
-        });
-        const seq = head.head++;
-        this.recordChanges.push({
-            kind: "rows",
-            rows: [{ tenantId: this.tenantId, sessionId, seq, generation: head.generation, body: event }],
-        });
-        this.events.push(event);
-        this.generations.push(head.generation);
-        return copy(event);
-    }
-    afterCommit(fn) {
-        this.check();
-        this.callbacks.push(fn);
-    }
-    // --- ownership -----------------------------------------------------------
-    async takeOwnership(sessionId, claim) {
-        this.check();
-        const meta = this.s.sessionMeta.get(sessionId);
-        if (!meta)
-            return { status: "missing" };
-        if (meta.owner !== null &&
-            meta.ownerExpiresAt !== null &&
-            Date.parse(meta.ownerExpiresAt) > claim.now.getTime())
-            return {
-                status: "busy",
-                owner: meta.owner,
-                ownerExpiresAt: meta.ownerExpiresAt,
-            };
-        const previous = {
-            owner: meta.owner,
-            epoch: meta.epoch,
-            ownerExpiresAt: meta.ownerExpiresAt,
-        };
-        meta.epoch += 1;
-        meta.owner = claim.owner;
-        meta.ownerExpiresAt = new Date(claim.now.getTime() + claim.leaseMs).toISOString();
-        return {
-            status: "owned",
-            epoch: meta.epoch,
-            takeover: previous.owner !== null,
-            previous,
-        };
-    }
-    async renewOwnership(sessionId, owner, epoch, until) {
-        this.check();
-        const meta = this.s.sessionMeta.get(sessionId);
-        if (!meta || meta.owner !== owner || meta.epoch !== epoch)
-            return false;
-        meta.ownerExpiresAt = until.toISOString();
-        return true;
-    }
-    async releaseOwnership(sessionId, owner, epoch) {
-        this.check();
-        const meta = this.s.sessionMeta.get(sessionId);
-        if (!meta || meta.owner !== owner || meta.epoch !== epoch)
-            return false;
-        meta.owner = null;
-        meta.ownerExpiresAt = null;
-        return true;
-    }
-    async assertEpoch(sessionId, epoch) {
-        this.check();
-        const session = this.session(sessionId);
-        if (!session)
-            throw new OwnershipLostError(sessionId, epoch, undefined);
-        if (session.epoch !== epoch)
-            throw new OwnershipLostError(sessionId, epoch, session.epoch);
-        return session;
-    }
-    // --- typed queries -------------------------------------------------------
-    async sessionsWithStatus(statuses) {
-        this.check();
-        return this.sessions().filter((s) => statuses.includes(s.status));
-    }
-    async orphanedSessions(now, limit) {
-        this.check();
-        const lease = (s) => s.owner === null || s.ownerExpiresAt === null
-            ? -Infinity
-            : Date.parse(s.ownerExpiresAt);
-        return this.sessions()
-            .filter((s) => OPEN_SESSION.has(s.status) && lease(s) <= now.getTime())
-            .sort((a, b) => lease(a) - lease(b) || (a.id < b.id ? -1 : 1))
-            .slice(0, limit);
-    }
-    async listSessions(filter = {}) {
-        this.check();
-        return this.sessions().filter((s) => (filter.agentId === undefined || s.agentId === filter.agentId) &&
-            (filter.ownerUserId === undefined ||
-                s.ownerUserId === filter.ownerUserId));
-    }
-    async listDefinitions() {
-        this.check();
-        return this.docs("definitions").map(([, doc]) => doc);
-    }
-    async listSandboxes() {
-        this.check();
-        return this.docs("sandboxes").map(([, doc]) => doc);
-    }
-    actions() {
-        return this.docs("actions").map(([, doc]) => doc);
-    }
-    async pendingActions(agentId) {
-        this.check();
-        return this.actions().filter((a) => a.status === "pending" && a.agentId === agentId);
-    }
-    async deliveringCount(agentId) {
-        this.check();
-        return this.actions().filter((a) => a.status === "delivering" && a.agentId === agentId).length;
-    }
-    async pendingActionsWithEndpoint(limit) {
-        this.check();
-        return this.actions()
-            .filter((a) => a.status === "pending" && this.s.endpoints.has(a.agentId))
-            .slice(0, limit);
-    }
-    async expiredDeliveries(now, limit) {
-        this.check();
-        return this.actions()
-            .filter((a) => a.status === "delivering" &&
-            typeof a.deadlineAt === "string" &&
-            Date.parse(a.deadlineAt) <= now.getTime())
-            .sort((a, b) => Date.parse(a.deadlineAt) - Date.parse(b.deadlineAt) ||
-            (a.actionId < b.actionId ? -1 : 1))
-            .slice(0, limit);
-    }
-    async actionsForSession(sessionId, filter = {}) {
-        this.check();
-        return this.actions().filter((a) => a.sessionId === sessionId &&
-            (filter.turnId === undefined || a.turnId === filter.turnId) &&
-            (filter.statuses === undefined || filter.statuses.includes(a.status)));
-    }
-    async actionsWithStatus(statuses, filter = {}) {
-        this.check();
-        return this.actions().filter((a) => statuses.includes(a.status) &&
-            (filter.kinds === undefined || filter.kinds.includes(a.kind)));
-    }
-    effects() {
-        return this.docs("effects").map(([, doc]) => doc);
-    }
-    async invokingEffects(sessionId) {
-        return this.effectsForSession(sessionId, { statuses: ["invoking"] });
-    }
-    async effectsForSession(sessionId, filter = {}) {
-        this.check();
-        return this.effects().filter((e) => e.request?.sessionId === sessionId &&
-            (filter.turnId === undefined || e.request.turnId === filter.turnId) &&
-            (filter.statuses === undefined || filter.statuses.includes(e.status)));
-    }
-    async effectsForTurn(sessionId, turnId, statuses) {
-        return this.effectsForSession(sessionId, { turnId, statuses });
-    }
-    async effectsWithStatus(statuses, filter = {}) {
-        this.check();
-        return this.effects().filter((e) => statuses.includes(e.status) &&
-            (filter.kinds === undefined || filter.kinds.includes(e.request?.kind)));
-    }
-    async linkedSessions(workflowSessionId) {
-        this.check();
-        const out = [];
-        for (const [agentSessionId, link] of this.docs("links")) {
-            if (link.workflowSessionId !== workflowSessionId)
-                continue;
-            const session = this.session(agentSessionId);
-            if (session)
-                out.push({ agentSessionId, link, session });
-        }
-        return out;
-    }
-    async counts() {
-        this.check();
-        const sessions = this.sessions();
-        return {
-            sessions: sessions.length,
-            runningSessions: sessions.filter((s) => OPEN_SESSION.has(s.status))
-                .length,
-            pendingActions: this.actions().filter((a) => a.status === "pending" || a.status === "delivering").length,
-            uncertainEffects: this.effects().filter((e) => e.status === "uncertain")
-                .length,
-            sandboxes: this.s.docs.sandboxes.size,
-            definitions: this.s.docs.definitions.size,
-        };
-    }
-    // --- basin generations --------------------------------------------------
-    async basinGenerations() {
-        this.check();
-        return copy(this.s.basin);
-    }
-    async forgetRetiredGeneration(generation) {
-        this.check();
-        this.s.basin.retired = this.s.basin.retired.filter((g) => g !== generation);
-    }
-    // --- Action endpoints -----------------------------------------------------
-    async listEndpoints() {
-        this.check();
-        return byId(this.s.endpoints).map(([, row]) => copy(row));
-    }
-    async getEndpoint(agentId) {
-        this.check();
-        const row = this.s.endpoints.get(agentId);
-        return row && copy(row);
-    }
-    async putEndpoint(row) {
-        this.check();
-        const existing = this.s.endpoints.get(row.agentId);
-        const health = existing && existing.url === row.url ? healthOf(existing) : { consecutiveFailures: 0 };
-        this.s.endpoints.set(row.agentId, {
-            ...copy(row),
-            ...health,
-            createdAt: existing?.createdAt ?? row.updatedAt,
-        });
-    }
-    async deleteEndpoint(agentId) {
-        this.check();
-        this.s.endpoints.delete(agentId);
-    }
-    async recordEndpointHealth(agentId, update) {
-        this.check();
-        const row = this.s.endpoints.get(agentId);
-        if (row)
-            this.s.endpoints.set(agentId, withHealth(row, update));
-    }
-    // --- principals ----------------------------------------------------------
-    async insertPrincipal(row) {
-        this.check();
-        if (this.s.principals.has(row.id))
-            throw new Error("principals.id must be unique");
-        for (const other of this.s.principals.values())
-            if (other.tokenHash === row.tokenHash)
-                throw new Error("principals.token_hash must be unique");
-        this.s.principals.set(row.id, copy(row));
-    }
-    async principalByTokenHash(tokenHash) {
-        this.check();
-        for (const row of this.s.principals.values())
-            if (row.tokenHash === tokenHash)
-                return copy(row);
-        return undefined;
-    }
-    async principalById(id) {
-        this.check();
-        const row = this.s.principals.get(id);
-        return row && copy(row);
-    }
-    async applicationTokenHashes() {
-        this.check();
-        return byId(this.s.principals)
-            .filter(([, row]) => row.role === "application")
-            .map(([, row]) => row.tokenHash);
-    }
-    // --- vault ---------------------------------------------------------------
-    async insertVault(row) {
-        this.check();
-        if (this.s.vaults.has(row.id))
-            throw new Error("vaults.id must be unique");
-        if (row.scope === "host" &&
-            [...this.s.vaults.values()].some((v) => v.scope === "host"))
-            throw new Error("Only one host vault is allowed");
-        this.s.vaults.set(row.id, copy(row));
-    }
-    async getVault(id) {
-        this.check();
-        const row = this.s.vaults.get(id);
-        return row && copy(row);
-    }
-    async vaultsByOwner(ownerUserId) {
-        this.check();
-        return [...this.s.vaults.values()]
-            .filter((v) => v.ownerUserId === ownerUserId && v.scope === "user")
-            .sort(byCreated)
-            .map(copy);
-    }
-    async updateVaultMetadata(id, metadataJson) {
-        this.check();
-        const row = this.s.vaults.get(id);
-        if (row)
-            row.metadataJson = metadataJson;
-    }
-    async deleteVault(id) {
-        this.check();
-        for (const [credentialId, row] of this.s.credentials)
-            if (row.vaultId === id)
-                this.s.credentials.delete(credentialId);
-        this.s.vaults.delete(id);
-    }
-    async insertCredential(row) {
-        this.check();
-        if (this.s.credentials.has(row.id))
-            throw new Error("vault_credentials.id must be unique");
-        if (!this.s.vaults.has(row.vaultId))
-            throw new Error("vault_credentials.vault_id references a missing vault");
-        this.s.credentials.set(row.id, copy(row));
-    }
-    async getCredential(id) {
-        this.check();
-        const row = this.s.credentials.get(id);
-        return row && copy(row);
-    }
-    async credentialsForVault(vaultId, filter = {}) {
-        this.check();
-        return [...this.s.credentials.values()]
-            .filter((c) => c.vaultId === vaultId &&
-            (filter.type === undefined || c.type === filter.type))
-            .sort(byCreated)
-            .map(copy);
-    }
-    async updateCredential(vaultId, id, patch) {
-        this.check();
-        const row = this.s.credentials.get(id);
-        if (!row || row.vaultId !== vaultId)
-            return false;
-        const defined = Object.fromEntries(Object.entries(copy(patch)).filter(([, value]) => value !== undefined));
-        this.s.credentials.set(id, { ...row, ...defined });
-        return true;
-    }
-    async deleteCredential(vaultId, id) {
-        this.check();
-        const row = this.s.credentials.get(id);
-        if (!row || row.vaultId !== vaultId)
-            return false;
-        this.s.credentials.delete(id);
-        return true;
-    }
-    async countCredentials() {
-        this.check();
-        return this.s.credentials.size;
-    }
-    async insertVaultAudit(row) {
-        this.check();
-        this.s.audit.push(copy(row));
-    }
-    async vaultAudit(filter = {}) {
-        this.check();
-        return this.s.audit
-            .filter((r) => filter.vaultId === undefined || r.vaultId === filter.vaultId)
-            .slice(0, filter.limit ?? Infinity)
-            .map(copy);
-    }
-    async getVaultIdempotency(id) {
-        this.check();
-        const row = this.s.idempotency.get(id);
-        return row && copy(row);
-    }
-    async insertVaultIdempotency(row) {
-        this.check();
-        if (this.s.idempotency.has(row.id))
-            throw new Error("vault_idempotency.id must be unique");
-        this.s.idempotency.set(row.id, copy(row));
-    }
-    // --- subject tokens ------------------------------------------------------
-    /** Transactions are serialized already. */
-    async lockSigningKeys() {
-        this.check();
-    }
-    async insertSigningKey(row) {
-        this.check();
-        if (this.s.signingKeys.has(row.id))
-            throw new Error("signing_keys.id must be unique");
-        if (row.state !== "revoked")
-            for (const other of this.s.signingKeys.values())
-                if (other.state === row.state)
-                    throw new Error(`signing_keys allows one ${row.state} key`);
-        this.s.signingKeys.set(row.id, copy(row));
-    }
-    async signingKey(id) {
-        this.check();
-        const row = this.s.signingKeys.get(id);
-        return row && copy(row);
-    }
-    async signingKeys(states) {
-        this.check();
-        return [...this.s.signingKeys.values()]
-            .filter((row) => states === undefined || states.includes(row.state))
-            .sort(byCreated)
-            .map(copy);
-    }
-    async setSigningKeyState(id, from, to, at) {
-        this.check();
-        const row = this.s.signingKeys.get(id);
-        if (!row || row.state !== from)
-            return false;
-        if (to !== "revoked")
-            for (const other of this.s.signingKeys.values())
-                if (other.id !== id && other.state === to)
-                    throw new Error(`signing_keys allows one ${to} key`);
-        this.s.signingKeys.set(id, { ...row, ...signingKeyStamp(to, at), state: to });
-        return true;
-    }
-    async countSigningKeys() {
-        this.check();
-        return this.s.signingKeys.size;
-    }
-    async subjectEpoch(subject) {
-        this.check();
-        return this.s.subjectEpochs.get(subject) ?? 0;
-    }
-    async subjectEpochs(subjects) {
-        this.check();
-        const out = new Map();
-        for (const subject of subjects) {
-            const epoch = this.s.subjectEpochs.get(subject);
-            if (epoch !== undefined)
-                out.set(subject, epoch);
-        }
-        return out;
-    }
-    async bumpSubjectEpoch(subject, _at) {
-        this.check();
-        const epoch = (this.s.subjectEpochs.get(subject) ?? 0) + 1;
-        this.s.subjectEpochs.set(subject, epoch);
-        return epoch;
-    }
-    async lockSubjectUsage(initial) {
-        this.check();
-        // Transactions are serialized, so the row is as good as locked.
-        const row = this.s.subjectUsage.get(initial.subject);
-        if (row)
-            return copy(row);
-        this.s.subjectUsage.set(initial.subject, copy(initial));
-        return copy(initial);
-    }
-    async putSubjectUsage(row) {
-        this.check();
-        this.s.subjectUsage.set(row.subject, copy(row));
-    }
-    async countOwnerSessions(ownerUserId, statuses) {
-        this.check();
-        return this.sessions().filter((s) => s.ownerUserId === ownerUserId &&
-            statuses.includes(s.status ?? "")).length;
-    }
-    // --- publishable keys ----------------------------------------------------
-    async insertPublishableKey(row) {
-        this.check();
-        for (const other of this.s.publishableKeys.values())
-            if (other.id === row.id || other.key === row.key || other.name === row.name)
-                throw new Error("publishable_keys id, key and name must be unique");
-        this.s.publishableKeys.set(row.id, copy(row));
-    }
-    async publishableKeyByKey(key) {
-        this.check();
-        for (const row of this.s.publishableKeys.values())
-            if (row.key === key)
-                return copy(row);
-        return undefined;
-    }
-    async publishableKey(id) {
-        this.check();
-        const row = this.s.publishableKeys.get(id);
-        return row && copy(row);
-    }
-    async publishableKeys() {
-        this.check();
-        return [...this.s.publishableKeys.values()].sort(byCreated).map(copy);
-    }
-    async updatePublishableKey(id, patch) {
-        this.check();
-        const row = this.s.publishableKeys.get(id);
-        if (!row)
-            return false;
-        this.s.publishableKeys.set(id, { ...row, ...copy(patch) });
-        return true;
-    }
-    // --- settings ------------------------------------------------------------
-    async getSetting(key) {
-        this.check();
-        return this.s.settings.get(key);
-    }
-    async putSetting(key, value) {
-        this.check();
-        this.s.settings.set(key, value);
-    }
-    // --- reset ---------------------------------------------------------------
-    async reset(scope) {
-        this.check();
-        if (scope === "sessions" || scope === "all") {
-            for (const table of [
-                "sessions",
-                "commands",
-                "checkpoints",
-                "effects",
-                "actions",
-                "links",
-            ])
-                this.s.docs[table].clear();
-            this.s.sessionMeta.clear();
-            this.s.heads.clear();
-            this.s.subjectUsage.clear();
-            this.s.basin = {
-                current: this.s.basin.current + 1,
-                retired: [...this.s.basin.retired, this.s.basin.current],
-            };
-            this.recordChanges.push({ kind: "reset", generation: this.s.basin.current });
-        }
-        if (scope === "sandboxes" || scope === "all")
-            this.s.docs.sandboxes.clear();
-        if (scope === "all") {
-            this.s.docs.definitions.clear();
-            this.s.endpoints.clear();
-            for (const vault of [...this.s.vaults.values()])
-                if (vault.scope !== "host")
-                    await this.deleteVault(vault.id);
-        }
-    }
-}
-/** The time column a signing key's new state stamps. */
-export function signingKeyStamp(state, at) {
-    if (state === "current")
-        return { activatedAt: at };
-    if (state === "previous")
-        return { retiredAt: at };
-    if (state === "revoked")
-        return { revokedAt: at };
-    return {};
-}
-function byCreated(a, b) {
-    if (a.createdAt !== b.createdAt)
-        return a.createdAt < b.createdAt ? -1 : 1;
-    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
-}
-const HEALTH_KEYS = [
-    "lastDeliveryAt",
-    "lastSuccessAt",
-    "lastErrorCode",
-    "lastErrorMessage",
-    "consecutiveFailures",
-    "servedImplementationVersion",
-    "servedManifestHash",
-];
-/** The health fields of an endpoint row. */
-function healthOf(row) {
-    const health = {};
-    for (const key of HEALTH_KEYS)
-        if (row[key] !== undefined)
-            health[key] = row[key];
-    return { ...health, consecutiveFailures: row.consecutiveFailures };
-}
-/** `row` after one health observation (the same rules as the Postgres store). */
-function withHealth(row, update) {
-    switch (update.kind) {
-        case "success": {
-            const { lastErrorCode: _c, lastErrorMessage: _m, ...rest } = row;
-            return {
-                ...rest,
-                lastDeliveryAt: update.at,
-                lastSuccessAt: update.at,
-                consecutiveFailures: 0,
-            };
-        }
-        case "failure":
-            return {
-                ...row,
-                lastDeliveryAt: update.at,
-                lastErrorCode: update.code,
-                lastErrorMessage: update.message,
-                consecutiveFailures: row.consecutiveFailures + 1,
-            };
-        case "served": {
-            const { servedManifestHash: _h, ...rest } = row;
-            return {
-                ...rest,
-                servedImplementationVersion: update.implementationVersion,
-                ...(update.manifestHash === undefined ? {} : { servedManifestHash: update.manifestHash }),
-            };
-        }
-    }
-}