@nylorun/runtime 0.9.0-beta → 0.11.0-beta

package/dist/tenant/runtime.js

@@ -0,0 +1,298 @@
+import { mkdirSync } from "node:fs";
+import { resolveFlowLimits } from "../core/limits.js";
+import { loadExecutorRegistry } from "../core/executors.js";
+import { scriptedModel, gatewayModel, toolFixtureModel, } from "../core/provider.js";
+import { createKekFile, readVaultKek } from "../vault/kek.js";
+import { VaultService } from "../vault/service.js";
+import { McpPool } from "../mcp/pool.js";
+import { SandboxManager } from "../sandbox/manager.js";
+import { defaultSandboxBackends } from "../sandbox/select.js";
+import { MemoryExecution } from "../execution/memory.js";
+import { QuarantineError } from "./quarantine-error.js";
+import { MemoryStreams } from "../streams/memory.js";
+import { connectedExecutorCount, createLiveHub, endAllStreams, } from "./live.js";
+import { closeStreams, drainOutbox, streamsStatus, wireStreams, } from "./streams.js";
+import { abortAll, abortLocal, createWorkState, drain, waitForIdle, } from "./scheduler.js";
+import { advance } from "./advance.js";
+import { sweep } from "./sweep.js";
+import { TenantWorkers, WORKER_ID, } from "./worker.js";
+import { authorize } from "./effects.js";
+import { handle } from "./routes.js";
+/** Default ownership lease of an advance; the heartbeat renews it every third. */
+const DEFAULT_OWNER_LEASE_MS = 30_000;
+function validateConfig(config) {
+    for (const key of ["leaseMs", "ownerLeaseMs", "sweepIntervalMs"]) {
+        const value = config[key];
+        if (value !== undefined && (!Number.isFinite(value) || value <= 0))
+            throw new Error(`${key} must be finite and positive`);
+    }
+    const flowLimits = resolveFlowLimits({
+        flow: config.flow,
+        env: config.flowEnv,
+    });
+    if ((config.model.kind === "fixture" || config.model.kind === "scripted") &&
+        config.mode === "shared")
+        throw new Error("fixture/scripted models require ephemeral or test mode");
+    return flowLimits;
+}
+export class TenantRuntime {
+    ctx;
+    envelope;
+    worker;
+    detach;
+    closeGraceMs;
+    constructor(ctx, envelope, 
+    /** This Tenant's Worker handlers, as registered with the execution. */
+    worker, detach, 
+    /** How long close waits for running advances: the execution's advance grace period. */
+    closeGraceMs) {
+        this.ctx = ctx;
+        this.envelope = envelope;
+        this.worker = worker;
+        this.detach = detach;
+        this.closeGraceMs = closeGraceMs;
+    }
+    static async open(config, hooks) {
+        const envelope = hooks.envelope;
+        const flowLimits = validateConfig(config);
+        const paths = config.paths;
+        mkdirSync(paths.root, { recursive: true });
+        mkdirSync(paths.home, { recursive: true });
+        mkdirSync(paths.tmp, { recursive: true });
+        mkdirSync(paths.sandboxes, { recursive: true });
+        mkdirSync(paths.pluginData, { recursive: true });
+        mkdirSync(paths.logs, { recursive: true });
+        const store = hooks.store;
+        let wired;
+        let detach;
+        try {
+            let kek = readVaultKek({
+                vaultKek: hooks.vaultKek,
+                vaultKekPath: paths.kek,
+            });
+            if ((await store.tx((t) => t.countCredentials())) > 0 && !kek) {
+                throw new QuarantineError("kek-missing", "Vault key-encryption key is missing for ciphertext in this Tenant", "restore the vault-kek file in the Tenant directory");
+            }
+            const createKekIfMissing = hooks.createKekIfMissing !== false;
+            const ensureKek = () => {
+                if (kek)
+                    return kek;
+                if (!createKekIfMissing)
+                    throw new QuarantineError("kek-missing", "Vault key-encryption key is required", "restore the vault-kek file in the Tenant directory");
+                kek = createKekFile(paths.kek);
+                return kek;
+            };
+            const opened = store;
+            const registry = await loadExecutorRegistry(opened);
+            // A seeded Tenant setting wins over the Host default (A18).
+            const seededBackend = await opened.tx((t) => t.getSetting("sandbox.backend"));
+            const vault = new VaultService({
+                store: opened,
+                kek: ensureKek,
+                fetch: config.vaultFetch ?? globalThis.fetch,
+            });
+            // `ctx` is assigned below; these callbacks only run once the Tenant is open.
+            let ctx;
+            const mcp = new McpPool({
+                pluginData: paths.pluginData,
+                childEnv: config.childEnv,
+                authorize: (sessionId, request) => authorize(ctx, sessionId, request),
+            });
+            const ephemeral = config.mode === "ephemeral";
+            const sandbox = new SandboxManager({
+                scope: config.tenantId,
+                store: opened,
+                backends: config.sandbox.backends ??
+                    defaultSandboxBackends({ root: paths.sandboxes }),
+                preference: seededBackend ?? config.sandbox.backend,
+                ephemeral,
+                emit: async (sessionId, turnId, type, payload) => {
+                    if (ctx.closed)
+                        return;
+                    try {
+                        await opened.tx((t) => t.event(sessionId, turnId, type, payload));
+                    }
+                    catch {
+                        /* the session is gone (reset) or the store closed */
+                    }
+                },
+            });
+            const useVaultModel = config.model.kind === "vault";
+            let modelProvider;
+            if (hooks.modelProvider)
+                modelProvider = hooks.modelProvider;
+            else if (config.model.kind === "scripted")
+                modelProvider = scriptedModel(config.model.output);
+            else if (config.model.kind === "fixture")
+                modelProvider = toolFixtureModel();
+            else if (config.model.kind === "gateway") {
+                const gateway = config.model;
+                modelProvider = async (effect, signal) => {
+                    const secret = await vault.readHostModel();
+                    const token = typeof secret?.credential.key === "string"
+                        ? secret.credential.key
+                        : "";
+                    return gatewayModel({
+                        url: gateway.url,
+                        model: gateway.model,
+                        token,
+                    })(effect, signal);
+                };
+            }
+            else
+                modelProvider = scriptedModel();
+            const live = createLiveHub();
+            const local = hooks.execution
+                ? undefined
+                : new MemoryExecution({
+                    sweepIntervalMs: config.sweepIntervalMs ?? Math.min(config.leaseMs ?? 30_000, 5000),
+                    onError: (error) => config.logger.error("tenant execution failed", {
+                        message: error instanceof Error ? error.message : String(error),
+                    }),
+                });
+            const { execution, workers } = hooks.execution ?? {
+                execution: local,
+                workers: new TenantWorkers(),
+            };
+            const sweepHooks = new Set();
+            ctx = {
+                config,
+                envelope,
+                store: opened,
+                vault,
+                registry,
+                mcp,
+                sandbox,
+                flowLimits,
+                modelProvider,
+                useVaultModel,
+                closing: false,
+                closed: false,
+                work: createWorkState(),
+                live,
+                workerId: hooks.workerId ?? WORKER_ID,
+                ownerLeaseMs: config.ownerLeaseMs ?? DEFAULT_OWNER_LEASE_MS,
+                wake: async (sessionId, wake) => {
+                    if (ctx.closing || ctx.closed)
+                        return;
+                    await execution.wake(config.tenantId, sessionId, wake);
+                },
+                abortLocal: (sessionId) => abortLocal(ctx, sessionId),
+                ...(hooks.execution?.stuckInvocations
+                    ? {
+                        stuckInvocations: () => hooks.execution.stuckInvocations(config.tenantId),
+                    }
+                    : {}),
+                sweepHooks,
+                onSweep: (hook) => {
+                    sweepHooks.add(hook);
+                    return () => sweepHooks.delete(hook);
+                },
+            };
+            wired = await wireStreams(ctx, {
+                store: opened,
+                streams: hooks.streams ?? new MemoryStreams(),
+                ownsStreams: !hooks.streams,
+                tenantId: config.tenantId,
+            });
+            // Outbox rows a lost relay step left behind are appended by the sweep.
+            sweepHooks.add(async () => {
+                await drainOutbox(ctx);
+            });
+            // Register the handlers, then arm the sweep: its first pass runs at once and re-wakes
+            // sessions a previous process left runnable or running (takeover handles the rest).
+            let afterOpen = true;
+            const worker = {
+                advance: (sessionId, signal) => advance(ctx, sessionId, signal),
+                sweep: async () => {
+                    const first = afterOpen;
+                    afterOpen = false;
+                    await sweep(ctx, { afterOpen: first });
+                },
+            };
+            const unregister = workers.register(config.tenantId, worker);
+            detach = async () => {
+                unregister();
+                await local?.stop();
+            };
+            if (local)
+                await local.start(workers.handlers);
+            await execution.armSweep(config.tenantId);
+            return new TenantRuntime(ctx, envelope, worker, detach, workers.graceMs);
+        }
+        catch (error) {
+            await detach?.().catch(() => undefined);
+            await wired?.close().catch(() => undefined);
+            await store.close().catch(() => undefined);
+            throw error;
+        }
+    }
+    handle(request, response, url) {
+        return handle(this.ctx, request, response, url);
+    }
+    authorize(sessionId, request) {
+        return authorize(this.ctx, sessionId, request);
+    }
+    async summary() {
+        const { store, live } = this.ctx;
+        const { counts, outbox } = await store.tx(async (t) => ({
+            counts: await t.counts(),
+            outbox: await t.outboxStats(),
+        }));
+        return {
+            ready: !this.ctx.closing && !this.ctx.closed,
+            runningSessions: counts.runningSessions,
+            connectedExecutors: connectedExecutorCount(live),
+            pendingActions: counts.pendingActions,
+            uncertainEffects: counts.uncertainEffects,
+            outboxDepth: outbox.depth,
+            relayLagMs: outbox.oldestCreatedAt === null
+                ? 0
+                : Math.max(0, Date.now() - Date.parse(outbox.oldestCreatedAt)),
+        };
+    }
+    drain(activeWork, timeoutMs = 30_000) {
+        return drain(this.ctx, activeWork, timeoutMs);
+    }
+    /**
+     * Aborts the advance of `sessionId` if it runs on this process. Cancel calls it after
+     * committing `cancelled`; the control stream calls it for cancels made elsewhere.
+     */
+    abortLocal(sessionId) {
+        this.ctx.abortLocal(sessionId);
+    }
+    /**
+     * The Durable Streams seam's status for Tenant status and readiness: S2 reachability, the
+     * basin, outbox depth and relay lag (`streamsStatus` in `tenant/streams.ts`).
+     */
+    streamsStatus() {
+        return streamsStatus(this.ctx);
+    }
+    /** Adds a callback to the Tenant sweep. Returns a function that removes it. */
+    onSweep(hook) {
+        return this.ctx.onSweep(hook);
+    }
+    async close() {
+        const ctx = this.ctx;
+        ctx.closing = true;
+        // A shutdown abort: the advances leave their sessions to the next advance, unsettled.
+        abortAll(ctx, "shutdown");
+        const idleBy = Date.now() + this.closeGraceMs;
+        await this.detach();
+        await ctx.mcp.close();
+        endAllStreams(ctx.live);
+        // Bounded: an advance that ignores its abort is abandoned; its lease lapses (§11.4).
+        await waitForIdle(ctx, Math.max(0, idleBy - Date.now()));
+        await ctx.sandbox.close();
+        ctx.closed = true;
+        await closeStreams(ctx);
+        await ctx.store.close();
+    }
+}
+/**
+ * Open a Tenant Runtime from an explicit `TenantConfig`. No listen() (A1).
+ * Implements `OpenTenantRuntime`.
+ */
+export async function openTenantRuntime(config, hooks) {
+    return TenantRuntime.open(config, hooks);
+}

package/dist/tenant/scheduler.d.ts

@@ -0,0 +1,25 @@
+import type { TenantContext } from "./context.js";
+import { type AdvanceAbortKind } from "./worker.js";
+export interface WorkState {
+    /** Advances running on this process, by session id. */
+    readonly running: Map<string, AbortController>;
+}
+export declare function createWorkState(): WorkState;
+/**
+ * Abort the advance of `id` if it runs on this process. Cancel calls it after committing
+ * `cancelled`, and so does the control stream for cancels made elsewhere.
+ */
+export declare function abortLocal(ctx: TenantContext, id: string, kind?: AdvanceAbortKind): void;
+/** Reset: abort every advance running on this process; their sessions are being cleared. */
+export declare function clearWork(ctx: TenantContext): void;
+/** Stop new advances; cancel active turns if asked; wait for running advances until the timeout. */
+export declare function drain(ctx: TenantContext, activeWork: "drain" | "cancel", timeoutMs: number): Promise<void>;
+/** Abort every advance running on this process; closing the Tenant is a `shutdown`. */
+export declare function abortAll(ctx: TenantContext, kind?: AdvanceAbortKind): void;
+/**
+ * Close: wait until no advance runs on this process, for at most `timeoutMs`. Advances still
+ * running then (an effect that ignores its abort signal) are abandoned and logged: they have
+ * stopped renewing their lease, so it lapses and the next advance takes the session over
+ * (§11.4); the epoch fences anything they still try to write. Returns their session ids.
+ */
+export declare function waitForIdle(ctx: TenantContext, timeoutMs: number): Promise<string[]>;

package/dist/tenant/scheduler.js

@@ -0,0 +1,84 @@
+/**
+ * Local work: the advances running on this process, for `abortLocal`, drain, reset and close.
+ *
+ * Scheduling itself lives behind `DurableExecution` (`ctx.wake`), the Tenant's handlers in
+ * `worker.ts`, `advance.ts` and `sweep.ts`. What stays here is only what one process must
+ * know about the advances it runs: their `AbortController`s, keyed by session id.
+ *
+ * Every abort carries an `AdvanceAbort` saying why (`worker.ts`): a cancel or a reset aborts
+ * with `cancel`, closing the Tenant with `shutdown`, which leaves the session for the next
+ * advance instead of settling it.
+ */
+import { randomUUID } from "node:crypto";
+import { command } from "./commands.js";
+import { AdvanceAbort } from "./worker.js";
+export function createWorkState() {
+    return { running: new Map() };
+}
+const MESSAGES = {
+    cancel: "Turn cancelled",
+    shutdown: "The Tenant is closing",
+    deadline: "The advance ran past its deadline",
+    "ownership.lost": "Ownership lost",
+};
+function abortWith(controller, kind) {
+    if (!controller.signal.aborted)
+        controller.abort(new AdvanceAbort(kind, MESSAGES[kind]));
+}
+/**
+ * Abort the advance of `id` if it runs on this process. Cancel calls it after committing
+ * `cancelled`, and so does the control stream for cancels made elsewhere.
+ */
+export function abortLocal(ctx, id, kind = "cancel") {
+    const controller = ctx.work.running.get(id);
+    if (controller)
+        abortWith(controller, kind);
+}
+/** Reset: abort every advance running on this process; their sessions are being cleared. */
+export function clearWork(ctx) {
+    abortAll(ctx, "cancel");
+}
+/** Stop new advances; cancel active turns if asked; wait for running advances until the timeout. */
+export async function drain(ctx, activeWork, timeoutMs) {
+    ctx.closing = true;
+    if (activeWork === "cancel") {
+        const active = await ctx.store.tx((t) => t.sessionsWithStatus(["running", "runnable", "paused"]));
+        for (const sess of active)
+            if (sess.activeTurnId)
+                await command(ctx, sess.id, {
+                    type: "cancel",
+                    requestId: randomUUID(),
+                    idempotencyKey: `drain-cancel-${sess.id}-${sess.activeTurnId}`,
+                    reason: "tenant drain cancel",
+                }, {
+                    kind: "application",
+                    principalId: "drain",
+                });
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (ctx.work.running.size > 0 && Date.now() < deadline)
+        await new Promise((resolve) => setTimeout(resolve, 10));
+}
+/** Abort every advance running on this process; closing the Tenant is a `shutdown`. */
+export function abortAll(ctx, kind = "shutdown") {
+    for (const c of ctx.work.running.values())
+        abortWith(c, kind);
+}
+/**
+ * Close: wait until no advance runs on this process, for at most `timeoutMs`. Advances still
+ * running then (an effect that ignores its abort signal) are abandoned and logged: they have
+ * stopped renewing their lease, so it lapses and the next advance takes the session over
+ * (§11.4); the epoch fences anything they still try to write. Returns their session ids.
+ */
+export async function waitForIdle(ctx, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (ctx.work.running.size > 0 && Date.now() < deadline)
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    const abandoned = [...ctx.work.running.keys()];
+    if (abandoned.length > 0)
+        ctx.config.logger.warn("tenant closed with advances still running", {
+            sessionIds: abandoned,
+            waitedMs: timeoutMs,
+        });
+    return abandoned;
+}

package/dist/tenant/session.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Pure helpers over the session document: turn-manifest pins and variants, state rebasing,
+ * the tools of an MCP snapshot, and the event target of an Action. No store access and no I/O.
+ *
+ * Later waves: stable; the async store conversion (Wave 1 / A) does not change these.
+ */
+import { type DurableSessionTool, type HostEffect } from "@nylorun/harness/run";
+import type { Action } from "@nylorun/core/contracts";
+import { type AgentManifest, type JsonValue } from "@nylorun/core/define";
+import { type TurnManifestStore } from "../core/turn-manifest.js";
+import type { McpSnapshot, McpToolRecord } from "../mcp/snapshot.js";
+import type { Session } from "./context.js";
+export declare function sessionToolsOf(snapshot: McpSnapshot | undefined): readonly DurableSessionTool[] | undefined;
+/** Turn-manifest store backed by the session's `variants` map (no schema change). */
+export declare function variantStore(session: Session): TurnManifestStore;
+/** Manifest this turn's checkpoint is pinned to (session pin or a stored variant). */
+export declare function turnManifestOf(session: Session): AgentManifest;
+/** Wrap a linked agent turn so the Loop learns the turn's manifest (SD-I4 pin stays on session). */
+export declare function linkedAgentOutput(session: Session, output: JsonValue | undefined): JsonValue;
+export declare function rebaseSessionState(session: Session, turnHash: string): void;
+export declare function mcpToolOf(session: Session, request: Pick<HostEffect, "agent" | "capabilityId" | "toolName">): McpToolRecord | undefined;
+/** The manifest of the agent an effect belongs to: the root, or an agent it uses as a tool. */
+export declare function manifestFor(manifest: AgentManifest, agent: HostEffect["agent"]): AgentManifest | undefined;
+export declare function pinnedTool(manifest: AgentManifest, capabilityId?: string, toolName?: string): import("@nylorun/core/define").ToolManifest | undefined;
+/** What an action runs, for events: a tool name, or a hook point and its capabilities. */
+export declare function actionTarget(action: Action): {
+    hook: {
+        at: "after" | "before";
+        scope: "step" | "turn";
+        capabilityIds: string[];
+    };
+    agent?: {
+        id: string;
+        path: string;
+        delegationId?: string | undefined;
+    } | undefined;
+} | {
+    toolName: string;
+    agent?: {
+        id: string;
+        path: string;
+        delegationId?: string | undefined;
+    } | undefined;
+} | {
+    path: string;
+    key: string;
+    agent?: {
+        id: string;
+        path: string;
+        delegationId?: string | undefined;
+    } | {
+        id: string;
+        path: string;
+        delegationId?: string | undefined;
+    } | {
+        id: string;
+        path: string;
+        delegationId?: string | undefined;
+    } | undefined;
+};

package/dist/tenant/session.js

@@ -0,0 +1,94 @@
+/**
+ * Pure helpers over the session document: turn-manifest pins and variants, state rebasing,
+ * the tools of an MCP snapshot, and the event target of an Action. No store access and no I/O.
+ *
+ * Later waves: stable; the async store conversion (Wave 1 / A) does not change these.
+ */
+import { agentTurnValue, } from "@nylorun/harness/run";
+import { delegateManifest, } from "@nylorun/core/define";
+import { isWorkflowManifest } from "../core/flow-host.js";
+import { allowedManifestHashes, rebaseTurnState, } from "../core/turn-manifest.js";
+export function sessionToolsOf(snapshot) {
+    if (!snapshot?.mcpTools.length)
+        return undefined;
+    return snapshot.mcpTools.map((tool) => ({
+        ...(tool.agentId === undefined ? {} : { agentId: tool.agentId }),
+        capabilityId: tool.capabilityId,
+        name: tool.name,
+        ...(tool.description === undefined
+            ? {}
+            : { description: tool.description }),
+        inputSchema: tool.inputSchema,
+        ...(tool.outputSchema === undefined
+            ? {}
+            : { outputSchema: tool.outputSchema }),
+    }));
+}
+/** Turn-manifest store backed by the session's `variants` map (no schema change). */
+export function variantStore(session) {
+    return {
+        get(hash) {
+            return session.variants?.[hash];
+        },
+        put(hash, manifest) {
+            session.variants = { ...(session.variants ?? {}), [hash]: manifest };
+        },
+    };
+}
+/** Manifest this turn's checkpoint is pinned to (session pin or a stored variant). */
+export function turnManifestOf(session) {
+    const hash = session.checkpoint?.manifestHash;
+    if (!hash || hash === session.manifestHash)
+        return session.manifest;
+    return session.variants?.[hash] ?? session.manifest;
+}
+/** Wrap a linked agent turn so the Loop learns the turn's manifest (SD-I4 pin stays on session). */
+export function linkedAgentOutput(session, output) {
+    if (isWorkflowManifest(session.manifest))
+        return output ?? null;
+    return agentTurnValue(output ?? null, turnManifestOf(session));
+}
+export function rebaseSessionState(session, turnHash) {
+    const allowed = allowedManifestHashes({
+        pinnedHash: session.manifestHash,
+        variantHashes: Object.keys(session.variants ?? {}),
+    });
+    const next = rebaseTurnState({
+        state: session.state,
+        turnManifestHash: turnHash,
+        isAllowedHash: (hash) => allowed.has(hash),
+    });
+    if (next !== session.state)
+        session.state = next;
+}
+export function mcpToolOf(session, request) {
+    return session.mcpSnapshot?.mcpTools.find((tool) => tool.agentId === request.agent?.id &&
+        tool.capabilityId === request.capabilityId &&
+        tool.name === request.toolName);
+}
+/** The manifest of the agent an effect belongs to: the root, or an agent it uses as a tool. */
+export function manifestFor(manifest, agent) {
+    return agent ? delegateManifest(manifest, agent.id) : manifest;
+}
+export function pinnedTool(manifest, capabilityId, toolName) {
+    const capability = manifest.capabilities.find((item) => item.id === capabilityId);
+    return capability?.tools?.find((tool) => tool.name === toolName);
+}
+/** What an action runs, for events: a tool name, or a hook point and its capabilities. */
+export function actionTarget(action) {
+    if (action.kind === "hook")
+        return {
+            hook: action.hook,
+            ...(action.agent ? { agent: action.agent } : {}),
+        };
+    if (action.kind === "tool" && "toolName" in action)
+        return {
+            toolName: action.toolName,
+            ...(action.agent ? { agent: action.agent } : {}),
+        };
+    return {
+        path: action.path,
+        key: action.key,
+        ...(action.agent ? { agent: action.agent } : {}),
+    };
+}

package/dist/tenant/sessions.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Session and definition resources: `PUT/GET /v1/agents`, `PUT /v1/sessions/:id` (create or
+ * re-attach vaults), the session list and the session view. Reads use the store's typed
+ * queries; `PUT /v1/sessions/:id` runs in one transaction with the vault attachment checks.
+ */
+import { type PutAgentRequest, type PutSessionRequest } from "@nylorun/core/contracts";
+import type { Tx } from "../store/types.js";
+import { type Session, type TenantContext } from "./context.js";
+export declare function listDefinitions(ctx: TenantContext): Promise<{
+    agents: {
+        agentId: any;
+        manifest: any;
+        manifestHash: string;
+        implementationVersion: string;
+    }[];
+}>;
+export declare function putDefinition(ctx: TenantContext, agentId: string, body: PutAgentRequest): Promise<{
+    agentId: string;
+    manifestHash: string;
+    implementationVersion: string;
+}>;
+export declare function listSessions(ctx: TenantContext, agentId: string | null): Promise<{
+    sessions: {
+        id: string;
+        agentId: string;
+        ownerUserId: string;
+        status: string;
+        activeTurnId: string | null;
+    }[];
+}>;
+/** Create a session from its definition, or re-attach vaults to an identical one. */
+export declare function putSession(ctx: TenantContext, id: string, body: PutSessionRequest): Promise<Session>;
+/** The session resource returned by `GET`/`PUT /v1/sessions/:id`. */
+export declare function sessionView(t: Tx, s: Session): Promise<unknown>;