@nylorun/runtime 0.15.2-beta → 0.17.0-beta

package/dist/host/main.js

@@ -9,14 +9,19 @@
  * Execution and Durable Streams from the endpoints; `createHostExecution`
  * builds the process's execution; the Host serves the one Tenant its Postgres
  * database holds (`NYLORUN_DATABASE_URL`, required), and creates it there on
- * first start (`NYLORUN_TENANT_ID`, `NYLORUN_TENANT_NAME`,
- * `NYLORUN_DERIVED_PRINCIPALS`; tenancy.md §4); with S2, a process running core
+ * first start (`NYLORUN_TENANT_ID`, `NYLORUN_TENANT_NAME`; tenancy.md §4), trusting the issuers of the identity file
+ * `NYLORUN_IDENTITY_FILE` names (Host feature `trusted-issuers`); with S2, a process running core
  * runs the stream relay, which feeds the Tenant's streams from the record over
  * logical replication (one process at a time holds the slot); `/ready` reports
- * the Tenant and the infrastructure checks. A process running the gates service (the local
- * stack's `gateway` container) starts only the gate (`runGates`): it needs
- * neither host.json nor host-credentials.json. See the startup order in `main()`. Tests compose a Host without this
- * entry, with `createHost` and an injected Tenant module.
+ * the Tenant and the infrastructure checks. With an Object store
+ * (`NYLORUN_OBJECT_STORE_*`) the Tenant's blobs go to it through the `s3` BlobStore, and a
+ * process running core creates its bucket; without one they stay on disk (`fs`). A process
+ * running the gates service (the local stack's `gateway` container) starts only the gate, and egress-gate with `egress` (`runGates`): it needs
+ * neither host.json nor host-credentials.json, and reads the files a prompt names from the Object store. A process running the harness service (`--service harness`, F6.2)
+ * starts only the harness (`harness/main.ts`), which connects to core's Harness API. With `NYLORUN_HARNESS=remote`
+ * the Tenant runs no harness of its own: core starts the Harness API listener (`NYLORUN_HARNESS_LISTEN_*`) and
+ * harnesses that present `NYLORUN_HARNESS_TOKEN` run its segments and hold its workspaces. See the startup order
+ * in `main()`. Tests compose a Host without this entry, with `createHost` and an injected Tenant module.
  */
 import { readFileSync, mkdirSync, existsSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -24,6 +29,8 @@ import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { hostPaths } from "../tenant/paths.js";
 import { createTenantModule } from "../tenant/module.js";
+import { parseIdentityFile } from "../tenant/identity-file.js";
+import { createTrustedIssuers } from "../tenant/issuers.js";
 import { hostPrincipals } from "../tenant/principals.js";
 import { createPostgresTenantOpener } from "../tenant/store-pg.js";
 import { openTenantRuntime } from "../tenant/runtime.js";
@@ -40,10 +47,15 @@ import { createHostLogger } from "./logger.js";
 import { describeEndpoints, describeServices, parseStackConfig, } from "./stack-config.js";
 import { createExecution, createInfra } from "../infra/index.js";
 import { createDatabase } from "../infra/database.js";
-import { startGates } from "./gates.js";
+import { startEgress, startGates } from "./gates.js";
 import { httpToolGate } from "../gates/tool-client.js";
 import { httpKeys } from "../keys/client.js";
 import { httpModelGate } from "../gates/http-client.js";
+import { createS3BlobStore } from "../blob/index.js";
+import { createRunGrants } from "../tenant/run-grants.js";
+import { runHarness } from "../harness/main.js";
+import { startHarnessListener } from "../harness-api/ws-server.js";
+import { httpSandboxesClient } from "../sandbox/pods/client.js";
 const nodeRequire = createRequire(import.meta.url);
 function coreVersion() {
     try {
@@ -56,43 +68,107 @@ function coreVersion() {
 function loadJson(path) {
     return JSON.parse(readFileSync(path, "utf8"));
 }
+/**
+ * The trusted issuers of the identity file (`NYLORUN_IDENTITY_FILE`, Host feature
+ * `trusted-issuers`). A missing or malformed file stops the boot, naming the issuer and field;
+ * an issuer's JWKS is fetched only when a token needs it, so one that is down does not.
+ */
+function loadIssuers(path) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        throw new Error(`NYLORUN_IDENTITY_FILE names ${path}, which cannot be read: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return createTrustedIssuers(parseIdentityFile(text, path));
+}
 function resolveHostRoot() {
     const fromEnv = process.env.NYLORUN_HOME;
     const root = fromEnv && fromEnv.length > 0 ? fromEnv : resolve(homedir(), ".nylorun");
     return resolve(root);
 }
+/** The Object store's `s3` BlobStore (D35), from `StackConfig.objectStore`. */
+function objectStore(config) {
+    return createS3BlobStore({
+        endpoint: config.endpoint,
+        bucket: config.bucket,
+        region: config.region,
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+    });
+}
+/**
+ * Creates the Object store's bucket unless it exists, retrying while the store starts. In the
+ * background: only artifacts use the store, so a store that stays down is logged (artifact
+ * uploads and downloads fail meanwhile) and does not hold up the Host.
+ */
+async function ensureBucket(store, bucket, logger) {
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            await store.ensureBucket();
+            logger.info("object_store_ready", { bucket });
+            return;
+        }
+        catch (error) {
+            if (attempt >= 10) {
+                logger.error("object_store_unavailable", {
+                    bucket,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, Math.min(1000 * attempt, 5000)));
+        }
+    }
+}
 /** The slot's lag in WAL bytes, when the source can tell. */
 async function lagOf(source) {
     const lagBytes = await source.lag?.().catch(() => undefined);
     return lagBytes === undefined ? {} : { lagBytes };
 }
 /**
- * The gates service: the Model Gate's listener over the Postgres pool and the Host's tenant
- * directory. Writes nothing to the Host root (the local stack mounts it read-only).
+ * The gateway's services: the Model Gate's listener (gates, keys) and egress-gate's (egress), over
+ * the Postgres pool and the Host's tenant directory. Writes nothing to the Host root (the local
+ * stack mounts it read-only).
  */
 async function runGates(stack) {
-    const gates = stack.gates;
     if (!stack.endpoints.databaseUrl)
-        throw new Error("NYLORUN_DATABASE_URL is required for --service gates: the gate reads Tenant vaults from Postgres (`nylorun start` sets it)");
+        throw new Error(`NYLORUN_DATABASE_URL is required for --service ${describeServices(stack.services)}: the gateway reads the Tenant from Postgres (\`nylorun start\` sets it)`);
     const logger = createHostLogger();
     logger.info("host_stack_config", {
         services: [...stack.services],
         ...(stack.packing ? { packing: stack.packing } : {}),
         endpoints: describeEndpoints(stack.endpoints),
+        objectStore: stack.objectStore ? "s3" : "none",
+        // Never the resolver's URL or token: only whether one is set (F9 C1).
+        resolver: stack.gates?.resolver ? "configured" : "none",
     });
     const database = createDatabase(stack);
-    let server;
+    const servers = [];
     try {
-        server = await startGates({
-            gates,
-            database,
-            hostRoot: resolveHostRoot(),
-            logger,
-            ...(stack.delivery ? { delivery: stack.delivery } : {}),
-            ...(stack.services.has("keys") ? { keys: true } : {}),
-        });
+        if (stack.gates) {
+            const server = await startGates({
+                gates: stack.gates,
+                database,
+                hostRoot: resolveHostRoot(),
+                logger,
+                ...(stack.delivery ? { delivery: stack.delivery } : {}),
+                ...(stack.services.has("keys") ? { keys: true } : {}),
+                // Model-gate reads the files a prompt names from the Object store (protocol 6).
+                ...(stack.objectStore ? { blobs: objectStore(stack.objectStore) } : {}),
+            });
+            servers.push(server);
+            logger.info("gates_ready", { url: server.url });
+        }
+        if (stack.egress) {
+            const egress = await startEgress({ egress: stack.egress, database, hostRoot: resolveHostRoot(), logger });
+            servers.push(egress);
+            logger.info("egress_ready", { url: egress.url });
+        }
     }
     catch (error) {
+        await Promise.all(servers.map((server) => server.close()));
         await database.end({ timeout: 5 });
         if (error instanceof HostListenError) {
             logger.error("listen_failed", { message: error.message, exitCode: error.exitCode });
@@ -101,23 +177,23 @@ async function runGates(stack) {
         }
         throw error;
     }
-    logger.info("gates_ready", { url: server.url });
     let stopping = false;
     for (const signal of ["SIGINT", "SIGTERM"])
         process.on(signal, () => {
             if (stopping)
                 return;
             stopping = true;
-            void server
-                .close()
+            void Promise.all(servers.map((server) => server.close()))
                 .then(() => database.end({ timeout: 5 }))
                 .finally(() => process.exit(0));
         });
 }
 export async function main() {
     const stack = parseStackConfig(process.env, process.argv.slice(2));
-    if (stack.services.has("gates") || stack.services.has("keys"))
+    if (stack.services.has("gates") || stack.services.has("keys") || stack.services.has("egress"))
         return runGates(stack);
+    if (stack.services.has("harness"))
+        return runHarness(stack, baselineEnvironment(process.env));
     const hostRoot = resolveHostRoot();
     const paths = hostPaths(hostRoot);
     mkdirSync(paths.home, { recursive: true });
@@ -138,7 +214,14 @@ export async function main() {
     }
     const config = loadJson(paths.config);
     const credentials = loadJson(paths.credentials);
+    const identityFile = stack.tenant?.identityFile;
+    const issuers = identityFile ? loadIssuers(identityFile) : undefined;
     const logger = createHostLogger();
+    if (issuers)
+        logger.info("trusted_issuers", {
+            file: identityFile,
+            issuers: issuers.issuers.map((issuer) => issuer.config.name),
+        });
     if (stack.deprecatedRole)
         logger.warn("deprecated_flag", {
             flag: "--role",
@@ -150,8 +233,10 @@ export async function main() {
         ...(stack.services.has("loop")
             ? { modelGate: stack.modelGate ? stack.modelGate.url : "in-process" }
             : {}),
+        harness: stack.harnessMode ?? "in-process",
         mode: stack.listen ? "container" : "local",
         endpoints: describeEndpoints(stack.endpoints),
+        objectStore: stack.objectStore ? "s3" : "fs",
     });
     const infra = createInfra(stack, { logger });
     const database = infra.database;
@@ -166,6 +251,8 @@ export async function main() {
         logger,
         baseline,
         ...(stack.delivery ? { delivery: stack.delivery } : {}),
+        ...(issuers ? { issuers } : {}),
+        ...(stack.publicUrl ? { publicUrl: stack.publicUrl } : {}),
     });
     // The process's Durable Session Execution: Restate when its endpoints are set, else the
     // in-process memory execution. An invocation that arrives while the Tenant opens waits for it.
@@ -206,16 +293,32 @@ export async function main() {
     };
     // With the gates service the Tenant's vault-backed model calls, remote MCP calls and Action
     // deliveries cross it, and this process never reads a model or MCP credential.
-    const modelGate = stack.modelGate
-        ? httpModelGate({ url: stack.modelGate.url, token: stack.modelGate.token })
+    // Their credentials (F5): each advance's run token for its session's model and MCP calls,
+    // core's credential (NYLORUN_GATES_TOKEN) for deliveries and MCP requests outside a run.
+    const runGrants = stack.modelGate ? createRunGrants() : undefined;
+    const modelGate = stack.modelGate && runGrants
+        ? httpModelGate({ url: stack.modelGate.url, runTokens: runGrants })
         : undefined;
-    const toolGate = stack.modelGate
-        ? httpToolGate({ url: stack.modelGate.url, token: stack.modelGate.token })
+    const toolGate = stack.modelGate && runGrants
+        ? httpToolGate({ url: stack.modelGate.url, token: stack.modelGate.token, runTokens: runGrants })
         : undefined;
     // With the keys service, vault writes and token signing cross it, and this process never
     // reads the vault key (F4.2).
     const keys = stack.keys ? httpKeys({ url: stack.keys.url, token: stack.keys.token }) : undefined;
-    const tenantSettings = stack.tenant ?? { name: "default", derivedPrincipals: ["project"] };
+    // The Object store (D35): the stack's S3 server through the BlobStore seam, handed to the
+    // Tenant (`TenantContext.blobs`). Without one the Tenant keeps blobs on disk. core creates
+    // the bucket.
+    const blobs = stack.objectStore ? objectStore(stack.objectStore) : undefined;
+    if (blobs && stack.services.has("core"))
+        void ensureBucket(blobs, stack.objectStore.bucket, logger);
+    // Sandbox pods (F7.2): the sandboxes service, which alone holds the cluster's credentials.
+    const pods = stack.sandboxes
+        ? {
+            client: httpSandboxesClient({ url: stack.sandboxes.url, token: stack.sandboxes.token }),
+            harnessImage: stack.sandboxes.harnessImage,
+        }
+        : undefined;
+    const tenantSettings = stack.tenant ?? { name: "default" };
     const module = createTenantModule({
         open: createPostgresTenantOpener({
             hostRoot,
@@ -223,10 +326,7 @@ export async function main() {
             create: {
                 ...(tenantSettings.id ? { tenantId: tenantSettings.id } : {}),
                 name: tenantSettings.name,
-                principals: hostPrincipals({
-                    adminKey: credentials.adminKey,
-                    derived: tenantSettings.derivedPrincipals,
-                }),
+                principals: hostPrincipals({ adminKey: credentials.adminKey }),
             },
             configFor,
             logger,
@@ -234,8 +334,12 @@ export async function main() {
                 execution: hostExecution.tenantExecution,
                 ...(modelGate ? { modelGate } : {}),
                 ...(toolGate ? { toolGate } : {}),
+                ...(runGrants ? { runGrants } : {}),
                 ...(keys ? { keys } : {}),
                 ...(streams ? { streams, hostRelay: true } : {}),
+                ...(blobs ? { blobs } : {}),
+                ...(stack.harnessMode === "remote" ? { harness: "remote" } : {}),
+                ...(pods ? { pods } : {}),
                 ...opened,
             }),
         }),
@@ -256,9 +360,6 @@ export async function main() {
         coreVersion: coreVersion(),
         ...(stack.listen ? { listen: stack.listen } : {}),
         ...(stack.publicUrl ? { publicUrl: stack.publicUrl } : {}),
-        // Container mode (the local stack) allows browsers unless told not to; a Host started
-        // from host.json only when it says so. Without publishable keys nothing is reachable.
-        browserAccess: stack.browserAccess ?? (stack.listen ? true : config.browserAccess === true),
         // The Admin API on its own listener: from the container environment, or from host.json
         // (loopback, on the same host) when the Host runs outside a container.
         ...(stack.operator
@@ -273,8 +374,12 @@ export async function main() {
             beforeTenants: async () => {
                 await hostExecution.stop();
                 await relay?.stop();
+                // The harnesses' runs stop with the Tenant's advances; their connections close after.
+            },
+            afterTenants: async () => {
+                await harnessListener?.close();
+                await infra.close();
             },
-            afterTenants: () => infra.close(),
         },
     };
     const host = createHost(options);
@@ -289,11 +394,35 @@ export async function main() {
     // Restate's state (§14.8), and starts the stream relay. A Tenant that cannot
     // be opened leaves the Host listening but not ready, with the cause in
     // `/v1/admin/status`.
+    // The Harness API listener (NYLORUN_HARNESS=remote): only harnesses connect here, with the
+    // harness credential, and only while the Tenant is open.
+    let harnessListener;
     try {
         await hostExecution.start();
+        if (stack.harnessListener)
+            harnessListener = await startHarnessListener({
+                ...stack.harnessListener.listen,
+                ...(stack.harnessListener.token ? { token: stack.harnessListener.token } : {}),
+                // Sandbox pods join here and connect with host tokens (F7.2).
+                ...(pods
+                    ? {
+                        hosts: async () => {
+                            const resolved = await module.resolve();
+                            return resolved.kind === "open" ? resolved.handle.hostAuthority?.() : undefined;
+                        },
+                    }
+                    : {}),
+                attach: async () => {
+                    const resolved = await module.resolve();
+                    const handle = resolved.kind === "open" ? resolved.handle : undefined;
+                    return handle?.attachHarness ? (channel, peer) => handle.attachHarness(channel, peer) : undefined;
+                },
+                logger,
+            });
         await host.listen();
     }
     catch (error) {
+        await harnessListener?.close().catch(() => undefined);
         await hostExecution.stop().catch(() => undefined);
         await module.close().catch(() => undefined);
         await relay?.stop().catch(() => undefined);
@@ -311,6 +440,7 @@ export async function main() {
     const tenant = module.tenant();
     logger.info("host_ready", {
         url: host.url,
+        ...(harnessListener ? { harness: harnessListener.url } : {}),
         hostId: config.hostId,
         tenantId: tenant.id,
         tenant: tenant.state,

package/dist/host/stack-config.d.ts

@@ -1,9 +1,16 @@
+import { type BlockedAddress } from "../sandbox/pods/network-gate.js";
 /** A Runtime service this release has. */
-export type RuntimeService = "core" | "loop" | "gates" | "keys";
+export type RuntimeService = "core" | "loop" | "gates" | "keys" | "egress" | "harness";
 export type RuntimeServices = ReadonlySet<RuntimeService>;
 export declare const RUNTIME_SERVICES: readonly RuntimeService[];
 /** Where the gates service listens by default. */
 export declare const DEFAULT_GATES_LISTEN_PORT = 4100;
+/** Where egress-gate listens by default. */
+export declare const DEFAULT_EGRESS_LISTEN_PORT = 4200;
+/** Where core's Harness API listener listens by default. */
+export declare const DEFAULT_HARNESS_LISTEN_PORT = 4200;
+/** Where a harness process answers `/health` (loopback only). */
+export declare const DEFAULT_HARNESS_HEALTH_PORT = 4300;
 /** What a process runs without `--service`: core and loop, as `--role all` did. */
 export declare const DEFAULT_SERVICES: RuntimeServices;
 /** The deprecated `--role` values, and the services each stands for. */
@@ -47,17 +54,99 @@ export interface GatesConfig {
     listen: ContainerListen;
     /** `NYLORUN_GATES_TOKEN`: the bearer the loop presents; at least 32 bytes as hex. */
     token: string;
+    /**
+     * The operator's credential resolver (`NYLORUN_RESOLVER_URL`, `NYLORUN_RESOLVER_TOKEN`), asked
+     * for a person's MCP credential when the session's vaults hold none (F9 C1). Absent: vaults only.
+     */
+    resolver?: {
+        url: string;
+        token: string;
+    };
+}
+/** egress-gate's listener (`NYLORUN_EGRESS_LISTEN_HOST`, `NYLORUN_EGRESS_LISTEN_PORT`). */
+export interface EgressConfig {
+    listen: {
+        host: string;
+        port: number;
+    };
 }
 /** Where the loop reaches the gates service (`NYLORUN_GATES_URL`, `NYLORUN_GATES_TOKEN`). */
 export interface ModelGateEndpoint {
     url: string;
     token: string;
 }
+/**
+ * Core's Harness API listener (`NYLORUN_HARNESS=remote`, or sandbox pods): where harnesses
+ * connect, and the credential they present (`NYLORUN_HARNESS_TOKEN`), which nothing else
+ * accepts. With sandbox pods and no harness container there is no token: only pods' host tokens
+ * are accepted (F7.2).
+ */
+export interface HarnessListenConfig {
+    listen: ContainerListen;
+    token?: string;
+}
+/**
+ * Sandbox pods (`NYLORUN_SANDBOXES_URL`, F7.2): the sandboxes service core drives them with, its
+ * token, and the Runtime image pods copy the engine from.
+ */
+export interface SandboxesConfig {
+    url: string;
+    token: string;
+    /** `NYLORUN_SANDBOX_HARNESS_IMAGE` (the stack sets it to the Runtime image). */
+    harnessImage: string;
+}
+/**
+ * The engine in a pod sandbox (`--service harness` with `NYLORUN_SANDBOX_KIND=pod`, F7.2): no
+ * harness token; it joins with the join token mounted in the pod.
+ */
+export interface PodHostConfig {
+    /** `NYLORUN_SANDBOX_ID`. */
+    sandboxId: string;
+    /** `NYLORUN_POD_UID` (the downward API's `metadata.uid`). */
+    podUid: string;
+    /** `NYLORUN_SANDBOX_JOIN_FILE`. */
+    joinFile: string;
+    /** The Harness API listener's HTTP base, for `host/join` and `host/renew`. */
+    httpUrl: string;
+    /** `NYLORUN_EGRESS_PROXY`: egress-gate's address, or undefined while it is not published. */
+    egressProxy?: string;
+    /** Addresses the pod's NetworkPolicy must block, probed before the engine starts. */
+    blocked: BlockedAddress[];
+}
+/** A harness process (`--service harness`). */
+export interface HarnessServiceConfig {
+    /** `NYLORUN_HARNESS_URL`: core's Harness API, e.g. `ws://runtime:4200/nylorun/harness/v1`. */
+    url: string;
+    /** `NYLORUN_HARNESS_TOKEN`; absent for a pod's engine, which joins (`pod`). */
+    token?: string;
+    /** Present for the engine in a pod sandbox. */
+    pod?: PodHostConfig;
+    /** `NYLORUN_GATES_URL`: the gates service its model and MCP calls cross, with run tokens. */
+    gatesUrl: string;
+    /** `NYLORUN_HARNESS_ROOT`: its sandboxes, plugin data, home and tmp. Default `/harness`. */
+    root: string;
+    /** `/health` on `127.0.0.1:<NYLORUN_HARNESS_HEALTH_PORT>` (default 4300). */
+    healthPort: number;
+}
 export interface StackConfig {
     /** The Runtime services this process runs. */
     services: RuntimeServices;
     /** Present when the process runs gates. */
     gates?: GatesConfig;
+    /** Present when the process runs egress. */
+    egress?: EgressConfig;
+    /** Present when the process runs the harness service (`--service harness`). */
+    harness?: HarnessServiceConfig;
+    /**
+     * `NYLORUN_HARNESS` (`in-process` or `remote`; absent means `in-process`), for a process running
+     * core or loop: whether the Tenant runs its own harness, or harnesses connect to
+     * `harnessListener`.
+     */
+    harnessMode?: "in-process" | "remote";
+    /** Present when `harnessMode` is `remote`, or with `sandboxes`: core's Harness API listener. */
+    harnessListener?: HarnessListenConfig;
+    /** Present when the process runs core or loop and `NYLORUN_SANDBOXES_URL` is set (F7.2). */
+    sandboxes?: SandboxesConfig;
     /**
      * Present when the process runs core or loop and `NYLORUN_GATES_URL` is set: its model calls,
      * remote MCP calls and Action deliveries cross the gates service. Required for loop in
@@ -88,11 +177,6 @@ export interface StackConfig {
      * means nothing outside the container.
      */
     publicUrl?: string;
-    /**
-     * `NYLORUN_BROWSER_ACCESS` (`on` or `off`): whether browser requests may reach Tenant
-     * routes. Absent means the Host's default (on in container mode).
-     */
-    browserAccess?: boolean;
     /**
      * The operator listener in container mode (`NYLORUN_ADMIN_LISTEN_PORT`, `…_HOST`,
      * `…_ALLOWED_HOSTS`). Absent: one listener serves the Admin API and the Tenant API.
@@ -110,6 +194,25 @@ export interface StackConfig {
     };
     /** Present when the process runs core or loop: who its Tenant is on first start. */
     tenant?: TenantSettings;
+    /**
+     * The Object store (blueprint D35) behind the `BlobStore` seam's `s3` adapter, from
+     * `NYLORUN_OBJECT_STORE_*`; the local stack's RustFS. Absent: the Tenant keeps blobs on disk
+     * (the `fs` adapter, `TenantPaths.blobs`).
+     */
+    objectStore?: ObjectStoreConfig;
+}
+/** Where the Object store is and the credential for it (`NYLORUN_OBJECT_STORE_*`). */
+export interface ObjectStoreConfig {
+    /** `NYLORUN_OBJECT_STORE_ENDPOINT`: the S3 endpoint, e.g. `http://rustfs:9000`. */
+    endpoint: string;
+    /** `NYLORUN_OBJECT_STORE_BUCKET`. Default `nylorun`. */
+    bucket: string;
+    /** `NYLORUN_OBJECT_STORE_REGION`. Default `us-east-1`. */
+    region: string;
+    /** `NYLORUN_OBJECT_STORE_ACCESS_KEY`. */
+    accessKeyId: string;
+    /** `NYLORUN_OBJECT_STORE_SECRET_KEY`. */
+    secretAccessKey: string;
 }
 /**
  * The Tenant a Host creates when its database holds none (tenancy.md §4). Later starts open the
@@ -121,10 +224,10 @@ export interface TenantSettings {
     /** `NYLORUN_TENANT_NAME`. Default `default`. */
     name: string;
     /**
-     * `NYLORUN_DERIVED_PRINCIPALS`: comma-separated application principals whose keys the admin
-     * key derives (`deriveTenantKey`). Default `project`.
+     * `NYLORUN_IDENTITY_FILE`: the identity file listing the trusted issuers (Host feature
+     * `trusted-issuers`), read once at boot (`host/main.ts`). Absent: no issuer is trusted.
      */
-    derivedPrincipals: readonly string[];
+    identityFile?: string;
 }
 export declare class StackConfigError extends Error {
     constructor(message: string);