@nylorun/runtime 0.9.0-beta → 0.10.0-beta

package/dist/core/limits.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Operator flow limits (`workflows.md` §13).
+ * Host configuration only — never workflow API settings.
+ */
+export type FlowLimits = {
+    readonly maxConcurrency: number;
+    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;

package/dist/core/limits.js

@@ -0,0 +1,76 @@
+/**
+ * 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;
+    }
+}
+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). */
+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);
+}

package/dist/core/runtime.d.ts

@@ -1,90 +1,5 @@
-import { type ExecutorScope } from "@nylorun/core/contracts";
-import { type ModelProvider } from "./provider.js";
-import { type AuthorizeResult } from "../vault/service.js";
-import type { SandboxBackend } from "../sandbox/types.js";
-export interface RuntimeOptions {
-    sqlitePath: string;
-    serverToken: string;
-    executors: readonly (ExecutorScope & {
-        token: string;
-    })[];
-    model?: ModelProvider;
-    /** Read the model provider credential from the host vault at call time. */
-    useHostModel?: boolean;
-    leaseMs?: number;
-    /** 32-byte key, or base64 of that key. `null` disables env and file lookup. */
-    vaultKek?: Buffer | string | null;
-    vaultKekPath?: string;
-    vaultFetch?: typeof fetch;
-    sandbox?: {
-        /** `auto` (default), `microsandbox` or `virtual`. Defaults to NYLORUN_SANDBOX. */
-        backend?: string;
-        /** Host directory for virtual-backend workspaces. Defaults beside the SQLite file. */
-        root?: string;
-        /** Replace the backend list. Tests only. */
-        backends?: readonly SandboxBackend[];
-    };
-}
-export declare class CoreRuntime {
-    private readonly options;
-    private readonly store;
-    private readonly vault;
-    private kek;
-    private readonly kekPath;
-    private readonly running;
-    private readonly pending;
-    private readonly observers;
-    private readonly executorStreams;
-    private readonly registry;
-    private readonly scopeId;
-    private readonly mcp;
-    private readonly sandbox;
-    private server?;
-    private closing;
-    private closed;
-    private readonly lockPath?;
-    private readonly timer;
-    constructor(options: RuntimeOptions);
-    private session;
-    private publish;
-    private send;
-    private notify;
-    /**
-     * Manifest v4 replaced beforeModelCall/afterModelCall with scoped hooks. Turns started under
-     * an older manifest cannot continue, and their hook actions no longer parse, so end them.
-     */
-    private retireLegacyHooks;
-    private expireClaims;
-    private schedule;
-    private execute;
-    private invokeModel;
-    private resolveEffect;
-    private scope;
-    private scoped;
-    private body;
-    private command;
-    private sse;
-    private handle;
-    private view;
-    private prepareMcp;
-    private callMcpTool;
-    private callSandboxTool;
-    authorize(sessionId: string, request: {
-        url: string;
-        serverName?: string;
-    }): Promise<AuthorizeResult>;
-    private ensureKek;
-    private dispatchHost;
-    private dispatchVault;
-    listen(port?: number, hostname?: string): Promise<{
-        url: string;
-    }>;
-    close(): Promise<void>;
-}
-export declare function createRuntime(options: RuntimeOptions): CoreRuntime;
-export declare function startRuntime(options: RuntimeOptions & {
-    port?: number;
-    hostname?: string;
-}): Promise<CoreRuntime & {
-    url: string;
-}>;
+export { openTenantRuntime, TenantRuntime, type TenantOpenHooks, } from "../tenant/runtime.js";
+export { startEphemeralRuntime, type StartEphemeralRuntimeOptions, type EphemeralRuntime, } from "../tenant/ephemeral.js";
+export { scriptedModel, gatewayModel, type ModelProvider } from "./provider.js";
+/** @deprecated Use TenantHandle. */
+export type { TenantHandle as CoreRuntime } from "../tenant/types.js";