@nylorun/runtime 0.13.0-beta → 0.15.0-beta

package/dist/vault/service.js

@@ -34,13 +34,12 @@
  * listHostProviders(): Promise<{ providers: HostModelProviderInfo[] }>
  * putHostModel(body: PutHostModelRequest): Promise<HostModelView>
  * selectHostModel(body: SelectHostModelRequest): Promise<HostModelView>
- * readHostModel(): Promise<HostModelSecret | undefined>
- * updateHostCredential(credential): Promise<void>
- *
- * // Rejected caller audit: opens its own transaction.
- * reject(route: string): Promise<void>
  * ```
  *
+ * Reading the host model's secret and writing back a refreshed one are `HostModelVault`'s
+ * (`vault/host-model.ts`), which only the Model Gate uses: this service seals the host model's
+ * credential but never reads it back.
+ *
  * ## Transactions and I/O
  *
  * - No network I/O runs inside a transaction. The KEK getter may touch the
@@ -67,16 +66,21 @@ import { VaultError } from "./error.js";
 import { hostModelCatalog } from "../model/catalog.js";
 import { normalizeVaultUrl } from "./url.js";
 const REFRESH_SKEW_MS = 60_000;
-const HOST_VAULT_ID = "host";
+const REFRESH_TIMEOUT_MS = 30_000;
+export const HOST_VAULT_ID = "host";
 const HOST_MODEL_ID = "host-model";
 export class VaultService {
     store;
     kek;
     fetchImpl;
+    refreshTimeoutMs;
+    /** Refreshes in progress by credential id: concurrent uses share one. */
+    refreshing = new Map();
     constructor(options) {
         this.store = options.store;
         this.kek = options.kek;
         this.fetchImpl = options.fetch;
+        this.refreshTimeoutMs = options.refreshTimeoutMs ?? REFRESH_TIMEOUT_MS;
     }
     // --- administration --------------------------------------------------------
     async createVault(body) {
@@ -338,7 +342,7 @@ export class VaultService {
             };
         }
         if (row.type === "oauth" && dueForRefresh(row.expiresAt)) {
-            const refreshed = await this.refresh(kek, row, payload, input.sessionId, url);
+            const refreshed = await this.refreshShared(kek, row, payload, input.sessionId, url);
             if (refreshed.status === "refused")
                 return refreshed;
             payload = refreshed.payload;
@@ -373,9 +377,9 @@ export class VaultService {
     }
     async listHostProviders() {
         return this.store.tx(async (t) => {
-            const active = await this.activeProviderId(t);
+            const active = await activeProviderId(t);
             const catalog = new Map(hostModelCatalog().providers.map((provider) => [provider.id, provider.name]));
-            const providers = (await this.hostModelRows(t)).map((row) => {
+            const providers = (await hostModelRows(t)).map((row) => {
                 const binding = modelBinding(row);
                 return {
                     id: binding.provider,
@@ -386,6 +390,7 @@ export class VaultService {
                     model: binding.model,
                     authType: binding.authType,
                     ...(binding.baseUrl ? { baseUrl: binding.baseUrl } : {}),
+                    ...(binding.settings ? { settings: binding.settings } : {}),
                     lastUpdated: row.rotatedAt ?? row.createdAt,
                     active: binding.provider === active,
                 };
@@ -412,6 +417,7 @@ export class VaultService {
                 provider: body.provider,
                 model: body.model,
                 baseUrl: body.baseUrl,
+                settings: body.settings,
                 authType: body.auth.type,
                 payload,
             });
@@ -430,7 +436,7 @@ export class VaultService {
         const kek = this.kek();
         return this.store.tx((t) => this.replay(t, `host-model-select:${body.idempotencyKey}`, body, async () => {
             this.validateHostModel(body);
-            const row = await this.hostCredentialRowFor(t, body.provider);
+            const row = await hostCredentialRowFor(t, body.provider);
             if (!row)
                 throw new VaultError(404, "Model provider is not configured");
             const binding = modelBinding(row);
@@ -442,6 +448,8 @@ export class VaultService {
                 provider: body.provider,
                 model: body.model,
                 baseUrl: body.baseUrl,
+                // Selecting a model keeps the endpoint's settings.
+                settings: binding.settings,
                 authType: binding.authType,
                 payload,
             });
@@ -456,61 +464,47 @@ export class VaultService {
             return this.hostModelView(t);
         }));
     }
-    /** Reads the active host model secret. Decrypts after the read commits. */
-    async readHostModel() {
-        const row = await this.store.tx((t) => this.activeHostCredentialRow(t));
-        if (!row)
-            return undefined;
-        const binding = modelBinding(row);
-        const payload = readHostPayload(this.kek(), row, binding);
-        const credential = binding.authType === "oauth"
-            ? { type: "oauth", ...payload.oauth }
-            : {
-                type: "api_key",
-                key: payload.apiKey,
-                ...(payload.env ? { env: payload.env } : {}),
-            };
-        return {
-            provider: binding.provider,
-            model: binding.model,
-            ...(binding.baseUrl ? { baseUrl: binding.baseUrl } : {}),
-            authType: binding.authType,
-            credential,
-        };
-    }
-    async updateHostCredential(credential) {
-        const kek = this.kek();
-        await this.store.tx(async (t) => {
-            const row = await this.activeHostCredentialRow(t);
-            if (!row)
-                throw new VaultError(404, "Model provider is not configured");
-            const binding = modelBinding(row);
-            const payload = credential.type === "oauth"
-                ? { oauth: credential }
-                : {
-                    apiKey: credential.key,
-                    ...(credential.env ? { env: credential.env } : {}),
-                };
-            const sealed = encryptSecret(kek, hostModelAad(binding.provider, binding.model), Buffer.from(JSON.stringify(payload), "utf8"));
-            await t.updateCredential(HOST_VAULT_ID, row.id, {
-                type: "model",
-                bindingJson: JSON.stringify({ ...binding, authType: credential.type }),
-                ...sealed,
-                rotatedAt: new Date().toISOString(),
-            });
-        });
-    }
-    // --- rejected callers ---------------------------------------------------------
-    async reject(route) {
-        await this.store.tx((t) => this.audit(t, {
-            actor: "executor",
-            action: "reject",
-            target: route,
-            outcome: "rejected",
-        }));
-    }
     // --- internals -----------------------------------------------------------------
     /** Calls the token endpoint outside any transaction, then stores the result. */
+    /**
+     * Refreshes an OAuth grant once for every concurrent use in this process. A rotating refresh
+     * token is valid once, so two refreshes with it would fail the second, or make the provider
+     * revoke the grant.
+     */
+    refreshShared(kek, row, payload, sessionId, url) {
+        let pending = this.refreshing.get(row.id);
+        if (!pending) {
+            pending = this.refreshLatest(kek, row, payload, sessionId, url).finally(() => this.refreshing.delete(row.id));
+            this.refreshing.set(row.id, pending);
+        }
+        return pending;
+    }
+    /** Uses a token another process refreshed instead of refreshing again, before and after. */
+    async refreshLatest(kek, row, payload, sessionId, url) {
+        const before = await this.rotatedSince(kek, row);
+        if (before)
+            return { status: "ok", payload: before };
+        const refreshed = await this.refresh(kek, row, payload, sessionId, url);
+        if (refreshed.status === "ok")
+            return refreshed;
+        // The loser of a race with another process fails with the spent refresh token.
+        const after = await this.rotatedSince(kek, row);
+        return after ? { status: "ok", payload: after } : refreshed;
+    }
+    /** The credential's payload when it was rotated after `row` was read and is not due. */
+    async rotatedSince(kek, row) {
+        const current = await this.store.tx((t) => t.getCredential(row.id));
+        if (!current || current.vaultId !== row.vaultId || !isUserCredential(current))
+            return undefined;
+        if (current.rotatedAt === row.rotatedAt || dueForRefresh(current.expiresAt))
+            return undefined;
+        try {
+            return readPayload(kek, current);
+        }
+        catch {
+            return undefined;
+        }
+    }
     async refresh(kek, row, payload, sessionId, url) {
         const failRefresh = async () => {
             await this.store.tx((t) => this.audit(t, {
@@ -557,6 +551,7 @@ export class VaultService {
                 headers,
                 body: body.toString(),
                 redirect: "error",
+                signal: AbortSignal.timeout(this.refreshTimeoutMs),
             });
             if (!response.ok)
                 return failRefresh();
@@ -640,6 +635,8 @@ export class VaultService {
         });
     }
     validateHostModel(body) {
+        if (body.settings && body.provider !== "custom")
+            throw new VaultError(400, "Model settings (context window, output limit, reasoning, compat) apply only to a custom provider.");
         if (body.provider === "custom") {
             if (!body.baseUrl)
                 throw new VaultError(400, "A base URL is required for a custom provider.");
@@ -673,6 +670,9 @@ export class VaultService {
                 provider: input.provider,
                 model: input.model,
                 ...(input.baseUrl ? { baseUrl: input.baseUrl } : {}),
+                ...(input.settings && Object.keys(input.settings).length
+                    ? { settings: input.settings }
+                    : {}),
                 authType: input.authType,
             }),
             expiresAt: null,
@@ -682,7 +682,7 @@ export class VaultService {
         });
     }
     async hostModelView(t) {
-        const row = await this.activeHostCredentialRow(t);
+        const row = await activeHostCredentialRow(t);
         if (!row)
             return { configured: false };
         const binding = modelBinding(row);
@@ -692,67 +692,15 @@ export class VaultService {
             model: binding.model,
             authType: binding.authType,
             ...(binding.baseUrl ? { baseUrl: binding.baseUrl } : {}),
+            ...(binding.settings ? { settings: binding.settings } : {}),
         };
     }
-    async hostModelRows(t) {
-        return (await t.credentialsForVault(HOST_VAULT_ID, { type: "model" })).filter((row) => {
-            try {
-                modelBinding(row);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        });
-    }
-    async hostCredentialRowFor(t, provider) {
-        const preferred = hostModelCredentialId(provider);
-        const rows = await this.hostModelRows(t);
-        return (rows.find((row) => row.id === preferred) ??
-            rows.find((row) => modelBinding(row).provider === provider));
-    }
-    async activeHostCredentialRow(t) {
-        const active = await this.activeProviderId(t);
-        if (!active)
-            return undefined;
-        return this.hostCredentialRowFor(t, active);
-    }
-    async activeProviderId(t) {
-        const vault = await t.getVault(HOST_VAULT_ID);
-        if (vault?.metadataJson) {
-            let activeProvider;
-            try {
-                activeProvider = JSON.parse(vault.metadataJson).activeProvider;
-            }
-            catch {
-                /* Fall through to the only configured provider. */
-            }
-            if (typeof activeProvider === "string" && activeProvider) {
-                try {
-                    if (await this.hostCredentialRowFor(t, activeProvider))
-                        return activeProvider;
-                }
-                catch {
-                    /* An invalid provider id falls through, as before. */
-                }
-            }
-        }
-        const rows = await this.hostModelRows(t);
-        if (rows.length === 0)
-            return undefined;
-        if (rows.length === 1)
-            return modelBinding(rows[0]).provider;
-        const legacy = rows.find((row) => row.id === HOST_MODEL_ID);
-        if (legacy)
-            return modelBinding(legacy).provider;
-        return modelBinding(rows[0]).provider;
-    }
     async setActiveProvider(t, provider) {
         await this.ensureHostVault(t);
         await t.updateVaultMetadata(HOST_VAULT_ID, JSON.stringify({ activeProvider: provider }));
     }
     async deleteHostProviderRows(t, provider) {
-        const ids = (await this.hostModelRows(t))
+        const ids = (await hostModelRows(t))
             .filter((row) => modelBinding(row).provider === provider)
             .map((row) => row.id);
         ids.push(hostModelCredentialId(provider));
@@ -818,7 +766,64 @@ function readPayload(kek, row) {
         plaintext.fill(0);
     }
 }
-function readHostPayload(kek, row, binding) {
+/** The host vault's model credential rows that parse. */
+export async function hostModelRows(t) {
+    return (await t.credentialsForVault(HOST_VAULT_ID, { type: "model" })).filter((row) => {
+        try {
+            modelBinding(row);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** The host model credential of `provider`. */
+export async function hostCredentialRowFor(t, provider) {
+    const preferred = hostModelCredentialId(provider);
+    const rows = await hostModelRows(t);
+    return (rows.find((row) => row.id === preferred) ??
+        rows.find((row) => modelBinding(row).provider === provider));
+}
+/** The provider the host model selection names, or the only (or legacy) one configured. */
+export async function activeProviderId(t) {
+    const vault = await t.getVault(HOST_VAULT_ID);
+    if (vault?.metadataJson) {
+        let activeProvider;
+        try {
+            activeProvider = JSON.parse(vault.metadataJson).activeProvider;
+        }
+        catch {
+            /* Fall through to the only configured provider. */
+        }
+        if (typeof activeProvider === "string" && activeProvider) {
+            try {
+                if (await hostCredentialRowFor(t, activeProvider))
+                    return activeProvider;
+            }
+            catch {
+                /* An invalid provider id falls through, as before. */
+            }
+        }
+    }
+    const rows = await hostModelRows(t);
+    if (rows.length === 0)
+        return undefined;
+    if (rows.length === 1)
+        return modelBinding(rows[0]).provider;
+    const legacy = rows.find((row) => row.id === HOST_MODEL_ID);
+    if (legacy)
+        return modelBinding(legacy).provider;
+    return modelBinding(rows[0]).provider;
+}
+/** The active host model credential row (ciphertext), in `t`. */
+export async function activeHostCredentialRow(t) {
+    const active = await activeProviderId(t);
+    if (!active)
+        return undefined;
+    return hostCredentialRowFor(t, active);
+}
+export function readHostPayload(kek, row, binding) {
     const plaintext = decryptSecret(kek, hostModelAad(binding.provider, binding.model), Buffer.from(row.nonce), Buffer.from(row.ciphertext), Buffer.from(row.wrappedDek), row.kekId);
     try {
         return JSON.parse(plaintext.toString("utf8"));
@@ -889,7 +894,7 @@ function requireTimestamp(value) {
         throw new VaultError(400, "Credential expiry is invalid");
     return new Date(Date.parse(value)).toISOString();
 }
-function modelBinding(row) {
+export function modelBinding(row) {
     const binding = JSON.parse(row.bindingJson);
     if (!binding.provider || !binding.model || !binding.authType)
         throw new VaultError(500, "Host model credential is unreadable");
@@ -900,7 +905,7 @@ function hostModelCredentialId(provider) {
         throw new VaultError(400, "Invalid provider id");
     return `${HOST_MODEL_ID}:${provider}`;
 }
-function hostModelAad(provider, model) {
+export function hostModelAad(provider, model) {
     return Buffer.from(canonical({
         scope: "host",
         vaultId: HOST_VAULT_ID,

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.13.0-beta";
+export declare const RUNTIME_VERSION = "0.15.0-beta";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in step with package.json by runtime/scripts/check-package.mjs, which runs in npm run check.
 // release:prepare also rewrites this when it bumps @nylorun/runtime.
-export const RUNTIME_VERSION = "0.13.0-beta";
+export const RUNTIME_VERSION = "0.15.0-beta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.13.0-beta",
+  "version": "0.15.0-beta",
   "description": "Nylorun Runtime: the agent execution Host on Postgres, Restate and S2, and model providers.",
   "type": "module",
   "license": "Apache-2.0",
@@ -30,6 +30,8 @@
       "types": "./dist/configuration.d.ts",
       "import": "./dist/configuration.js"
     },
+    "./openapi.json": "./dist/openapi.json",
+    "./admin-openapi.json": "./dist/admin-openapi.json",
     "./package.json": "./package.json"
   },
   "files": [
@@ -43,7 +45,7 @@
     "provenance": true
   },
   "scripts": {
-    "build": "npm run clean && node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json",
+    "build": "npm run clean && node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json && node scripts/copy-migrations.mjs && node scripts/build-openapi.mjs",
     "check": "npm run build && npm test && node scripts/check-package.mjs",
     "typecheck": "node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
@@ -52,24 +54,38 @@
     "test:stack:down": "node test/stack/up.mjs down",
     "prepack": "npm run build",
     "clean": "node -e \"import('node:fs').then(({rmSync})=>rmSync('dist',{recursive:true,force:true}))\"",
-    "start": "node dist/host/main.js"
+    "start": "node dist/host/main.js",
+    "db:generate": "drizzle-kit generate",
+    "db:studio": "drizzle-kit studio"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "@earendil-works/pi-ai": "0.87.0",
+    "@ag-ui/core": "~1.0.0",
+    "@asteasolutions/zod-to-openapi": "^9.1.0",
+    "@earendil-works/pi-ai": "0.99.1",
     "@hono/node-server": "^2.1.1",
-    "@nylorun/harness": "0.20.0-beta",
-    "@nylorun/core": "0.8.0-beta",
+    "@hono/zod-openapi": "^1.6.3",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@nylorun/core": "0.10.0-beta",
+    "@nylorun/harness": "0.21.1-beta",
     "@restatedev/restate-sdk": "1.16.9",
     "@s2-dev/streamstore": "0.27.0",
+    "drizzle-orm": "^0.45.3",
+    "hono": "^4.13.12",
+    "jose": "^6.2.12",
     "just-bash": "3.4.2",
-    "postgres": "^3.4.9"
+    "pg": "8.23.1",
+    "pg-logical-replication": "2.5.0",
+    "postgres": "^3.4.9",
+    "zod": "^4.6.5"
   },
   "devDependencies": {
+    "@a2a-js/sdk": "~1.3.0",
     "@ag-ui/client": "1.0.0",
+    "@scalar/openapi-parser": "^0.29.9",
     "@types/node": "^26.5.0",
+    "@types/pg": "^8.23.1",
     "@typescript/native": "npm:typescript@^7.0.2",
-    "hono": "^4.13.8",
+    "drizzle-kit": "^0.31.11",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
     "vitest": "^5.0.1"
   }

package/dist/core/executors.d.ts

@@ -1,44 +0,0 @@
-import type { ExecutorScope } from "@nylorun/core/contracts";
-import type { SessionStore } from "../store/types.js";
-/**
- * Executor bearer tokens are 256-bit CSPRNG values minted by the CLI and the wire schema
- * requires at least 16 characters, so an unsalted digest is adequate to keep them out of
- * the Session Store at rest. This is not a password KDF and must not be used for one.
- */
-export declare const hashToken: (token: string) => string;
-export interface ExecutorRecord extends ExecutorScope {
-    readonly tokenHash: string;
-    /** Always true under Runtime Tenants; startup env executors are removed (D8). */
-    readonly persisted: boolean;
-    readonly updatedAt: string;
-    /** Application principal that last registered this executor, when known. */
-    readonly principalId?: string;
-}
-/**
- * Rejects tokens that are weak, empty of agent identity, or whose hash equals any
- * application principal hash (A5). Replaces the old `serverToken` equality check.
- */
-export declare function assertExecutorCredential(executor: {
-    agentId: string;
-    implementationVersion: string;
-    token: string;
-}, applicationHashes: readonly string[]): void;
-/** Mint a 32-byte hex application/executor key for tests and CLI bootstrap. */
-export declare function mintBearerToken(): string;
-export declare class ExecutorRegistry {
-    private readonly byHash;
-    private readonly byAgent;
-    seed(records: readonly ExecutorRecord[]): void;
-    find(tokenHash: string): ExecutorRecord | undefined;
-    get(agentId: string): ExecutorRecord | undefined;
-    list(): readonly ExecutorRecord[];
-    upsert(record: ExecutorRecord): {
-        rotated: boolean;
-        previousHash?: string;
-        previousPrincipalId?: string;
-    };
-    remove(agentId: string): ExecutorRecord | undefined;
-    private write;
-}
-/** A registry seeded from the executors the store persisted (at Tenant open). */
-export declare function loadExecutorRegistry(store: SessionStore): Promise<ExecutorRegistry>;

package/dist/core/executors.js

@@ -1,95 +0,0 @@
-import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
-const equals = (a, b) => {
-    const aa = Buffer.from(a), bb = Buffer.from(b);
-    return aa.length === bb.length && timingSafeEqual(aa, bb);
-};
-/**
- * Executor bearer tokens are 256-bit CSPRNG values minted by the CLI and the wire schema
- * requires at least 16 characters, so an unsalted digest is adequate to keep them out of
- * the Session Store at rest. This is not a password KDF and must not be used for one.
- */
-export const hashToken = (token) => createHash("sha256").update(token, "utf8").digest("hex");
-/**
- * Rejects tokens that are weak, empty of agent identity, or whose hash equals any
- * application principal hash (A5). Replaces the old `serverToken` equality check.
- */
-export function assertExecutorCredential(executor, applicationHashes) {
-    const tokenHash = hashToken(executor.token);
-    const matchesApplication = applicationHashes.some((hash) => equals(hash, tokenHash));
-    if (executor.token.length < 16 ||
-        matchesApplication ||
-        !executor.agentId ||
-        !executor.implementationVersion)
-        throw new Error("Executor tokens require independent credentials and an agent id");
-}
-/** Mint a 32-byte hex application/executor key for tests and CLI bootstrap. */
-export function mintBearerToken() {
-    return randomBytes(32).toString("hex");
-}
-export class ExecutorRegistry {
-    byHash = new Map();
-    byAgent = new Map();
-    seed(records) {
-        for (const record of records)
-            this.write(record);
-    }
-    find(tokenHash) {
-        return this.byHash.get(tokenHash);
-    }
-    get(agentId) {
-        return this.byAgent.get(agentId);
-    }
-    list() {
-        return [...this.byAgent.values()];
-    }
-    upsert(record) {
-        const previous = this.byAgent.get(record.agentId);
-        const collision = this.byHash.get(record.tokenHash);
-        if (collision && collision.agentId !== record.agentId)
-            throw new Error("Executor tokens must be unique");
-        this.write(record);
-        if (!previous || previous.tokenHash === record.tokenHash)
-            return { rotated: false };
-        return {
-            rotated: true,
-            previousHash: previous.tokenHash,
-            ...(previous.principalId === undefined
-                ? {}
-                : { previousPrincipalId: previous.principalId }),
-        };
-    }
-    remove(agentId) {
-        const record = this.byAgent.get(agentId);
-        if (!record)
-            return undefined;
-        this.byAgent.delete(agentId);
-        this.byHash.delete(record.tokenHash);
-        return record;
-    }
-    write(record) {
-        const previous = this.byAgent.get(record.agentId);
-        if (previous)
-            this.byHash.delete(previous.tokenHash);
-        this.byAgent.set(record.agentId, record);
-        this.byHash.set(record.tokenHash, record);
-    }
-}
-/** A registry seeded from the executors the store persisted (at Tenant open). */
-export async function loadExecutorRegistry(store) {
-    const registry = new ExecutorRegistry();
-    const rows = await store.tx((t) => t.listExecutors());
-    registry.seed(rows.map((row) => ({
-        agentId: row.agentId,
-        implementationVersion: row.implementationVersion,
-        ...(row.manifestHash === undefined
-            ? {}
-            : { manifestHash: row.manifestHash }),
-        tokenHash: row.tokenHash,
-        persisted: true,
-        updatedAt: row.updatedAt,
-        ...(row.principalId === undefined
-            ? {}
-            : { principalId: row.principalId }),
-    })));
-    return registry;
-}

package/dist/store/memory.d.ts

@@ -1,57 +0,0 @@
-import { type CommitListener, type DocTable, type ExecutorRow, type PrincipalRow, type SessionOwnership, type SessionStore, type SessionStoreOptions, type StoreHealth, type Tx, type VaultAuditRow, type VaultCredentialRow, type VaultIdempotencyRow, type VaultRow } from "./types.js";
-/** Schema version the fake reports; it has no migrations. */
-export declare const MEMORY_SCHEMA_VERSION = 1;
-interface SessionMeta extends SessionOwnership {
-    nextSeq: number;
-}
-interface State {
-    /** JSON text per id, like a `body` column. */
-    docs: Record<DocTable, Map<string, string>>;
-    sessionMeta: Map<string, SessionMeta>;
-    /** sessionId → seq → event JSON. */
-    outbox: Map<string, Map<number, string>>;
-    executors: Map<string, ExecutorRow>;
-    principals: Map<string, PrincipalRow>;
-    vaults: Map<string, VaultRow>;
-    credentials: Map<string, VaultCredentialRow>;
-    audit: VaultAuditRow[];
-    idempotency: Map<string, VaultIdempotencyRow>;
-    settings: Map<string, string>;
-}
-/**
- * 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 declare class MemoryStoreData {
-    /** @internal */ state: State;
-    /** @internal */ queue: Promise<void>;
-}
-/**
- * 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, outbox rows, `afterCommit` callbacks and `signalWork`. Commit listeners see
- * only this store's commits, as with a Postgres connection.
- */
-export declare class MemorySessionStore implements SessionStore {
-    /** Shared with other stores on the same data; a fresh, private one by default. */
-    private readonly data;
-    readonly tenantId: string;
-    private readonly active;
-    private readonly listeners;
-    private readonly now;
-    private readonly onError;
-    private closed;
-    constructor(options: SessionStoreOptions, 
-    /** Shared with other stores on the same data; a fresh, private one by default. */
-    data?: MemoryStoreData);
-    tx<T>(fn: (t: Tx) => Promise<T>): Promise<T>;
-    onCommit(listener: CommitListener): () => void;
-    health(): Promise<StoreHealth>;
-    close(): Promise<void>;
-    private acquire;
-}
-export {};