@nylorun/runtime 0.25.0-beta → 0.27.0-beta

package/dist/artifacts/quota.js

@@ -0,0 +1,44 @@
+import { limitsInForce, readTenantLimits } from "../tenant/limits.js";
+/** The quota for an artifact of `environmentId`, or of the Tenant alone when undefined. */
+export async function artifactQuota(t, environmentId) {
+    const tenant = await readTenantLimits(t);
+    const set = environmentId === undefined ? undefined : (await t.environment(environmentId))?.applied.limits;
+    const inForce = limitsInForce(tenant, set);
+    return {
+        fileBytes: inForce.artifacts.fileBytes,
+        totals: [
+            { limitBytes: tenant.artifacts.totalBytes },
+            ...(environmentId !== undefined && set?.artifacts?.totalBytes !== undefined
+                ? [{ environmentId, limitBytes: inForce.artifacts.totalBytes }]
+                : []),
+        ],
+    };
+}
+/** The bytes each of the quota's totals holds now. */
+export async function artifactUsage(t, quota) {
+    const usage = [];
+    for (const total of quota.totals)
+        usage.push({
+            total,
+            usedBytes: await t.artifactBytes(total.environmentId === undefined ? undefined : { environmentId: total.environmentId }),
+        });
+    return usage;
+}
+/** The total with the least room left, and that room (none left: zero or less). */
+export function tightest(usage) {
+    let best = usage[0];
+    for (const entry of usage)
+        if (entry.total.limitBytes - entry.usedBytes < best.total.limitBytes - best.usedBytes)
+            best = entry;
+    return { ...best, roomBytes: best.total.limitBytes - best.usedBytes };
+}
+/** Whose artifacts a total counts: `The Tenant's artifacts`, or `Environment <id>'s artifacts`. */
+export function totalSubject(total) {
+    return total.environmentId === undefined ? "The Tenant's artifacts" : `Environment ${total.environmentId}'s artifacts`;
+}
+/** The Environment a session's artifacts belong to, if it names one. */
+export async function environmentOfSession(t, sessionId) {
+    if (sessionId === null)
+        return undefined;
+    return (await t.get("sessions", sessionId))?.environmentId;
+}

package/dist/artifacts/service.d.ts

@@ -2,6 +2,7 @@ import type { ArtifactSource, ArtifactVersionView, ArtifactView, FolderManifest
 import { type BlobBody } from "../blob/index.js";
 import type { ArtifactRow, ArtifactVersionRow, Tx } from "../store/types.js";
 import { type SessionAccess, type TenantContext } from "../tenant/context.js";
+import { type ArtifactQuota, type ArtifactUsage } from "./quota.js";
 /** What the caller may reach: undefined for the whole Tenant (an application principal). */
 export type ArtifactAccess = SessionAccess | undefined;
 export interface UploadInput {
@@ -17,15 +18,38 @@ export interface UploadInput {
     /** The body's declared length (`Content-Length`): one past the limits is refused unread. */
     readonly declaredBytes?: number;
     readonly source: ArtifactSource;
-    /** The turn that saved it (`save_artifact`), for the event. */
+    /** The turn that saved it (a harness's `artifact.write`), for the event. */
     readonly turnId?: string | null;
     /** The tool call that saved it, for the event. */
     readonly callId?: string;
+    /**
+     * The idempotency key of a harness write (`writeKeyOf`): a version already stored with it is
+     * answered instead, and this upload's bytes are dropped. Needs `sessionId` or `artifactId`.
+     */
+    readonly writeKey?: string;
 }
 export interface Uploaded {
     readonly artifact: ArtifactView;
     readonly version: ArtifactVersionView;
+    /** False when `writeKey` named a version an earlier write stored. */
+    readonly created: boolean;
 }
+/** The key a harness write of session `sessionId` is stored by: its key, scoped to the session. */
+export declare function writeKeyOf(sessionId: string, key: string): string;
+/** Why a write does not fit: the message, and the limit it passes. */
+export interface ArtifactRefusal {
+    readonly message: string;
+    readonly limitBytes: number;
+}
+/**
+ * What one file may hold now within `quota`: the per-file cap, or what is left of the fullest
+ * total (`maxBytes`), and why a file of `size` bytes is refused (`refusal`; with no size, whether
+ * any room is left at all).
+ */
+export declare function artifactRoom(quota: ArtifactQuota, usage: readonly ArtifactUsage[]): {
+    readonly maxBytes: number;
+    refusal(size?: number): ArtifactRefusal | undefined;
+};
 export declare function versionView(row: ArtifactVersionRow): ArtifactVersionView;
 export declare function artifactView(row: ArtifactRow, versions?: ArtifactVersionRow[]): ArtifactView;
 /** An artifact name: 1–255 characters, no path separators or control characters. */

package/dist/artifacts/service.js

@@ -4,11 +4,12 @@
  * (F8.2) are written by the turn-end export (`./export.ts`, `./folders.ts`) and read here.
  *
  * - **Uploads stream.** The body goes to the store as it arrives, at a fresh random key, counted
- *   against the per-file cap and what is left of the Tenant total (`maxBytes`): nothing is
- *   buffered whole, and a body past either limit stores nothing (`413 limit_exceeded`).
+ *   against the per-file cap and what is left of each total it counts towards (`maxBytes`,
+ *   `./quota.ts`: the Tenant's, and a session's Environment's when its manifest sets one):
+ *   nothing is buffered whole, and a body past a limit stores nothing (`413 limit_exceeded`).
  * - **Postgres is the commit point.** One transaction writes the version row and, for a session's
  *   artifact, its `artifact.created` or `artifact.version.created` event through the record
- *   module, after re-checking the Tenant total under the quota lock. Until it commits the object
+ *   module, after re-checking each total under the quota lock. Until it commits the object
  *   is garbage, and a failed commit deletes it.
  * - **Access mirrors sessions.** An application principal reaches every artifact. A request acting
  *   for a person (a trusted issuer's token or subject headers) reaches only artifacts of that person's
@@ -16,24 +17,53 @@
  *
  * Lock order, the same in every write: the session, then the quota lock, then the artifact row.
  */
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { ARTIFACT_NAME_MAX } from "@nylorun/core/contracts";
 import { isArtifactId, newArtifactId } from "@nylorun/core/compatibility";
 import { BlobTooLargeError } from "../blob/index.js";
 import { lockedSession, sessionOf, } from "../tenant/context.js";
 import { fail } from "../tenant/http.js";
-import { readArtifactLimits } from "./config.js";
+import { artifactQuota, artifactUsage, environmentOfSession, tightest, totalSubject, } from "./quota.js";
 import { collectContent, readManifest } from "./folders.js";
-import { contentTypeFor } from "./media-types.js";
+import { contentTypeFor } from "@nylorun/core/contracts";
+/** The key a harness write of session `sessionId` is stored by: its key, scoped to the session. */
+export function writeKeyOf(sessionId, key) {
+    return createHash("sha256").update(`${sessionId}\n${key}`).digest("hex");
+}
 const notFound = () => fail(404, "Artifact not found");
 function tooLarge(message, limit) {
     return fail(413, message, { code: "limit_exceeded", details: { limitBytes: limit } });
 }
-/** A body past `maxBytes`: past the per-file cap, or past what is left of the Tenant total. */
-function tooLargeFor(maxBytes, limits) {
-    return maxBytes === limits.fileBytes
-        ? tooLarge(`A file may hold at most ${limits.fileBytes} bytes`, limits.fileBytes)
-        : tooLarge(`The Tenant's artifacts may hold at most ${limits.totalBytes} bytes; this file does not fit`, limits.totalBytes);
+/**
+ * What one file may hold now within `quota`: the per-file cap, or what is left of the fullest
+ * total (`maxBytes`), and why a file of `size` bytes is refused (`refusal`; with no size, whether
+ * any room is left at all).
+ */
+export function artifactRoom(quota, usage) {
+    const fullest = tightest(usage);
+    const maxBytes = Math.max(0, Math.min(quota.fileBytes, fullest.roomBytes));
+    return {
+        maxBytes,
+        refusal(size) {
+            if (fullest.roomBytes <= 0)
+                return {
+                    message: `${totalSubject(fullest.total)} hold ${fullest.usedBytes} of ${fullest.total.limitBytes} bytes; delete some first`,
+                    limitBytes: fullest.total.limitBytes,
+                };
+            if (size === undefined || size <= maxBytes)
+                return undefined;
+            if (maxBytes === quota.fileBytes)
+                return { message: `A file may hold at most ${quota.fileBytes} bytes`, limitBytes: quota.fileBytes };
+            return {
+                message: `${totalSubject(fullest.total)} may hold at most ${fullest.total.limitBytes} bytes; this file does not fit`,
+                limitBytes: fullest.total.limitBytes,
+            };
+        },
+    };
+}
+function refused(refusal) {
+    if (refusal)
+        tooLarge(refusal.message, refusal.limitBytes);
 }
 export function versionView(row) {
     return {
@@ -108,7 +138,7 @@ export async function versionOf(t, row, version) {
 export async function uploadArtifact(ctx, input, body, access, signal) {
     const name = input.artifactId === undefined ? checkArtifactName(input.name) : undefined;
     // Where it goes and how much room is left, before a byte is stored.
-    const { limits, used, sessionId, fileName } = await ctx.store.tx(async (t) => {
+    const { quota, usage, sessionId, fileName } = await ctx.store.tx(async (t) => {
         let sessionId;
         let fileName = name;
         if (input.artifactId !== undefined) {
@@ -125,15 +155,15 @@ export async function uploadArtifact(ctx, input, body, access, signal) {
                 await sessionOf(t, input.sessionId, access);
             sessionId = input.sessionId ?? null;
         }
-        return { limits: await readArtifactLimits(t), used: await t.artifactBytes(), sessionId, fileName };
+        const quota = await artifactQuota(t, await environmentOfSession(t, sessionId));
+        return { quota, usage: await artifactUsage(t, quota), sessionId, fileName };
     });
     const contentType = input.contentType ?? contentTypeFor(fileName);
-    const room = limits.totalBytes - used;
-    if (room <= 0)
-        tooLarge(`The Tenant's artifacts hold ${used} of ${limits.totalBytes} bytes; delete some first`, limits.totalBytes);
-    const maxBytes = Math.min(limits.fileBytes, room);
-    if (input.declaredBytes !== undefined && input.declaredBytes > maxBytes)
-        tooLargeFor(maxBytes, limits);
+    const room = artifactRoom(quota, usage);
+    refused(room.refusal());
+    const { maxBytes } = room;
+    if (input.declaredBytes !== undefined)
+        refused(room.refusal(input.declaredBytes));
     const artifactId = input.artifactId ?? newArtifactId();
     const key = `artifacts/${artifactId}/${randomUUID()}`;
     let stored;
@@ -146,20 +176,29 @@ export async function uploadArtifact(ctx, input, body, access, signal) {
     }
     catch (error) {
         if (error instanceof BlobTooLargeError)
-            tooLargeFor(maxBytes, limits);
+            refused(room.refusal(maxBytes + 1));
         throw error;
     }
     const createdAt = new Date().toISOString();
+    let uploaded;
     try {
-        return await ctx.store.tx(async (t) => {
+        uploaded = await ctx.store.tx(async (t) => {
             // The session first, then the quota, then the artifact (the module's lock order).
             let session;
             if (sessionId !== null)
                 session = await lockedSession(t, sessionId, access);
+            // A harness's write repeated: the session's lock orders it after the first, whose version
+            // it answers.
+            const known = input.writeKey === undefined ? undefined : await t.artifactVersionByWriteKey(input.writeKey);
+            if (known) {
+                const row = await t.artifact(known.artifactId);
+                if (row)
+                    return { artifact: artifactView(row), version: versionView(known), created: false };
+            }
             await t.lockArtifactQuota();
-            const total = await t.artifactBytes();
-            if (total + stored.size > limits.totalBytes)
-                tooLarge(`The Tenant's artifacts may hold at most ${limits.totalBytes} bytes; this file does not fit`, limits.totalBytes);
+            for (const { total, usedBytes } of await artifactUsage(t, quota))
+                if (usedBytes + stored.size > total.limitBytes)
+                    tooLarge(`${totalSubject(total)} may hold at most ${total.limitBytes} bytes; this file does not fit`, total.limitBytes);
             let row;
             let version;
             if (input.artifactId !== undefined) {
@@ -173,6 +212,7 @@ export async function uploadArtifact(ctx, input, body, access, signal) {
                     contentType,
                     source: input.source,
                     createdAt,
+                    writeKey: input.writeKey ?? null,
                 };
                 await t.insertArtifactVersion(version);
                 row = {
@@ -206,6 +246,7 @@ export async function uploadArtifact(ctx, input, body, access, signal) {
                     contentType,
                     source: input.source,
                     createdAt,
+                    writeKey: input.writeKey ?? null,
                 };
                 await t.insertArtifact(row, version);
             }
@@ -221,7 +262,7 @@ export async function uploadArtifact(ctx, input, body, access, signal) {
                     source: version.source,
                     ...(input.callId === undefined ? {} : { callId: input.callId }),
                 });
-            return { artifact: artifactView(row), version: versionView(version) };
+            return { artifact: artifactView(row), version: versionView(version), created: true };
         });
     }
     catch (error) {
@@ -229,6 +270,10 @@ export async function uploadArtifact(ctx, input, body, access, signal) {
         await ctx.blobs.delete(key).catch(() => undefined);
         throw error;
     }
+    // A repeated write stored nothing of its own: its object is garbage too.
+    if (!uploaded.created)
+        await ctx.blobs.delete(key).catch(() => undefined);
+    return uploaded;
 }
 /** The caller's artifacts: of one session, or of every session it reaches. */
 export async function listArtifacts(ctx, filter, access) {

package/dist/blob/fs.js

@@ -2,7 +2,8 @@ import { createHash, randomUUID } from "node:crypto";
 import { mkdir, open, readFile, readdir, rename, rm, stat, unlink } from "node:fs/promises";
 import { dirname, join, relative, sep } from "node:path";
 import { Readable } from "node:stream";
-import { BlobRangeError, BlobTooLargeError, DEFAULT_CONTENT_TYPE, assertBlobKey, assertBlobPrefix, assertMaxBytes, assertRange, chunksOf, } from "./types.js";
+import { DEFAULT_CONTENT_TYPE } from "@nylorun/core/contracts";
+import { BlobRangeError, BlobTooLargeError, assertBlobKey, assertBlobPrefix, assertMaxBytes, assertRange, chunksOf, } from "./types.js";
 function isMissing(error) {
     const code = error?.code;
     return code === "ENOENT" || code === "ENOTDIR";

package/dist/blob/s3.d.ts

@@ -14,10 +14,14 @@ export interface S3BlobStoreOptions {
     forcePathStyle?: boolean;
     /**
      * A body longer than this is uploaded in parts of about this size (multipart upload); a
-     * shorter one in one request. At least 5 MiB, the S3 minimum. Default 8 MiB.
+     * shorter one in one request. At least 5 MiB, the S3 minimum (`S3_MIN_PART_BYTES`). Default
+     * `objectStore.partSizeBytes` (Host tuning, 8 MiB).
      */
     partSize?: number;
-    /** Attempts for a request that fails with a network error, 429 or 5xx. Default 3. */
+    /**
+     * Attempts for a request that fails with a network error, 429 or 5xx. Default
+     * `objectStore.attempts` (3); the wait after a failed one is `objectStore.retryBaseMs`, doubled.
+     */
     attempts?: number;
     /** Replaces the global `fetch` (tests). */
     fetch?: typeof fetch;

package/dist/blob/s3.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
 import { AwsClient } from "aws4fetch";
-import { BlobRangeError, BlobStoreError, BlobTooLargeError, DEFAULT_CONTENT_TYPE, assertBlobKey, assertBlobPrefix, assertMaxBytes, assertRange, chunksOf, } from "./types.js";
-const MIN_PART_SIZE = 5 * 1024 * 1024;
-const DEFAULT_PART_SIZE = 8 * 1024 * 1024;
+import { hostTuning, S3_MIN_PART_BYTES } from "../tuning.js";
+import { DEFAULT_CONTENT_TYPE } from "@nylorun/core/contracts";
+import { BlobRangeError, BlobStoreError, BlobTooLargeError, assertBlobKey, assertBlobPrefix, assertMaxBytes, assertRange, chunksOf, } from "./types.js";
 function sha256Hex(bytes) {
     return createHash("sha256").update(bytes).digest("hex");
 }
@@ -57,8 +57,10 @@ export function createS3BlobStore(options) {
     const bucketUrl = pathStyle
         ? `${base}/${options.bucket}`
         : `${endpoint.protocol}//${options.bucket}.${endpoint.host}${endpoint.pathname.replace(/\/+$/, "")}`;
-    const partSize = Math.max(options.partSize ?? DEFAULT_PART_SIZE, MIN_PART_SIZE);
-    const attempts = Math.max(1, options.attempts ?? 3);
+    const tuning = hostTuning().objectStore;
+    const partSize = Math.max(options.partSize ?? tuning.partSizeBytes, S3_MIN_PART_BYTES);
+    const attempts = Math.max(1, options.attempts ?? tuning.attempts);
+    const pause = (attempt) => new Promise((resolve) => setTimeout(resolve, tuning.retryBaseMs * 2 ** (attempt - 1)));
     const fetchImpl = options.fetch ?? globalThis.fetch;
     const client = new AwsClient({
         accessKeyId: options.accessKeyId,
@@ -81,7 +83,7 @@ export function createS3BlobStore(options) {
                 const response = await fetchImpl(await client.sign(url, init));
                 if ((response.status >= 500 || response.status === 429) && attempt < attempts && !once) {
                     await response.body?.cancel();
-                    await new Promise((resolve) => setTimeout(resolve, 50 * 2 ** attempt));
+                    await pause(attempt);
                     continue;
                 }
                 return response;
@@ -91,7 +93,7 @@ export function createS3BlobStore(options) {
                     throw error;
                 lastError = error;
                 if (attempt < (once ? 1 : attempts))
-                    await new Promise((resolve) => setTimeout(resolve, 50 * 2 ** attempt));
+                    await pause(attempt);
             }
         }
         throw new BlobStoreError(`The Object store is unreachable: ${lastError instanceof Error ? lastError.message : String(lastError)}`);

package/dist/blob/types.d.ts

@@ -93,7 +93,7 @@ export declare class BlobRangeError extends Error {
     readonly size: number;
     constructor(range: BlobRange, size: number);
 }
-export declare const DEFAULT_CONTENT_TYPE = "application/octet-stream";
+/** The longest object key S3 takes: 1024 bytes of UTF-8. A constant of the S3 API, not a setting. */
 export declare const MAX_KEY_BYTES = 1024;
 /**
  * Keys are `/`-separated segments of `A-Z a-z 0-9 . _ -`, neither `.` nor `..`, at most 1024

package/dist/blob/types.js

@@ -41,7 +41,7 @@ export class BlobRangeError extends Error {
         this.name = "BlobRangeError";
     }
 }
-export const DEFAULT_CONTENT_TYPE = "application/octet-stream";
+/** The longest object key S3 takes: 1024 bytes of UTF-8. A constant of the S3 API, not a setting. */
 export const MAX_KEY_BYTES = 1024;
 const SEGMENT = /^[A-Za-z0-9._-]+$/;
 /**

package/dist/core/limits.d.ts

@@ -1,40 +1,16 @@
 /**
- * Operator flow limits (`workflows.md` §13).
- * Host configuration only — never workflow API settings.
+ * Flow limits (`workflows.md` §13): the Tenant's Runtime limits `flowConcurrency`, `flowMapItems`
+ * and `flowLoopIterations` (`PUT /v1/tenant/limits`), read where they are checked. Core holds a
+ * flow turn to `flowConcurrency` when it dispatches effects; the flow engine checks the other two,
+ * which a flow's `turn.start` carries (`flowLimitsOf`).
  */
-export type FlowLimits = {
-    readonly maxConcurrency: number;
+import type { RuntimeLimits } from "@nylorun/core/contracts";
+/** What a flow's `turn.start.options.flowLimits` carries to the flow engine. */
+export interface FlowEngineLimits {
     readonly maxMapItems: number;
     readonly maxLoopIterations: number;
-};
-export declare const FLOW_LIMIT_DEFAULTS: FlowLimits;
-export declare const FLOW_LIMIT_ENV: {
-    readonly maxConcurrency: "NYLORUN_FLOW_MAX_CONCURRENCY";
-    readonly maxMapItems: "NYLORUN_FLOW_MAX_MAP_ITEMS";
-    readonly maxLoopIterations: "NYLORUN_FLOW_MAX_LOOP_ITERATIONS";
-};
-export type FlowLimitErrorCode = "map.too-many-items" | "loop.too-many-iterations";
-export declare class FlowLimitError extends Error {
-    readonly code: FlowLimitErrorCode;
-    readonly path?: string;
-    constructor(code: FlowLimitErrorCode, message: string, path?: string);
 }
-/**
- * Resolve limits from `RuntimeOptions.flow` overrides and optional env snapshot.
- * Does not read ambient process environment — callers pass an explicit env map.
- */
-export declare function resolveFlowLimits(input?: {
-    readonly flow?: Partial<FlowLimits> | null;
-    readonly env?: Readonly<Record<string, string | undefined>>;
-}): FlowLimits;
-/** Further ready work waits when active >= maxConcurrency (not an error). */
-export declare function mayDispatchMore(activeCount: number, limits: Pick<FlowLimits, "maxConcurrency">): boolean;
-/**
- * Map item ceiling. Exceeding raises `map.too-many-items` and nothing should start.
- */
-export declare function assertMapItemCount(count: number, limits: Pick<FlowLimits, "maxMapItems">, path?: string): void;
-/**
- * Loop operator ceiling. Exceeding raises `loop.too-many-iterations`.
- * `n` is the 1-based iteration about to run.
- */
-export declare function assertLoopIteration(n: number, limits: Pick<FlowLimits, "maxLoopIterations">, path?: string): void;
+/** The flow engine's limits from the Tenant's Runtime limits. */
+export declare function flowLimitsOf(limits: Pick<RuntimeLimits, "flowMapItems" | "flowLoopIterations">): FlowEngineLimits;
+/** Further ready work waits when `active` reaches `flowConcurrency` (not an error). */
+export declare function mayDispatchMore(activeCount: number, limits: Pick<RuntimeLimits, "flowConcurrency">): boolean;

package/dist/core/limits.js

@@ -1,76 +1,8 @@
-/**
- * Operator flow limits (`workflows.md` §13).
- * Host configuration only — never workflow API settings.
- */
-export const FLOW_LIMIT_DEFAULTS = {
-    maxConcurrency: 8,
-    maxMapItems: 1000,
-    maxLoopIterations: 100,
-};
-export const FLOW_LIMIT_ENV = {
-    maxConcurrency: "NYLORUN_FLOW_MAX_CONCURRENCY",
-    maxMapItems: "NYLORUN_FLOW_MAX_MAP_ITEMS",
-    maxLoopIterations: "NYLORUN_FLOW_MAX_LOOP_ITERATIONS",
-};
-export class FlowLimitError extends Error {
-    code;
-    path;
-    constructor(code, message, path) {
-        super(message);
-        this.name = "FlowLimitError";
-        this.code = code;
-        if (path !== undefined)
-            this.path = path;
-    }
+/** The flow engine's limits from the Tenant's Runtime limits. */
+export function flowLimitsOf(limits) {
+    return { maxMapItems: limits.flowMapItems, maxLoopIterations: limits.flowLoopIterations };
 }
-function parsePositiveInt(raw, field) {
-    if (raw === undefined || raw === "")
-        return undefined;
-    const n = Number(raw);
-    if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0)
-        throw new Error(`${field} must be a positive integer`);
-    return n;
-}
-/**
- * Resolve limits from `RuntimeOptions.flow` overrides and optional env snapshot.
- * Does not read ambient process environment — callers pass an explicit env map.
- */
-export function resolveFlowLimits(input) {
-    const env = input?.env ?? {};
-    const flow = input?.flow ?? {};
-    const fromEnv = {
-        maxConcurrency: parsePositiveInt(env[FLOW_LIMIT_ENV.maxConcurrency], FLOW_LIMIT_ENV.maxConcurrency),
-        maxMapItems: parsePositiveInt(env[FLOW_LIMIT_ENV.maxMapItems], FLOW_LIMIT_ENV.maxMapItems),
-        maxLoopIterations: parsePositiveInt(env[FLOW_LIMIT_ENV.maxLoopIterations], FLOW_LIMIT_ENV.maxLoopIterations),
-    };
-    const pick = (field, override, envValue) => {
-        const value = override ?? envValue ?? FLOW_LIMIT_DEFAULTS[field];
-        if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0)
-            throw new Error(`flow.${field} must be a positive integer`);
-        return value;
-    };
-    return {
-        maxConcurrency: pick("maxConcurrency", flow.maxConcurrency, fromEnv.maxConcurrency),
-        maxMapItems: pick("maxMapItems", flow.maxMapItems, fromEnv.maxMapItems),
-        maxLoopIterations: pick("maxLoopIterations", flow.maxLoopIterations, fromEnv.maxLoopIterations),
-    };
-}
-/** Further ready work waits when active >= maxConcurrency (not an error). */
+/** Further ready work waits when `active` reaches `flowConcurrency` (not an error). */
 export function mayDispatchMore(activeCount, limits) {
-    return activeCount < limits.maxConcurrency;
-}
-/**
- * Map item ceiling. Exceeding raises `map.too-many-items` and nothing should start.
- */
-export function assertMapItemCount(count, limits, path) {
-    if (count > limits.maxMapItems)
-        throw new FlowLimitError("map.too-many-items", `Map produced ${count} items; maxMapItems is ${limits.maxMapItems}`, path);
-}
-/**
- * Loop operator ceiling. Exceeding raises `loop.too-many-iterations`.
- * `n` is the 1-based iteration about to run.
- */
-export function assertLoopIteration(n, limits, path) {
-    if (n > limits.maxLoopIterations)
-        throw new FlowLimitError("loop.too-many-iterations", `Loop iteration ${n} exceeds maxLoopIterations ${limits.maxLoopIterations}`, path);
+    return activeCount < limits.flowConcurrency;
 }

package/dist/core/sandbox-routes.js

@@ -38,7 +38,6 @@ async function runTool(deps, session, tool, input, signal) {
     const ref = {
         id: workspace.ownerId,
         activeTurnId: session.activeTurnId,
-        manifest: session.manifest,
         ...(workspace.environmentId === undefined ? {} : { environmentId: workspace.environmentId }),
     };
     return deps.sandbox.run(ref, spec, tool, input, signal);

package/dist/core/turn-manifest.d.ts

@@ -17,8 +17,7 @@ export type TurnManifestErr = {
 };
 /**
  * Parse `message.manifest`, require it to be a variant of the session pin, and store the
- * manifest the turn runs with: the variant with the pin's `runtime` block (a variant never sets
- * one), by its hash. Applies to that turn only (caller must not latch).
+ * manifest the turn runs with, by its hash. Applies to that turn only (caller must not latch).
  */
 export declare function pinTurnManifest(args: {
     readonly candidate: unknown;

package/dist/core/turn-manifest.js

@@ -1,30 +1,9 @@
 import { AgentManifestSchema, } from "@nylorun/core/contracts";
 import { hashManifest } from "@nylorun/core/compatibility";
 import { isVariantOf } from "@nylorun/core/define";
-/**
- * The candidate's agents used as tools with the `runtime` block the pin gave each, when the
- * candidate left it out: a turn variant is written from the definition, and only the Runtime
- * writes `runtime`. A candidate that sets one keeps it, and must then match the pin's.
- */
-function withPinnedDelegates(candidate, pinned) {
-    if (candidate.tools === undefined)
-        return candidate;
-    const pinnedAgents = new Map((pinned.tools ?? []).flatMap((tool) => tool.agent !== undefined && !("kind" in tool.agent) ? [[tool.name, tool.agent]] : []));
-    let changed = false;
-    const tools = candidate.tools.map((tool) => {
-        const agent = tool.agent;
-        const prior = pinnedAgents.get(tool.name);
-        if (agent === undefined || "kind" in agent || agent.runtime !== undefined || prior?.runtime === undefined)
-            return tool;
-        changed = true;
-        return { ...tool, agent: { ...agent, runtime: prior.runtime } };
-    });
-    return changed ? { ...candidate, tools } : candidate;
-}
 /**
  * Parse `message.manifest`, require it to be a variant of the session pin, and store the
- * manifest the turn runs with: the variant with the pin's `runtime` block (a variant never sets
- * one), by its hash. Applies to that turn only (caller must not latch).
+ * manifest the turn runs with, by its hash. Applies to that turn only (caller must not latch).
  */
 export function pinTurnManifest(args) {
     const parsed = AgentManifestSchema.safeParse(args.candidate);
@@ -35,17 +14,14 @@ export function pinTurnManifest(args) {
             message: "Turn manifest failed AgentManifestSchema validation",
         };
     }
-    const candidate = withPinnedDelegates(parsed.data, args.pinned);
-    if (!isVariantOf(candidate, args.pinned)) {
+    const manifest = parsed.data;
+    if (!isVariantOf(manifest, args.pinned)) {
         return {
             ok: false,
             code: "loop.invalid-agent",
-            message: candidate.runtime === undefined
-                ? "Turn manifest is not a variant of the session's pinned manifest"
-                : "Turn manifest sets runtime, which only the Runtime writes: leave it out, and the turn runs with the session's",
+            message: "Turn manifest is not a variant of the session's pinned manifest",
         };
     }
-    const manifest = args.pinned.runtime === undefined ? candidate : { ...candidate, runtime: args.pinned.runtime };
     const hash = hashManifest(manifest);
     args.store.put(hash, manifest);
     return { ok: true, manifest, hash };

package/dist/execution/memory.d.ts

@@ -1,16 +1,19 @@
 import { type DurableExecution, type SandboxSignal, type Wake, type WorkerHandlers } from "./types.js";
 export interface MemoryExecutionOptions {
-    /** Delay between sweep passes of one Tenant. Default 5000. */
+    /** Delay between sweep passes of one Tenant. Default `sweep.intervalMs` (Host tuning, 5 s). */
     sweepIntervalMs?: number;
-    /** First retry delay after `advance` throws; doubles per attempt. Default 50. */
+    /**
+     * First retry delay after `advance` throws; doubles per attempt. Default
+     * `execution.memoryRetryMs` (50 ms).
+     */
     retryDelayMs?: number;
-    /** Attempts before giving up on a throwing handler and reporting it. Default 5. */
+    /** Attempts before giving up on a throwing handler and reporting it. Default `execution.memoryAttempts` (5). */
     maxAttempts?: number;
-    /** How long a dedupe key merges repeated wakes. Default 24 hours. */
+    /** How long a dedupe key merges repeated wakes. Default `execution.dedupeRetentionMs` (24 hours). */
     dedupeRetentionMs?: number;
     /**
      * How long `stop` waits for running handlers after aborting them; the ones still running
-     * then are abandoned. Default `DEFAULT_STOP_GRACE_MS`.
+     * then are abandoned. Default `execution.stopGraceMs` (30 s).
      */
     stopGraceMs?: number;
     /** Receives handler failures that are not retried. */

package/dist/execution/memory.js

@@ -1,4 +1,5 @@
-import { DEFAULT_STOP_GRACE_MS, WAKE_REASONS, sessionKey, settleWithin, } from "./types.js";
+import { WAKE_REASONS, sessionKey, settleWithin, } from "./types.js";
+import { hostTuning } from "../tuning.js";
 /**
  * In-process `DurableExecution`. Not durable: wakes, timers and sweeps live in
  * memory. It keeps the seam's ordering guarantees within one process, which is
@@ -21,11 +22,12 @@ export class MemoryExecution {
     stopGraceMs;
     onError;
     constructor(options = {}) {
-        this.sweepIntervalMs = options.sweepIntervalMs ?? 5000;
-        this.retryDelayMs = options.retryDelayMs ?? 50;
-        this.maxAttempts = options.maxAttempts ?? 5;
-        this.dedupeRetentionMs = options.dedupeRetentionMs ?? 24 * 60 * 60_000;
-        this.stopGraceMs = options.stopGraceMs ?? DEFAULT_STOP_GRACE_MS;
+        const tuning = hostTuning();
+        this.sweepIntervalMs = options.sweepIntervalMs ?? tuning.sweep.intervalMs;
+        this.retryDelayMs = options.retryDelayMs ?? tuning.execution.memoryRetryMs;
+        this.maxAttempts = options.maxAttempts ?? tuning.execution.memoryAttempts;
+        this.dedupeRetentionMs = options.dedupeRetentionMs ?? tuning.execution.dedupeRetentionMs;
+        this.stopGraceMs = options.stopGraceMs ?? tuning.execution.stopGraceMs;
         this.onError =
             options.onError ??
                 ((error) => queueMicrotask(() => {