@nylorun/runtime 0.9.0-beta → 0.11.0-beta

package/dist/tenant/quarantine-error.js

@@ -0,0 +1,9 @@
+/** Typed quarantine raised while opening a Tenant Runtime (A7). */
+export class QuarantineError extends Error {
+    quarantine;
+    constructor(code, message, repair = "nylo tenant status") {
+        super(message);
+        this.name = "QuarantineError";
+        this.quarantine = { code, message, repair };
+    }
+}

package/dist/tenant/quarantine.d.ts

@@ -0,0 +1,27 @@
+import type { Quarantine } from "./types.js";
+/** Typed quarantine failure thrown by stores and migration. */
+export declare class QuarantineError extends Error implements Quarantine {
+    readonly code: Quarantine["code"];
+    readonly repair: string;
+    constructor(fields: Quarantine);
+    toQuarantine(): Quarantine;
+}
+export declare function isQuarantineError(error: unknown): error is QuarantineError;
+export declare function asQuarantine(error: unknown): Quarantine | undefined;
+/** CLI-facing repair strings for every quarantine code (B9). */
+export declare function repairFor(code: Quarantine["code"], detail?: {
+    tenantId?: string;
+}): string;
+export declare function quarantine(code: Quarantine["code"], message: string, detail?: {
+    tenantId?: string;
+}): QuarantineError;
+/** Conflict when create bootstrap material does not match an existing Tenant (HTTP 409). */
+export declare class TenantConflictError extends Error {
+    readonly statusCode: 409;
+    constructor(message?: string);
+}
+/** Delete refused because the Tenant still has live work (HTTP 409). */
+export declare class TenantBusyError extends Error {
+    readonly statusCode: 409;
+    constructor(message?: string);
+}

package/dist/tenant/quarantine.js

@@ -0,0 +1,72 @@
+/** Typed quarantine failure thrown by stores and migration. */
+export class QuarantineError extends Error {
+    code;
+    repair;
+    constructor(fields) {
+        super(fields.message);
+        this.name = "QuarantineError";
+        this.code = fields.code;
+        this.repair = fields.repair;
+    }
+    toQuarantine() {
+        return { code: this.code, message: this.message, repair: this.repair };
+    }
+}
+export function isQuarantineError(error) {
+    return error instanceof QuarantineError;
+}
+export function asQuarantine(error) {
+    if (isQuarantineError(error))
+        return error.toQuarantine();
+    if (error &&
+        typeof error === "object" &&
+        "code" in error &&
+        "message" in error &&
+        "repair" in error) {
+        return error;
+    }
+    return undefined;
+}
+/** CLI-facing repair strings for every quarantine code (B9). */
+export function repairFor(code, detail = {}) {
+    const id = detail.tenantId ? ` ${detail.tenantId}` : "";
+    switch (code) {
+        case "kek-missing":
+            return `nylo tenant status${id} — restore vault-kek for this Tenant (ciphertext cannot be opened without it)`;
+        case "corrupt":
+            return `nylo tenant status${id} — restore the Tenant from backup`;
+        case "schema-too-new":
+            return `nylo tenant status${id} — the Tenant was migrated by a newer Runtime; run that version or newer`;
+        case "migration-failed":
+            return `nylo tenant status${id} — inspect the Runtime log for the failed migration, fix it, then restart the Runtime`;
+        case "envelope-invalid":
+            return `nylo tenant status${id} — the Tenant envelope is missing or invalid; restore the Tenant from backup`;
+        case "open-timeout":
+            return `nylo tenant status${id} — open timed out; inspect the Runtime log and Postgres, then retry`;
+        case "open-failed":
+            return `nylo tenant status${id} — inspect Tenant logs and repair before the Host retries open`;
+    }
+}
+export function quarantine(code, message, detail = {}) {
+    return new QuarantineError({
+        code,
+        message,
+        repair: repairFor(code, detail),
+    });
+}
+/** Conflict when create bootstrap material does not match an existing Tenant (HTTP 409). */
+export class TenantConflictError extends Error {
+    statusCode = 409;
+    constructor(message = "Tenant already exists with different bootstrap material") {
+        super(message);
+        this.name = "TenantConflictError";
+    }
+}
+/** Delete refused because the Tenant still has live work (HTTP 409). */
+export class TenantBusyError extends Error {
+    statusCode = 409;
+    constructor(message = "Tenant has live work; pass activeWork=drain|cancel or retry later") {
+        super(message);
+        this.name = "TenantBusyError";
+    }
+}

package/dist/tenant/reset.d.ts

@@ -0,0 +1,22 @@
+import type { ResetScope, SessionStore } from "../store/types.js";
+import type { ExecutorRegistry } from "../core/executors.js";
+import type { SandboxManager } from "../sandbox/manager.js";
+import type { TenantPaths } from "./types.js";
+export type { ResetScope } from "../store/types.js";
+export interface ResetTenantContext {
+    store: SessionStore;
+    registry: ExecutorRegistry;
+    sandbox: SandboxManager;
+    paths: TenantPaths;
+    /** Clear in-memory session observers after the store wipe. */
+    clearSessionState: () => void;
+    /** Clear executor SSE streams when registrations are removed. */
+    clearExecutorStreams: () => void;
+}
+/**
+ * Reset Tenant durable state for `scope` (A17).
+ * Caller must have already drained (`activeWork`). Deletes store state in one
+ * transaction (`Tx.reset`), then does the filesystem rename+delete for sandboxes /
+ * log as needed. The host vault (model credentials), principals and settings stay.
+ */
+export declare function resetTenant(ctx: ResetTenantContext, scope: ResetScope): Promise<void>;

package/dist/tenant/reset.js

@@ -0,0 +1,81 @@
+import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+/**
+ * Rename `dir` to a sibling, delete the sibling, recreate an empty `dir`.
+ * Failure before rename leaves the original intact; after rename the empty
+ * target is restored so the Tenant layout stays valid (A17).
+ */
+function replaceDirectory(dir) {
+    mkdirSync(dir, { recursive: true });
+    const sibling = `${dir}.resetting`;
+    if (existsSync(sibling))
+        rmSync(sibling, { recursive: true, force: true });
+    renameSync(dir, sibling);
+    try {
+        mkdirSync(dir, { recursive: true });
+        rmSync(sibling, { recursive: true, force: true });
+    }
+    catch (error) {
+        // Best-effort restore if recreation failed.
+        if (!existsSync(dir) && existsSync(sibling)) {
+            try {
+                renameSync(sibling, dir);
+            }
+            catch {
+                /* leave sibling for operator inspection */
+            }
+        }
+        throw error;
+    }
+}
+/**
+ * Reset Tenant durable state for `scope` (A17).
+ * Caller must have already drained (`activeWork`). Deletes store state in one
+ * transaction (`Tx.reset`), then does the filesystem rename+delete for sandboxes /
+ * log as needed. The host vault (model credentials), principals and settings stay.
+ */
+export async function resetTenant(ctx, scope) {
+    const clearSessions = scope === "sessions" || scope === "all";
+    const clearSandboxes = scope === "sandboxes" || scope === "all";
+    const clearAll = scope === "all";
+    if (clearSandboxes) {
+        await ctx.sandbox.reconcile(() => false);
+    }
+    await ctx.store.tx((t) => t.reset(scope));
+    if (clearAll)
+        for (const row of ctx.registry.list())
+            ctx.registry.remove(row.agentId);
+    if (clearSessions)
+        ctx.clearSessionState();
+    if (clearAll)
+        ctx.clearExecutorStreams();
+    if (clearSandboxes)
+        replaceDirectory(ctx.paths.sandboxes);
+    if (clearAll) {
+        mkdirSync(ctx.paths.logs, { recursive: true });
+        const logSibling = join(ctx.paths.logs, "tenant.log.resetting");
+        if (existsSync(ctx.paths.log)) {
+            if (existsSync(logSibling))
+                rmSync(logSibling, { force: true });
+            renameSync(ctx.paths.log, logSibling);
+            try {
+                writeFileSync(ctx.paths.log, "");
+                rmSync(logSibling, { force: true });
+            }
+            catch (error) {
+                if (!existsSync(ctx.paths.log) && existsSync(logSibling)) {
+                    try {
+                        renameSync(logSibling, ctx.paths.log);
+                    }
+                    catch {
+                        /* leave sibling */
+                    }
+                }
+                throw error;
+            }
+        }
+        else {
+            writeFileSync(ctx.paths.log, "");
+        }
+    }
+}

package/dist/tenant/routes-tenant.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tenant administration and vault routes: `/v1/tenant` (status, reset, config seed, host
+ * model and providers, sandbox report) and `/v1/vaults` (vaults and credentials).
+ * A reset that deletes sessions abandons their streams (a session created again gets a new
+ * incarnation) and collects them afterwards; it never deletes the Tenant's basin.
+ *
+ * Later waves: Wave 2 / X changes what reset clears once work leaves process memory.
+ */
+import type { IncomingMessage } from "node:http";
+import type { AuthScope, TenantContext } from "./context.js";
+export declare function dispatchTenant(ctx: TenantContext, scope: AuthScope, method: string | undefined, path: string[], request: IncomingMessage): Promise<unknown>;
+export declare function dispatchVault(ctx: TenantContext, scope: AuthScope, method: string | undefined, path: string[], url: URL, request: IncomingMessage): Promise<unknown>;

package/dist/tenant/routes-tenant.js

@@ -0,0 +1,126 @@
+import { CreateCredentialRequestSchema, CreateVaultRequestSchema, PutHostModelRequestSchema, ResetTenantRequestSchema, RotateCredentialRequestSchema, SeedTenantConfigRequestSchema, SelectHostModelRequestSchema, } from "@nylorun/core/contracts";
+import { hostModelCatalog } from "../model/catalog.js";
+import { resetTenant } from "./reset.js";
+import { buildTenantStatus, seedTenantConfig } from "./status.js";
+import { fail, readBody } from "./http.js";
+import { clearExecutorStreams, clearObservers } from "./live.js";
+import { requestStreamCollection, sessionStreamsAbandoned, streamsStatus, } from "./streams.js";
+import { clearWork, drain } from "./scheduler.js";
+import { usesFixtureModel } from "./model-setting.js";
+export async function dispatchTenant(ctx, scope, method, path, request) {
+    const { vault } = ctx;
+    if (scope.kind !== "application") {
+        await vault.reject(path.join("/"));
+        fail(403, "Application credential required");
+    }
+    if (path.length === 2 && method === "GET")
+        return await buildTenantStatus({
+            envelope: ctx.envelope,
+            config: ctx.config,
+            store: ctx.store,
+            registry: ctx.registry,
+            vault,
+            sandbox: ctx.sandbox,
+            closing: ctx.closing || ctx.closed,
+            modelConfigured: !ctx.useVaultModel ||
+                (await ctx.store.tx((t) => usesFixtureModel(t))) ||
+                (await vault.getHostModel()).configured,
+            executorStreams: ctx.live.executorStreams,
+            ...(ctx.stuckInvocations
+                ? { stuckInvocations: ctx.stuckInvocations }
+                : {}),
+            streamsStatus: () => streamsStatus(ctx),
+        });
+    if (path[2] === "reset" && path.length === 3 && method === "POST") {
+        const body = ResetTenantRequestSchema.parse(await readBody(request));
+        await drain(ctx, body.activeWork, 30_000);
+        // The deleted sessions' streams are abandoned: a session created again with the same id,
+        // during or after the reset, gets a new incarnation and starts at sequence 0. The pending
+        // collection is recorded first, so a crash before it runs leaves it to the sweep.
+        const sessionsReset = body.scope !== "sandboxes";
+        if (sessionsReset)
+            await requestStreamCollection(ctx);
+        await resetTenant({
+            store: ctx.store,
+            registry: ctx.registry,
+            sandbox: ctx.sandbox,
+            paths: ctx.config.paths,
+            clearSessionState: () => {
+                clearWork(ctx);
+                clearObservers(ctx.live);
+            },
+            clearExecutorStreams: () => clearExecutorStreams(ctx.live),
+        }, body.scope);
+        if (sessionsReset)
+            sessionStreamsAbandoned(ctx);
+        // Reset leaves the Tenant open for new work.
+        ctx.closing = false;
+        return { ok: true };
+    }
+    if (path[2] === "config" &&
+        path[3] === "seed" &&
+        path.length === 4 &&
+        method === "PUT") {
+        const body = SeedTenantConfigRequestSchema.parse(await readBody(request));
+        return await seedTenantConfig({ store: ctx.store, vault }, body);
+    }
+    if (path[2] === "models" && path.length === 3 && method === "GET")
+        return hostModelCatalog();
+    if (path[2] === "sandbox" && path.length === 3 && method === "GET")
+        return ctx.sandbox.report();
+    if (path[2] === "providers" && path.length === 3 && method === "GET")
+        return vault.listHostProviders();
+    if (path[2] === "model" && path.length === 3 && method === "GET")
+        return vault.getHostModel();
+    if (path[2] === "model" && path.length === 3 && method === "PUT")
+        return vault.putHostModel(PutHostModelRequestSchema.parse(await readBody(request)));
+    if (path[2] === "model" &&
+        path[3] === "selection" &&
+        path.length === 4 &&
+        method === "PUT")
+        return vault.selectHostModel(SelectHostModelRequestSchema.parse(await readBody(request)));
+    fail(404, "Route not found");
+}
+export async function dispatchVault(ctx, scope, method, path, url, request) {
+    const { vault } = ctx;
+    if (scope.kind !== "application") {
+        await vault.reject(path.join("/"));
+        fail(403, "Application credential required");
+    }
+    if (path.length === 2 && method === "POST") {
+        const body = CreateVaultRequestSchema.parse(await readBody(request));
+        return vault.createVault(body);
+    }
+    if (path.length === 2 && method === "GET") {
+        const ownerUserId = url.searchParams.get("ownerUserId") ??
+            fail(400, "ownerUserId is required");
+        return { vaults: await vault.listVaults(ownerUserId) };
+    }
+    const vaultId = path[2];
+    if (!vaultId)
+        fail(404, "Vault not found");
+    if (path.length === 3 && method === "GET")
+        return vault.getVault(vaultId);
+    if (path.length === 3 && method === "DELETE")
+        return vault.deleteVault(vaultId);
+    if (path[3] !== "credentials")
+        fail(404, "Route not found");
+    if (path.length === 4 && method === "POST") {
+        const body = CreateCredentialRequestSchema.parse(await readBody(request));
+        return vault.createCredential(vaultId, body);
+    }
+    if (path.length === 4 && method === "GET")
+        return { credentials: await vault.listCredentials(vaultId) };
+    const credentialId = path[4];
+    if (!credentialId)
+        fail(404, "Credential not found");
+    if (path.length === 5 && method === "GET")
+        return vault.getCredential(vaultId, credentialId);
+    if (path.length === 5 && method === "POST") {
+        const body = RotateCredentialRequestSchema.parse(await readBody(request));
+        return vault.rotateCredential(vaultId, credentialId, body);
+    }
+    if (path.length === 5 && method === "DELETE")
+        return vault.deleteCredential(vaultId, credentialId);
+    fail(404, "Route not found");
+}

package/dist/tenant/routes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Tenant HTTP router: authenticates the bearer token, matches `/v1/...` routes and
+ * delegates to the service modules (commands, actions, sessions, live, routes-tenant). It
+ * maps typed errors to responses and owns no business logic of its own. History, SSE and
+ * executor work streams read Durable Streams (`live.ts`).
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type TenantContext } from "./context.js";
+export declare function handle(ctx: TenantContext, request: IncomingMessage, response: ServerResponse, _url?: URL): Promise<void>;

package/dist/tenant/routes.js

@@ -0,0 +1,142 @@
+import { PutAgentRequestSchema, PutSessionRequestSchema, RegisterExecutorsRequestSchema, SessionCommandSchema, } from "@nylorun/core/contracts";
+import { VaultError } from "../vault/error.js";
+import { SandboxRouteError, handleSessionSandboxTool, } from "../core/sandbox-routes.js";
+import { loadSession, sessionOf } from "./context.js";
+import { HttpError, OpaqueAuthError, fail, readBody, requestAborted, } from "./http.js";
+import { authenticate, requireApplication } from "./auth.js";
+import { command } from "./commands.js";
+import { actionSandboxTool, deleteExecutor, listExecutors, listPendingActions, registerExecutors, sandboxRouteDeps, updateAction, } from "./actions.js";
+import { listDefinitions, listSessions, putDefinition, putSession, sessionView, } from "./sessions.js";
+import { readHistory, requestCursor, streamExecutorWork, streamSessionEvents, } from "./live.js";
+import { dispatchTenant, dispatchVault } from "./routes-tenant.js";
+export async function handle(ctx, request, response, _url) {
+    const json = (value, status = 200) => {
+        const payload = JSON.stringify(value);
+        response.writeHead(status, {
+            "content-type": "application/json",
+            "content-length": Buffer.byteLength(payload),
+        });
+        response.end(payload);
+    };
+    try {
+        const url = _url ?? new URL(request.url ?? "/", "http://runtime");
+        const path = url.pathname
+            .split("/")
+            .filter(Boolean)
+            .map(decodeURIComponent);
+        const method = request.method;
+        const scope = await authenticate(ctx, request);
+        if (path[0] !== "v1")
+            fail(404, "Route not found");
+        if (path[1] === "executors" && path[2] === "connect" && method === "GET") {
+            if (scope.kind !== "executor")
+                return fail(403, "Executor credential required");
+            streamExecutorWork(ctx.live, request, response, scope.executor.tokenHash);
+            return;
+        }
+        if (path[1] === "actions") {
+            if (scope.kind !== "executor")
+                return fail(403, "Executor credential required");
+            if (path.length === 2 && method === "GET")
+                return json(await listPendingActions(ctx, scope.executor));
+            const actionId = path[2];
+            if (!actionId)
+                fail(404, "Action not found");
+            if (method === "POST" &&
+                path[3] === "sandbox" &&
+                path[4] &&
+                path.length === 5)
+                return json(await actionSandboxTool(ctx, scope, actionId, path[4], request));
+            const body = await readBody(request);
+            return json(await updateAction(ctx, scope, actionId, method, path[3], body));
+        }
+        if (path[1] === "sessions" &&
+            path[2] &&
+            path[3] === "commands" &&
+            method === "POST")
+            return json(await command(ctx, path[2], SessionCommandSchema.parse(await readBody(request)), scope));
+        if (path[1] === "vaults")
+            return json(await dispatchVault(ctx, scope, method, path, url, request));
+        if (path[1] === "tenant")
+            return json(await dispatchTenant(ctx, scope, method, path, request));
+        const principalId = requireApplication(scope);
+        if (path[1] === "executors" && path.length === 2 && method === "GET")
+            return json(listExecutors(ctx));
+        // The length guard matters: the connect branch above only matches GET, so without it a
+        // PUT to /v1/executors/connect would register an agent literally named "connect".
+        if (path[1] === "executors" && path.length === 2 && method === "PUT")
+            return json(await registerExecutors(ctx, principalId, RegisterExecutorsRequestSchema.parse(await readBody(request))));
+        if (path[1] === "executors" &&
+            path.length === 3 &&
+            path[2] &&
+            method === "DELETE")
+            return json(await deleteExecutor(ctx, path[2]));
+        if (path[1] === "agents" && path.length === 2 && method === "GET")
+            return json(await listDefinitions(ctx));
+        if (path[1] === "sessions" && path.length === 2 && method === "GET")
+            return json(await listSessions(ctx, url.searchParams.get("agentId")));
+        if (path[1] === "agents" &&
+            path[2] &&
+            path.length === 3 &&
+            method === "PUT")
+            return json(await putDefinition(ctx, path[2], PutAgentRequestSchema.parse(await readBody(request))));
+        if (path[1] === "sessions" && path[2]) {
+            const id = path[2];
+            if (method === "PUT" && path.length === 3) {
+                const body = PutSessionRequestSchema.parse(await readBody(request));
+                const session = await putSession(ctx, id, body);
+                return json(await ctx.store.tx((t) => sessionView(t, session)));
+            }
+            if (method === "GET" && path.length === 3)
+                return json(await ctx.store.tx(async (t) => sessionView(t, await sessionOf(t, id))));
+            // Every other session route needs the session to exist.
+            await loadSession(ctx, id);
+            const cursor = requestCursor(request, url);
+            if (method === "GET" && path[3] === "items")
+                return json(await readHistory(ctx, id, cursor, url.searchParams.get("agent") ?? undefined));
+            if (method === "GET" && path[3] === "events") {
+                await streamSessionEvents(ctx, request, response, id, cursor);
+                return;
+            }
+            if (method === "POST" &&
+                path[3] === "sandbox" &&
+                path[4] &&
+                path.length === 5) {
+                requireApplication(scope);
+                try {
+                    const outcome = await handleSessionSandboxTool(sandboxRouteDeps(ctx), id, path[4], await readBody(request), requestAborted(request));
+                    return json(outcome);
+                }
+                catch (error) {
+                    if (error instanceof SandboxRouteError)
+                        fail(error.status, error.message);
+                    throw error;
+                }
+            }
+        }
+        fail(404, "Route not found");
+    }
+    catch (error) {
+        if (response.headersSent) {
+            response.end();
+            return;
+        }
+        if (error instanceof OpaqueAuthError) {
+            json(error.body, error.status);
+            return;
+        }
+        const status = error instanceof HttpError ||
+            error instanceof VaultError ||
+            error instanceof SandboxRouteError
+            ? error.status
+            : error?.name === "ZodError" ||
+                error?.message === "Invalid cursor"
+                ? 400
+                : 500;
+        json({
+            status: "rejected",
+            code: status === 500 ? "internal_error" : "request_rejected",
+            message: status === 500 ? "Runtime request failed" : error.message,
+        }, status);
+    }
+}

package/dist/tenant/runtime.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Composition root of an open Tenant: validates the config, opens the Session Store and the
+ * vault key, builds the services and the `TenantContext`, wires the seams, registers the
+ * Tenant's Worker handlers and arms its sweep, and implements `TenantHandle` (handle,
+ * summary, drain, close) by delegating to the Tenant modules.
+ *
+ * Seams wired here: `wireStreams()` connects the store's commits to Durable Streams (the
+ * relay, and the history, SSE, work and control readers); `wake` goes to the
+ * `DurableExecution`, whose handlers (`worker.ts`) call `advance` and `sweep`; `abortLocal`
+ * aborts an advance running on this process. The sweep also drains the outbox.
+ *
+ * Execution: the Host passes one `TenantExecution` for every Tenant it opens
+ * (`TenantOpenHooks.execution`); without one, the Tenant runs its own in-process
+ * `MemoryExecution`. No lock file: several processes may open a Tenant, and ownership of each
+ * session (§10.6) keeps its advances apart.
+ */
+import type { ServerResponse, IncomingMessage } from "node:http";
+import type { TenantEnvelope } from "@nylorun/core/contracts";
+import { type ModelProvider } from "../core/provider.js";
+import { type AuthorizeResult } from "../vault/service.js";
+import type { DurableStreams } from "../streams/types.js";
+import type { OpenedTenant, TenantConfig, TenantHandle, TenantSummary } from "./types.js";
+import { type StreamsStatus } from "./streams.js";
+import { type TenantExecution, type TenantWorker } from "./worker.js";
+/** TENANTS-CCR: test/injection hooks until TenantConfig gains them. */
+export type TenantOpenHooks = {
+    modelProvider?: ModelProvider;
+    vaultKek?: Buffer | string | null;
+    /** When true, create the KEK file on first vault write (tests / new Tenants). */
+    createKekIfMissing?: boolean;
+    /**
+     * The Host's Durable Session Execution and the registry its handlers dispatch through.
+     * The Host starts it; the Tenant registers its worker and arms its sweep. Without one,
+     * the Tenant starts and stops its own in-process `MemoryExecution`.
+     */
+    execution?: TenantExecution;
+    /** The Worker id written as session owner. Defaults to this process's `WORKER_ID`. */
+    workerId?: string;
+    /**
+     * Durable Streams for this Tenant, owned by the caller (the Host's S2 streams). Without
+     * them the Tenant creates its own in-process `MemoryStreams`, whose history does not
+     * survive a restart (tests, and a Host without S2).
+     */
+    streams?: DurableStreams;
+} & OpenedTenant;
+export declare class TenantRuntime implements TenantHandle {
+    private readonly ctx;
+    readonly envelope: TenantEnvelope;
+    /** This Tenant's Worker handlers, as registered with the execution. */
+    readonly worker: TenantWorker;
+    private readonly detach;
+    /** How long close waits for running advances: the execution's advance grace period. */
+    private readonly closeGraceMs;
+    private constructor();
+    static open(config: TenantConfig, hooks: TenantOpenHooks): Promise<TenantRuntime>;
+    handle(request: IncomingMessage, response: ServerResponse, url?: URL): Promise<void>;
+    authorize(sessionId: string, request: {
+        url: string;
+        serverName?: string;
+    }): Promise<AuthorizeResult>;
+    summary(): Promise<TenantSummary>;
+    drain(activeWork: "drain" | "cancel", timeoutMs?: number): Promise<void>;
+    /**
+     * 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: string): void;
+    /**
+     * 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(): Promise<StreamsStatus>;
+    /** Adds a callback to the Tenant sweep. Returns a function that removes it. */
+    onSweep(hook: () => Promise<void>): () => void;
+    close(): Promise<void>;
+}
+/**
+ * Open a Tenant Runtime from an explicit `TenantConfig`. No listen() (A1).
+ * Implements `OpenTenantRuntime`.
+ */
+export declare function openTenantRuntime(config: TenantConfig, hooks: TenantOpenHooks): Promise<TenantHandle>;