@nylorun/runtime 0.26.0-beta → 0.27.0-beta

package/dist/traces/projector.js

@@ -1,13 +1,15 @@
 import { spanOf, turnTraceOf } from "./map.js";
+import { hostTuning } from "../tuning.js";
 /** The projector's replication slot. */
 export const TRACE_SLOT = "nylorun_trace_export";
 export function createTraceProjector(options) {
     const { source, post } = options;
     const log = options.log ?? (() => { });
-    const maxBatch = options.maxBatch ?? 512;
-    const maxDelayMs = options.maxDelayMs ?? 2000;
-    const maxQueued = options.maxQueuedSpans ?? 8192;
-    const cacheSize = options.turnCacheSize ?? 1024;
+    const tuning = hostTuning().traces;
+    const maxBatch = options.maxBatch ?? tuning.batchSpans;
+    const maxDelayMs = options.maxDelayMs ?? tuning.batchDelayMs;
+    const maxQueued = options.maxQueuedSpans ?? tuning.queuedSpansMax;
+    const cacheSize = options.turnCacheSize ?? tuning.turnCacheSize;
     const turns = new Map();
     const stopping = new AbortController();
     /** Mapped transactions not yet posted, in commit order. */
@@ -17,6 +19,8 @@ export function createTraceProjector(options) {
     let mapping = Promise.resolve();
     let mappingCount = 0;
     let posting;
+    /** Transactions of the batch being posted: not acknowledged until the post settles. */
+    let postingTxs = 0;
     let timer;
     let active = false;
     let confirmed = null;
@@ -45,7 +49,7 @@ export function createTraceProjector(options) {
         const spans = [];
         if (tx.rows.length === 0)
             return spans;
-        const settings = { key: await options.key(), content: options.content };
+        const settings = { key: await options.key(), content: options.content, contentBytes: await options.contentBytes() };
         for (const record of tx.rows) {
             const row = record.body;
             if (!row || typeof row !== "object" || row.turnId == null)
@@ -72,7 +76,7 @@ export function createTraceProjector(options) {
                         if (of !== activation || stopping.signal.aborted)
                             return;
                         log("trace_projector_retry", { message: error instanceof Error ? error.message : String(error) });
-                        await new Promise((resolve) => setTimeout(resolve, 1000));
+                        await new Promise((resolve) => setTimeout(resolve, tuning.retryMs));
                     }
                 }
                 if (of !== activation)
@@ -115,6 +119,7 @@ export function createTraceProjector(options) {
         const batch = waiting;
         waiting = [];
         waitingSpans = 0;
+        postingTxs = batch.length;
         posting = (async () => {
             const spans = batch.flatMap((tx) => tx.spans);
             // A post a shutdown cut short is not the collector's failure: those rows go again.
@@ -129,6 +134,7 @@ export function createTraceProjector(options) {
             }
         })().finally(() => {
             posting = undefined;
+            postingTxs = 0;
             schedule();
             settle();
         });
@@ -186,7 +192,7 @@ export function createTraceProjector(options) {
         },
         status: () => ({
             active,
-            pendingTxs: waiting.length + mappingCount,
+            pendingTxs: waiting.length + mappingCount + postingTxs,
             pendingSpans: waitingSpans,
             confirmed,
         }),

package/dist/traces/read.js

@@ -1,9 +1,14 @@
 import { traceKey } from "./key.js";
+import { readRuntimeLimits } from "../tenant/runtime-limits.js";
 import { spanOf, turnTraceOf } from "./map.js";
 import { DEFAULT_SERVICE_NAME, resourceSpans } from "./otlp.js";
 /** Turn `turnId`'s spans as an OTLP `ExportTraceServiceRequest`, from its rows in log order. */
 export async function turnTrace(ctx, sessionId, turnId, events) {
-    const settings = { key: await traceKey(ctx.store), content: ctx.traces?.content ?? new Set() };
+    const settings = {
+        key: await traceKey(ctx.store),
+        content: ctx.traces?.content ?? new Set(),
+        contentBytes: (await ctx.store.tx((t) => readRuntimeLimits(t))).traceContentBytes,
+    };
     const message = events.find((event) => event.type === "command.message");
     const turn = turnTraceOf(settings, { tenantId: ctx.store.tenantId, sessionId, turnId }, message);
     const spans = [];

package/dist/tuning.d.ts

@@ -0,0 +1,383 @@
+/**
+ * Host tuning (B15): the timings, retries, poll intervals and internal sizes of the Runtime's
+ * processes, one typed schema with a default each. An operator sets any of them in
+ * `NYLORUN_TUNING`, a JSON object of the groups below (`{"tenant":{"openTimeoutMs":60000}}`),
+ * read once when a process starts (`parseStackConfig`, then `useHostTuning` in `host/main.ts`).
+ * What is left out keeps its default, which is the value the Runtime used before it was
+ * configuration. An unknown key, or a value past its ceiling, stops the process naming it.
+ *
+ * Every service reads the parts it uses: the gateway (`gates`, `keys`, `egress`), core and loop
+ * (the rest), a harness container or a pod's engine (`harness`, `engine`). Core hands a pod
+ * sandbox's engine the `harness` and `engine` groups the operator set (`podTuningEnv`), so a pod
+ * runs with the timings of the Runtime that started it.
+ *
+ * Tenant-facing limits (sizes a client meets, request and turn deadlines) are not here: they are
+ * Runtime limits and Tenant settings. `engine` is our harness's own configuration: the options
+ * of `createHarness` in `@nylorun/harness`, whose defaults stay there.
+ */
+import { z } from "zod";
+/**
+ * The longest delay Node's timers take (`setTimeout`, `setInterval`): 2^31 - 1 ms, a signed
+ * 32-bit integer. A longer one fires at once. Fixed by the platform, so a ceiling, not a setting.
+ */
+export declare const MAX_TIMER_MS: number;
+/** S3's smallest multipart part but the last (5 MiB), and its largest part (5 GiB). */
+export declare const S3_MIN_PART_BYTES: number;
+export declare const S3_MAX_PART_BYTES: number;
+/**
+ * How long a wake's dedupe key merges repeated wakes, at least (Durable Session Execution
+ * §12.3): a wake sent again within a day must not start a second advance. A floor of the
+ * design, so a setting may only raise it.
+ */
+export declare const DEDUPE_RETENTION_MIN_MS: number;
+/** The longest `?wait=` the sandboxes service takes (`MaxWait` in its API): a dependency's ceiling. */
+export declare const SANDBOXES_MAX_WAIT_MS = 30000;
+/**
+ * The most bind parameters one Postgres statement takes: the extended protocol's `Bind` message
+ * counts them in a 16-bit integer. A dependency's ceiling.
+ */
+export declare const POSTGRES_MAX_PARAMETERS = 65535;
+/** The most records, and bytes, one S2 append takes and one S2 read returns: S2's ceilings. */
+export declare const S2_BATCH_MAX_RECORDS = 1000;
+export declare const S2_BATCH_MAX_BYTES: number;
+export declare const HostTuningSchema: z.ZodObject<{
+    keys: z.ZodPrefault<z.ZodObject<{
+        bodyBytes: z.ZodDefault<z.ZodNumber>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        leafBackdateMs: z.ZodDefault<z.ZodNumber>;
+        leafLifetimeMs: z.ZodDefault<z.ZodNumber>;
+        caBackdateMs: z.ZodDefault<z.ZodNumber>;
+        caLifetimeDays: z.ZodDefault<z.ZodNumber>;
+        tokenTtlMaxSeconds: z.ZodDefault<z.ZodNumber>;
+        runTokenTtlSeconds: z.ZodDefault<z.ZodNumber>;
+        runTokenRenewSeconds: z.ZodDefault<z.ZodNumber>;
+        hostTokenTtlSeconds: z.ZodDefault<z.ZodNumber>;
+        tokenLifetimeSlackSeconds: z.ZodDefault<z.ZodNumber>;
+        clockToleranceSeconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    harnessApi: z.ZodPrefault<z.ZodObject<{
+        joinBodyBytes: z.ZodDefault<z.ZodNumber>;
+        reportBodyBytes: z.ZodDefault<z.ZodNumber>;
+        closeGraceMs: z.ZodDefault<z.ZodNumber>;
+        offerWaitMs: z.ZodDefault<z.ZodNumber>;
+        podOfferWaitMs: z.ZodDefault<z.ZodNumber>;
+        loopbackConnectTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        loopbackBackoff: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        rolloverSteps: z.ZodDefault<z.ZodNumber>;
+        rolloverMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    api: z.ZodPrefault<z.ZodObject<{
+        agUiHeartbeatMs: z.ZodDefault<z.ZodNumber>;
+        eventStreamKeepaliveMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    host: z.ZodPrefault<z.ZodObject<{
+        shutdownGraceMs: z.ZodDefault<z.ZodNumber>;
+        readinessTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        operateReadyTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        credentialLockPollMs: z.ZodDefault<z.ZodNumber>;
+        credentialLockAttempts: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    objectStore: z.ZodPrefault<z.ZodObject<{
+        partSizeBytes: z.ZodDefault<z.ZodNumber>;
+        attempts: z.ZodDefault<z.ZodNumber>;
+        retryBaseMs: z.ZodDefault<z.ZodNumber>;
+        bucketRetry: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        bucketAttempts: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    tenant: z.ZodPrefault<z.ZodObject<{
+        openTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        openRetry: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        ownerLeaseMs: z.ZodDefault<z.ZodNumber>;
+        busyRetryMinMs: z.ZodDefault<z.ZodNumber>;
+        unavailableRetryMs: z.ZodDefault<z.ZodNumber>;
+        drainTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        statusTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        signingKeyRotationGraceMs: z.ZodDefault<z.ZodNumber>;
+        retryAfterSeconds: z.ZodDefault<z.ZodNumber>;
+        seedLeaseMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    sweep: z.ZodPrefault<z.ZodObject<{
+        intervalMs: z.ZodDefault<z.ZodNumber>;
+        batchSize: z.ZodDefault<z.ZodNumber>;
+        signalRetentionMs: z.ZodDefault<z.ZodNumber>;
+        outboxGraceMs: z.ZodDefault<z.ZodNumber>;
+        orphanScanMs: z.ZodDefault<z.ZodNumber>;
+        drainBudgetMs: z.ZodDefault<z.ZodNumber>;
+        armConcurrency: z.ZodDefault<z.ZodNumber>;
+        outboxAttempts: z.ZodDefault<z.ZodNumber>;
+        outboxRetry: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        stalePodMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    execution: z.ZodPrefault<z.ZodObject<{
+        advanceDeadlineMs: z.ZodDefault<z.ZodNumber>;
+        advanceGraceMs: z.ZodDefault<z.ZodNumber>;
+        stopGraceMs: z.ZodDefault<z.ZodNumber>;
+        dedupeRetentionMs: z.ZodDefault<z.ZodNumber>;
+        memoryRetryMs: z.ZodDefault<z.ZodNumber>;
+        memoryAttempts: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    restate: z.ZodPrefault<z.ZodObject<{
+        sendRetryMs: z.ZodDefault<z.ZodNumber>;
+        sendBackoff: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        sendTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        inactivityMs: z.ZodDefault<z.ZodNumber>;
+        abortMs: z.ZodDefault<z.ZodNumber>;
+        handlerRetry: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        handlerAttempts: z.ZodDefault<z.ZodNumber>;
+        registrationDeadlineMs: z.ZodDefault<z.ZodNumber>;
+        registrationBackoff: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        registrationRequestTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        queryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        closeGraceMs: z.ZodDefault<z.ZodNumber>;
+        staleSweepIntervals: z.ZodDefault<z.ZodNumber>;
+        staleSweepMinMs: z.ZodDefault<z.ZodNumber>;
+        stuckListDefault: z.ZodDefault<z.ZodNumber>;
+        stuckListMax: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    postgres: z.ZodPrefault<z.ZodObject<{
+        poolSize: z.ZodDefault<z.ZodNumber>;
+        statementTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        idleInTransactionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        closeTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        idleTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        connectTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        replicationPoolSize: z.ZodDefault<z.ZodNumber>;
+        readPoolSize: z.ZodDefault<z.ZodNumber>;
+        readConnectTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        readStatementTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        readCloseTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        controlPollMs: z.ZodDefault<z.ZodNumber>;
+        controlWindowSeconds: z.ZodDefault<z.ZodNumber>;
+        controlRetry: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        replicationRetryMs: z.ZodDefault<z.ZodNumber>;
+        contentBatchRows: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    streams: z.ZodPrefault<z.ZodObject<{
+        retry: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        basinRetryMaxMs: z.ZodDefault<z.ZodNumber>;
+        basinRepairCooldownMs: z.ZodDefault<z.ZodNumber>;
+        basinLogEveryFailures: z.ZodDefault<z.ZodNumber>;
+        feedCheckMs: z.ZodDefault<z.ZodNumber>;
+        retireGraceMs: z.ZodDefault<z.ZodNumber>;
+        retireAttempts: z.ZodDefault<z.ZodNumber>;
+        probeTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        relayRetry: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        relayBatchRecords: z.ZodDefault<z.ZodNumber>;
+        relayBatchBytes: z.ZodDefault<z.ZodNumber>;
+        relayReconcileConcurrency: z.ZodDefault<z.ZodNumber>;
+        relayHeadsPage: z.ZodDefault<z.ZodNumber>;
+        s2Retry: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        s2ConflictAttempts: z.ZodDefault<z.ZodNumber>;
+        s2ConflictRetryMs: z.ZodDefault<z.ZodNumber>;
+        s2BasinRetryMs: z.ZodDefault<z.ZodNumber>;
+        s2BasinDeletionWaitMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    gates: z.ZodPrefault<z.ZodObject<{
+        clientTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        shortTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        keepAliveMs: z.ZodDefault<z.ZodNumber>;
+        requestTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        probeTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        mcpIdleMs: z.ZodDefault<z.ZodNumber>;
+        errorMessageChars: z.ZodDefault<z.ZodNumber>;
+        mcpSweepMinMs: z.ZodDefault<z.ZodNumber>;
+        mcpSweepMaxMs: z.ZodDefault<z.ZodNumber>;
+        toolCrossingTtlMs: z.ZodDefault<z.ZodNumber>;
+        toolCrossingPruneMs: z.ZodDefault<z.ZodNumber>;
+        drainMs: z.ZodDefault<z.ZodNumber>;
+        drainPollMs: z.ZodDefault<z.ZodNumber>;
+        inflightTtlMs: z.ZodDefault<z.ZodNumber>;
+        inflightMax: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    egress: z.ZodPrefault<z.ZodObject<{
+        maxTunnelsPerSandbox: z.ZodDefault<z.ZodNumber>;
+        idleMs: z.ZodDefault<z.ZodNumber>;
+        cacheMs: z.ZodDefault<z.ZodNumber>;
+        cacheEntries: z.ZodDefault<z.ZodNumber>;
+        connectTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        headersTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        requestTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        credentialsHeadersTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        credentialsMaxSockets: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    pods: z.ZodPrefault<z.ZodObject<{
+        readyDeadlineMs: z.ZodDefault<z.ZodNumber>;
+        pollMs: z.ZodDefault<z.ZodNumber>;
+        unreachableRetryMs: z.ZodDefault<z.ZodNumber>;
+        readyCacheMs: z.ZodDefault<z.ZodNumber>;
+        reconcileRetryMs: z.ZodDefault<z.ZodNumber>;
+        enginePollMs: z.ZodDefault<z.ZodNumber>;
+        memoryFloorMiB: z.ZodDefault<z.ZodNumber>;
+        requestTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        readyProbeTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        waitMs: z.ZodDefault<z.ZodNumber>;
+        waitSlackMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    harness: z.ZodPrefault<z.ZodObject<{
+        pingMs: z.ZodDefault<z.ZodNumber>;
+        silenceMs: z.ZodDefault<z.ZodNumber>;
+        reconnect: z.ZodPrefault<z.ZodObject<{
+            minMs: z.ZodDefault<z.ZodNumber>;
+            maxMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        handshakeTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        reconnectStopMs: z.ZodDefault<z.ZodNumber>;
+        stopMs: z.ZodDefault<z.ZodNumber>;
+        podStopMs: z.ZodDefault<z.ZodNumber>;
+        runTokensMax: z.ZodDefault<z.ZodNumber>;
+        mcpSweepMs: z.ZodDefault<z.ZodNumber>;
+        mcpIdleMs: z.ZodDefault<z.ZodNumber>;
+        mcpListPages: z.ZodDefault<z.ZodNumber>;
+        mcpDiagnosticChars: z.ZodDefault<z.ZodNumber>;
+        helperCommandTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        helperCommandExcerptChars: z.ZodDefault<z.ZodNumber>;
+        scrubMinChars: z.ZodDefault<z.ZodNumber>;
+        execCommandChars: z.ZodDefault<z.ZodNumber>;
+        commandStreamBytes: z.ZodDefault<z.ZodNumber>;
+        podRenewMs: z.ZodDefault<z.ZodNumber>;
+        podRenewEarlyMs: z.ZodDefault<z.ZodNumber>;
+        podJoinTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        podRequestTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        networkPolicyTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        networkProbeMs: z.ZodDefault<z.ZodNumber>;
+        networkPauseMs: z.ZodDefault<z.ZodNumber>;
+        networkConfirmations: z.ZodDefault<z.ZodNumber>;
+        setupRetryPollMs: z.ZodDefault<z.ZodNumber>;
+        setupAfterSeedPollMs: z.ZodDefault<z.ZodNumber>;
+        setupReportTailChars: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    traces: z.ZodPrefault<z.ZodObject<{
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        retries: z.ZodDefault<z.ZodNumber>;
+        backoffMs: z.ZodDefault<z.ZodNumber>;
+        batchSpans: z.ZodDefault<z.ZodNumber>;
+        batchDelayMs: z.ZodDefault<z.ZodNumber>;
+        queuedSpansMax: z.ZodDefault<z.ZodNumber>;
+        turnCacheSize: z.ZodDefault<z.ZodNumber>;
+        retryMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    engine: z.ZodPrefault<z.ZodObject<{
+        transcriptCacheMb: z.ZodOptional<z.ZodNumber>;
+        artifactPageBytes: z.ZodOptional<z.ZodNumber>;
+        skillReadBytes: z.ZodOptional<z.ZodNumber>;
+        leaseRetryMs: z.ZodOptional<z.ZodNumber>;
+        resendDelaysMs: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        partialOutputChars: z.ZodOptional<z.ZodNumber>;
+        flowValueChars: z.ZodOptional<z.ZodNumber>;
+        compaction: z.ZodOptional<z.ZodObject<{
+            keepTokens: z.ZodOptional<z.ZodNumber>;
+            keepShare: z.ZodOptional<z.ZodNumber>;
+            reserveTokens: z.ZodOptional<z.ZodNumber>;
+            maxReserveTokens: z.ZodOptional<z.ZodNumber>;
+            maxReserveShare: z.ZodOptional<z.ZodNumber>;
+            clipChars: z.ZodOptional<z.ZodNumber>;
+            summaryOverheadTokens: z.ZodOptional<z.ZodNumber>;
+            imageTokens: z.ZodOptional<z.ZodNumber>;
+            fileTokensMax: z.ZodOptional<z.ZodNumber>;
+            minChunkTokens: z.ZodOptional<z.ZodNumber>;
+            minSummaryTokens: z.ZodOptional<z.ZodNumber>;
+            summaryShare: z.ZodOptional<z.ZodNumber>;
+            charsPerToken: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        sandboxTools: z.ZodOptional<z.ZodObject<{
+            outputChars: z.ZodOptional<z.ZodNumber>;
+            defaultTimeoutS: z.ZodOptional<z.ZodNumber>;
+            maxTimeoutS: z.ZodOptional<z.ZodNumber>;
+            readLines: z.ZodOptional<z.ZodNumber>;
+            maxReadLines: z.ZodOptional<z.ZodNumber>;
+            lineChars: z.ZodOptional<z.ZodNumber>;
+            grepResults: z.ZodOptional<z.ZodNumber>;
+            maxGrepResults: z.ZodOptional<z.ZodNumber>;
+            globResults: z.ZodOptional<z.ZodNumber>;
+            globScan: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        mcpTools: z.ZodOptional<z.ZodObject<{
+            deferShare: z.ZodOptional<z.ZodNumber>;
+            charsPerToken: z.ZodOptional<z.ZodNumber>;
+            fallbackContextWindow: z.ZodOptional<z.ZodNumber>;
+            serverInstructionsMaxChars: z.ZodOptional<z.ZodNumber>;
+            toolSearchDefaultLimit: z.ZodOptional<z.ZodNumber>;
+            toolSearchMaxLimit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        toolResults: z.ZodOptional<z.ZodObject<{
+            resultInlineBytes: z.ZodOptional<z.ZodNumber>;
+            previewHeadBytes: z.ZodOptional<z.ZodNumber>;
+            previewTailBytes: z.ZodOptional<z.ZodNumber>;
+            stepBudgetBytes: z.ZodOptional<z.ZodNumber>;
+            stubBytes: z.ZodOptional<z.ZodNumber>;
+            smallBytes: z.ZodOptional<z.ZodNumber>;
+            minPreviewBytes: z.ZodOptional<z.ZodNumber>;
+            entryEnvelopeBytes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        outputs: z.ZodOptional<z.ZodObject<{
+            dir: z.ZodOptional<z.ZodString>;
+            maxBytes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type HostTuning = z.infer<typeof HostTuningSchema>;
+/** What an operator sets: any part of the tuning. */
+export type HostTuningInput = z.input<typeof HostTuningSchema>;
+export type EngineTuning = HostTuning["engine"];
+/** The tuning with every default: the Runtime's values when nothing is set. */
+export declare const DEFAULT_HOST_TUNING: HostTuning;
+export declare class HostTuningError extends Error {
+    constructor(message: string);
+}
+/** `input` over the defaults; throws `HostTuningError` naming each refused key. */
+export declare function hostTuningOf(input: unknown, source?: string): HostTuning;
+/** The tuning `NYLORUN_TUNING` names (JSON), and the overrides as set; the defaults when unset. */
+export declare function parseHostTuning(raw: string | undefined): {
+    tuning: HostTuning;
+    overrides?: Record<string, unknown>;
+};
+/**
+ * The process's tuning: what `useHostTuning` set when the process started, or the defaults. Read
+ * where a value is used, never kept at module load, so what the process was started with applies.
+ */
+export declare function hostTuning(): HostTuning;
+/**
+ * Sets the process's tuning, once at start (`host/main.ts`); tests set and reset it. `set` is the
+ * overrides as the operator wrote them, which a pod's engine is handed (`podTuningEnv`).
+ */
+export declare function useHostTuning(tuning: HostTuning, set?: Record<string, unknown>): void;
+/**
+ * `NYLORUN_TUNING` for a pod sandbox's engine: the `harness` and `engine` groups the operator
+ * set, or nothing when they set neither.
+ */
+export declare function podTuningEnv(): Record<string, string>;
+/** Every setting's dotted path (`tenant.openTimeoutMs`), for the docs check. */
+export declare function hostTuningPaths(): string[];