@skein-js/server-kit 0.11.2 → 0.12.0

package/dist/index.d.ts

@@ -1,12 +1,14 @@
-import { ProtocolRuntime, Logger, ProtocolDeps, RunWorkerOptions, RunFailureReport, GraphResolver, ProtocolResponse } from '@skein-js/agent-protocol';
+import { ProtocolRuntime, RouteBinding, Logger, ProtocolDeps, RunWorkerOptions, CronSchedulerOptions, RunFailureReport, GraphResolver, RouteMatcher, DisabledRouteGroups, ProtocolResponse } from '@skein-js/agent-protocol';
 export { CompiledGraphFactory, DEFAULT_RUN_CONCURRENCY, DEFAULT_SHUTDOWN_GRACE_MS, GraphResolver, Logger, ProtocolDeps, ResolvedGraph, RunWorkerOptions } from '@skein-js/agent-protocol';
 import { ModuleImporter, LanggraphJson, GraphSchemas } from '@skein-js/config';
 import { CorsOptions } from 'cors';
 export { CorsOptions } from 'cors';
-import { MemoryStoreSnapshot } from '@skein-js/storage-memory';
-import { CompiledGraph, BaseCheckpointSaver } from '@langchain/langgraph';
-import { SkeinStore } from '@skein-js/core';
+import { MemoryRunEventBusOptions } from '@skein-js/storage-memory';
+import { D as DevStateSnapshot } from './dev-BfYYRfEB.js';
+export { a as DevStateCounts } from './dev-BfYYRfEB.js';
+import { CompiledGraph } from '@langchain/langgraph';
 import { ServerResponse } from 'node:http';
+import '@skein-js/core';
 
 interface SkeinRuntimeCommonOptions {
     /**
@@ -58,6 +60,17 @@ interface SkeinRuntimeCommonOptions {
      * longer than this, or the abort step never runs — see docs/deploy.md.
      */
     worker?: RunWorkerOptions;
+    /**
+     * Tuning for the cron scheduler.
+     *
+     * `tickMs` is how often each instance looks for due crons (default `DEFAULT_CRON_TICK_MS`); omit it
+     * and skein reads `SKEIN_CRON_TICK_MS`, with the same explicit-wins-but-still-validated rule.
+     *
+     * `enabled` defaults to whether the crons route group is mounted, so `http.disable_crons` switches
+     * off the schedules as well as the endpoints. Set it explicitly to run one without the other — a
+     * worker-only instance that serves no HTTP, say.
+     */
+    scheduler?: CronSchedulerOptions;
 }
 /** Either point at a `langgraph.json` (in-memory runtime) or inject a ready `ProtocolDeps`. */
 type SkeinRuntimeOptions = SkeinRuntimeCommonOptions & ({
@@ -78,6 +91,12 @@ interface ResolvedProtocolRuntime {
     runtime: ProtocolRuntime;
     /** CORS mapped from the config's `http.cors`, or `undefined` for the injected-`deps` path. */
     cors?: CorsOptions;
+    /**
+     * The route table to mount: the full protocol, minus any group the config's `http.disable_*` flags
+     * switched off. Always present — the injected-`deps` path has no config to read flags from, so it
+     * gets the complete table.
+     */
+    routes: readonly RouteBinding[];
     /**
      * The logger the engine ended up with, after {@link SkeinRuntimeCommonOptions.logger}'s precedence
      * chain. `undefined` means nothing logs. Adapters read this (rather than `options.logger`) for
@@ -91,6 +110,8 @@ interface ResolvedRuntimeDeps {
     deps: ProtocolDeps;
     /** CORS mapped from the config's `http.cors`, or `undefined` for the injected-`deps` path. */
     cors?: CorsOptions;
+    /** The route table to mount — see {@link ResolvedProtocolRuntime.routes}. */
+    routes: readonly RouteBinding[];
     /** The resolved logger — see {@link ResolvedProtocolRuntime.logger}. */
     logger?: Logger;
 }
@@ -160,6 +181,182 @@ declare function formatLogMeta(meta: unknown): string;
  */
 declare function describeError(thrown: unknown): string;
 
+/**
+ * The two bounds this resolves. `finishedIdTtlMs` and `now` are deliberately not included — the TTL
+ * matches the Redis driver's closed-marker window and is not something a deployment tunes, and the
+ * clock exists for tests.
+ */
+type ResolvedMemoryBusLimits = Required<Pick<MemoryRunEventBusOptions, "maxRetainedRuns" | "maxFramesPerRun">>;
+/**
+ * Resolve the memory bus's retention bounds from explicit options, then the environment, then the
+ * defaults. Both variables are validated even when an explicit value is supplied, so a bad one can't
+ * sit unnoticed in a deployment that also passes options.
+ *
+ * `env` is injected (defaulting to `process.env`) so callers — and tests — can resolve against an
+ * environment they control.
+ *
+ * @example
+ * ```ts
+ * new MemoryRunEventBus(resolveMemoryBusLimits());
+ * ```
+ */
+declare function resolveMemoryBusLimits(explicit?: MemoryRunEventBusOptions, env?: NodeJS.ProcessEnv): ResolvedMemoryBusLimits;
+
+/** Reads a file, or returns undefined when it is absent/unreadable. Injectable for tests. */
+type FileReader = (path: string) => string | undefined;
+/**
+ * The container's memory limit in bytes, or `undefined` when there isn't one to read — not
+ * containerized, a cgroup namespace that doesn't expose it, or an explicitly unlimited container.
+ *
+ * cgroup v2 writes the literal `max` when unbounded; v1 writes a huge sentinel (commonly
+ * `9223372036854771712`) rather than anything meaningful, so a value at or above the exabyte mark is
+ * treated as "no limit" too.
+ */
+declare function readContainerMemoryLimit(readFile?: FileReader): number | undefined;
+interface HeapHeadroom {
+    /** V8's own ceiling for the old space, in bytes. */
+    heapLimitBytes: number;
+    /** The container's limit, when one could be read. */
+    containerLimitBytes: number | undefined;
+    /** A warning to log, or `undefined` when the sizing is fine (or unknowable). */
+    warning: string | undefined;
+}
+/**
+ * Compare V8's heap ceiling against the container's memory limit.
+ *
+ * Warns when the ceiling exceeds {@link HEAP_LIMIT_WARN_FRACTION} of the limit: at that point V8 is
+ * willing to grow into memory the container does not have, and the process dies by OOM kill rather than
+ * by a heap-out-of-memory error it could report. The remedy is `--max-old-space-size`, which is why the
+ * warning names it with a computed value rather than telling the operator to go and read something.
+ *
+ * Silent when no container limit is readable: guessing on a bare host would warn on every dev machine.
+ */
+declare function describeHeapHeadroom(heapLimitBytes: number, containerLimitBytes: number | undefined): HeapHeadroom;
+/**
+ * Read both limits and report the mis-sizing, if any. Call once at boot.
+ *
+ * `heapStatistics` and `readFile` are injected so this is testable without a container and without
+ * mutating the real process's heap.
+ */
+declare function checkHeapHeadroom(options?: {
+    heapStatistics?: () => {
+        heap_size_limit: number;
+    };
+    readFile?: FileReader;
+}): HeapHeadroom;
+
+/** Percent of the heap limit at which to warn. */
+declare const DEFAULT_HEAP_WARN_PERCENT = 85;
+/**
+ * How far below the warn threshold usage must fall before another warning can fire.
+ *
+ * Hysteresis, not a fixed floor: a process hovering at exactly the threshold would otherwise warn, drop a
+ * megabyte, warn again, and produce the per-sample noise the latch exists to prevent. Derived from the
+ * threshold rather than hardcoded because the threshold is operator-settable — a fixed 70% band with
+ * `SKEIN_HEAP_WARN_PERCENT=60` would re-arm on the very samples that trip the warning, turning the latch
+ * into exactly the flood it exists to prevent.
+ *
+ * Wider than the GC sawtooth: measured in `node:22-slim`, a busy process swings ~12–15 points between
+ * collections, so a narrower band would warn once per cycle on a healthy instance.
+ */
+declare const HEAP_REARM_MARGIN_PERCENT = 15;
+/** The default re-arm point, for docs and tests: 85% warn − 15 margin. */
+declare const HEAP_REARM_PERCENT: number;
+/** How often to sample. Long enough to cost nothing, short enough to catch an episode. */
+declare const DEFAULT_HEAP_SAMPLE_MS = 30000;
+/** Extra context gathered at warn time — whatever the host can cheaply answer. */
+interface HeapPressureContext {
+    /** Runs executing on this instance right now. */
+    inFlightRuns?: number;
+    /** Frames the in-memory event bus is holding, when that bus is in use. */
+    bufferedFrames?: number;
+}
+/** Whatever the injected scheduler returns; only ever passed back to the injected clearer. */
+type IntervalHandle = {
+    unref?: () => void;
+};
+interface HeapPressureMonitorOptions {
+    /** Where the warning goes. No logger → the monitor does nothing at all. */
+    logger?: Logger;
+    /** Percent of the heap limit at which to warn. `0` disables the monitor. */
+    warnPercent?: number;
+    /** Sampling interval in ms. */
+    sampleMs?: number;
+    /** Called at warn time only, so gathering context costs nothing on a healthy process. */
+    context?: () => HeapPressureContext;
+    /** Injected for tests. */
+    heapStatistics?: () => {
+        heap_size_limit: number;
+        used_heap_size: number;
+    };
+    /** Injected for tests. */
+    rss?: () => number;
+    /**
+     * Injected for tests. Typed loosely on purpose: the handle only ever travels from here to
+     * `clearInterval` below, so a real `Timeout` and a fake `{ unref }` both fit.
+     */
+    setInterval?: (callback: () => void, ms: number) => IntervalHandle;
+    clearInterval?: (handle: IntervalHandle) => void;
+}
+interface HeapPressureMonitor {
+    /** Stop sampling. Idempotent. */
+    stop(): void;
+}
+/**
+ * Start watching heap usage. Returns a handle to stop it; call that where the run worker is stopped.
+ *
+ * The interval is `unref`'d, so it can never hold the event loop open through shutdown — an embedded
+ * host with no force-exit timer of its own would otherwise experience a clean shutdown as a hang.
+ *
+ * Off is a supported configuration: no logger, or `warnPercent: 0`, and nothing is scheduled.
+ */
+declare function startHeapPressureMonitor(options?: HeapPressureMonitorOptions): HeapPressureMonitor;
+/**
+ * Resolve the monitor's tuning from the environment, following the same rule as the other knobs:
+ * explicit wins, but the environment is read *and validated* either way, so a typo fails at boot
+ * rather than sitting unnoticed in a deployment.
+ *
+ * `SKEIN_HEAP_WARN_PERCENT` accepts `0` to disable, which is why it cannot use
+ * `positiveIntegerFromEnv`.
+ */
+declare function resolveHeapPressureOptions(explicit?: {
+    warnPercent?: number;
+    sampleMs?: number;
+}, env?: NodeJS.ProcessEnv): {
+    warnPercent: number;
+    sampleMs: number;
+};
+
+/**
+ * The one precedence chain for the page bound: an explicit `maxPageSize` store option wins, else
+ * `SKEIN_MAX_PAGE_SIZE`, else {@link DEFAULT_MAX_PAGE_SIZE}. The environment is read and validated even
+ * when `explicit` is given, so a bad value can't sit unnoticed in a deployment that also passes it.
+ *
+ * Raising this is the escape hatch for a deployment that genuinely needs bigger pages; it is a
+ * *memory* setting, not a correctness one — the wire schemas independently cap a client-supplied
+ * `limit` at {@link DEFAULT_MAX_PAGE_SIZE}, so raising it only widens what an absent limit means and
+ * what an in-process caller may ask for.
+ *
+ * `env` is injected (defaulting to `process.env`) so callers — and tests — can resolve against an
+ * environment they control.
+ */
+declare function resolveMaxPageSize(explicit?: number, env?: NodeJS.ProcessEnv): number;
+
+/**
+ * The one precedence chain for the cron tick interval: an explicit `scheduler.tickMs` wins, else
+ * `SKEIN_CRON_TICK_MS`, else {@link DEFAULT_CRON_TICK_MS}. The environment is read and validated even
+ * when `explicit` is given, so a bad value cannot sit unnoticed in a deployment that also passes the
+ * option.
+ *
+ * Lowering this does not make schedules more accurate below one minute — a 5-field cron expression
+ * cannot express anything finer. Raising it trades lateness for fewer reads; the practical ceiling is
+ * one minute, past which a `* * * * *` cron visibly skips minutes.
+ *
+ * `env` is injected (defaulting to `process.env`) so callers — and tests — can resolve against an
+ * environment they control.
+ */
+declare function resolveCronTickMs(explicit?: number, env?: NodeJS.ProcessEnv): number;
+
 /**
  * The one precedence chain for background-run concurrency: an explicit value (a `worker.maxConcurrency`
  * option, or the CLI's `--concurrency` / `-n`) wins, else `SKEIN_RUN_CONCURRENCY`, else
@@ -171,6 +368,32 @@ declare function describeError(thrown: unknown): string;
  * environment they control.
  */
 declare function resolveRunConcurrency(explicit?: number, env?: NodeJS.ProcessEnv): number;
+/**
+ * A warning when the background worker can execute more runs at once than the Postgres pool has
+ * connections to serve them — or `undefined` when the two are sized sensibly.
+ *
+ * Each executing run holds a connection for its checkpoint writes, so `runConcurrency > poolMax` means
+ * runs queue on the pool rather than on the queue. That is not an error and not a deadlock, but it is
+ * invisible: throughput flattens, `PG_CONNECTION_TIMEOUT_MS` starts firing under load, and nothing in
+ * the logs points at the pool. Cheaper to say so once at boot.
+ *
+ * `poolMax` is `undefined` when `PG_POOL_MAX` is unset, in which case `pg`'s own default (10) applies —
+ * which is exactly the case worth warning about, since {@link DEFAULT_RUN_CONCURRENCY} is also 10 and a
+ * raised concurrency then silently outgrows a pool nobody chose.
+ */
+declare function describePoolPressure(runConcurrency: number, poolMax: number | undefined): string | undefined;
+
+/**
+ * The one precedence chain for the run timeout: an explicit value (the CLI's `--run-timeout`, or a
+ * `runTimeoutMs` on the deps) wins, else `SKEIN_RUN_TIMEOUT_MS`, else **unset** — no timeout.
+ *
+ * The environment is read and validated even when `explicit` is given, so a typo can't sit unnoticed in
+ * a deployment that also passes the option.
+ *
+ * `env` is injected (defaulting to `process.env`) so callers — and tests — can resolve against an
+ * environment they control.
+ */
+declare function resolveRunTimeoutMs(explicit?: number, env?: NodeJS.ProcessEnv): number | undefined;
 
 /**
  * The one precedence chain for the shutdown drain window: an explicit `worker.shutdownGraceMs` wins,
@@ -186,28 +409,13 @@ declare function resolveRunConcurrency(explicit?: number, env?: NodeJS.ProcessEn
  */
 declare function resolveShutdownGraceMs(explicit?: number, env?: NodeJS.ProcessEnv): number;
 
-/** The checkpoint tuple `[checkpoint, metadata, parentId?]` with the blobs base64-encoded. */
-type SerializedCheckpointTuple = [string, string, string | undefined];
-/** `MemorySaver.storage` (thread → namespace → checkpointId → tuple) with blobs base64-encoded. */
-type SerializedCheckpointStorage = Record<string, Record<string, Record<string, SerializedCheckpointTuple>>>;
-/** `MemorySaver.writes` (key → taskId+idx → `[taskId, channel, blob]`) with the blob base64-encoded. */
-type SerializedCheckpointWrites = Record<string, Record<string, [string, string, string]>>;
-interface CheckpointerSnapshot {
-    storage: SerializedCheckpointStorage;
-    writes: SerializedCheckpointWrites;
-}
-/** A JSON-serializable snapshot of the whole in-memory dev runtime. */
-interface DevStateSnapshot {
-    version: 1;
-    store: MemoryStoreSnapshot;
-    checkpoints: CheckpointerSnapshot;
-}
-
 interface InMemoryRuntimeConfig {
     /** In-memory `ProtocolDeps` (store, queue, bus, checkpointer) around the config's graphs. */
     deps: ProtocolDeps;
     /** CORS mapped from the config's `http.cors`, or `undefined` when none is declared. */
     cors?: CorsOptions;
+    /** The route table to mount, with any `http.disable_*` groups already removed. */
+    routes: readonly RouteBinding[];
 }
 /** Load `langgraph.json`, wiring fresh in-memory drivers and reading its `http.cors` for the adapter. */
 declare function loadInMemoryRuntime(configPath: string, importModule?: ModuleImporter, staticSchemas?: Record<string, GraphSchemas>): Promise<InMemoryRuntimeConfig>;
@@ -293,29 +501,8 @@ declare function embedInMemoryGraphs(graphs: GraphResolver | Record<string, Embe
  */
 declare const createInMemoryDeps: typeof embedInMemoryGraphs;
 
-/**
- * Read a LangGraph `.langgraph_api/` directory and reconstruct skein's `DevStateSnapshot`.
- * Returns `null` when the directory holds none of the expected files (nothing to import).
- */
-declare function readLanggraphDevState(langgraphApiDir: string): Promise<DevStateSnapshot | null>;
-/** Row/checkpoint counts in a snapshot, for CLI + log summaries. */
-interface DevStateCounts {
-    assistants: number;
-    threads: number;
-    runs: number;
-    items: number;
-    /** Threads that carry graph checkpoint history. */
-    checkpointedThreads: number;
-}
-declare function describeSnapshot(snapshot: DevStateSnapshot): DevStateCounts;
-/**
- * Load a `DevStateSnapshot` into a live store + checkpointer — the sink for importing into a real
- * skein deployment (e.g. Postgres). Resource rows go through the driver's `restore` (ids +
- * timestamps preserved, `ON CONFLICT DO NOTHING` so re-runs are safe); checkpoints — graph state +
- * full history — are copied via the public checkpointer API. Throws if the store can't bulk-restore
- * (both first-party drivers can); a custom driver must implement `restore` to be an import target.
- */
-declare function loadSnapshotIntoStore(snapshot: DevStateSnapshot, store: SkeinStore, checkpointer: BaseCheckpointSaver): Promise<void>;
+/** The matcher for `routes`, compiled on first use and reused thereafter. */
+declare function routeMatcherFor(routes: readonly RouteBinding[]): RouteMatcher;
 
 /** The `http.cors` block of a langgraph.json — LangGraph's field names (snake_case). */
 interface LanggraphCorsConfig {
@@ -331,6 +518,19 @@ interface LanggraphCorsConfig {
 declare function toCorsOptions(config: LanggraphCorsConfig): CorsOptions;
 /** Read `http.cors` from a langgraph.json `http` block, mapped to `CorsOptions`, or `undefined`. */
 declare function corsFromHttpConfig(http: unknown): CorsOptions | undefined;
+/**
+ * Read the `http.disable_*` route toggles from a langgraph.json `http` block.
+ *
+ * Only literal `true` disables a group: LangGraph's schema defaults each flag to `false`, and a
+ * truthy-but-not-true value (a `"false"` string from an env-substituted config) must not silently
+ * remove a resource.
+ */
+declare function disabledRoutesFromHttpConfig(http: unknown): DisabledRouteGroups;
+/**
+ * The route table a server should mount given a langgraph.json `http` block — the full table when
+ * nothing is disabled (the same array, not a copy).
+ */
+declare function routesFromHttpConfig(http: unknown): readonly RouteBinding[];
 
 type CorsSetting = true | CorsOptions;
 /**
@@ -369,4 +569,84 @@ declare function sendNodeError(error: unknown, res: ServerResponse, logger?: Log
  */
 declare function stripBasePath(pathname: string, basePath: string): string | null;
 
-export { type ConsoleLogLevel, type ConsoleLoggerOptions, type CorsSetting, type DevStateCounts, type DevStateSnapshot, type EmbeddableGraph, type InMemoryRuntimeConfig, type LanggraphCorsConfig, type ReloadableInMemoryRuntime, type ResolvedProtocolRuntime, type ResolvedRuntimeDeps, type SkeinRuntimeCommonOptions, type SkeinRuntimeOptions, allowedOrigin, applyNodeCors, corsFromHttpConfig, corsPreflightHeaders, corsResponseHeaders, createConsoleLogger, createInMemoryDeps, describeError, describeSnapshot, embedInMemoryGraphs, formatLogMeta, graphMapToResolver, joinList, loadInMemoryRuntime, loadReloadableInMemoryRuntime, loadSnapshotIntoStore, normalizeEmbeddableGraphs, readLanggraphDevState, resolveProtocolRuntime, resolveRunConcurrency, resolveRuntimeDeps, resolveShutdownGraceMs, runFailureIdentity, sendNodeError, sendNodePreflight, sendNodeResponse, stripBasePath, toCorsOptions };
+/**
+ * Memory values that runtimes can report honestly. Missing values are unavailable, not zero.
+ *
+ * No heap *limit* here on purpose: no runtime reports one through this seam, and an optional field
+ * nothing populates reads to a caller as "unavailable" when the truth is that
+ * `node:v8`'s `getHeapStatistics()` answers on all three (see `resolve-runtime.ts`). A field that is
+ * always undefined is how the heap-pressure monitor came to be silently disabled on Bun and Deno.
+ */
+interface RuntimeMemorySnapshot {
+    rssBytes?: number;
+    heapUsedBytes?: number;
+    nativeHeapBytes?: number;
+}
+interface RuntimeSignalSubscription {
+    dispose(): void;
+}
+/** The small platform seam used by runtime-neutral production launchers and diagnostics. */
+interface RuntimeCapabilities {
+    name: "node" | "bun" | "deno";
+    version: string;
+    env: {
+        get(name: string): string | undefined;
+        set(name: string, value: string): void;
+    };
+    clock: {
+        nowEpochMs(): number;
+        nowMonotonicMs(): number;
+    };
+    memory: {
+        read(): RuntimeMemorySnapshot;
+    };
+    signals: {
+        on(signal: "SIGINT" | "SIGTERM", listener: () => void): RuntimeSignalSubscription;
+    };
+    exit(code: number): never;
+}
+interface ProcessLike {
+    version: string;
+    env: Record<string, string | undefined>;
+    memoryUsage(): {
+        rss: number;
+        heapUsed: number;
+    };
+    on(signal: string, listener: () => void): void;
+    off(signal: string, listener: () => void): void;
+    exit(code: number): never;
+}
+interface BunLike {
+    version: string;
+    env: Record<string, string | undefined>;
+    memoryUsage?(): {
+        rss?: number;
+        heapUsed?: number;
+        current?: number;
+    };
+}
+interface DenoLike {
+    version: {
+        deno: string;
+    };
+    env: {
+        get(name: string): string | undefined;
+        set(name: string, value: string): void;
+    };
+    memoryUsage(): {
+        rss: number;
+        heapUsed: number;
+    };
+    addSignalListener(signal: "SIGINT" | "SIGTERM", listener: () => void): void;
+    removeSignalListener(signal: "SIGINT" | "SIGTERM", listener: () => void): void;
+    exit(code: number): never;
+}
+type RuntimeGlobal = typeof globalThis & {
+    process?: ProcessLike;
+    Bun?: BunLike;
+    Deno?: DenoLike;
+};
+/** Detect Node, Bun, or Deno without importing a runtime-specific module. */
+declare function detectRuntimeCapabilities(scope?: RuntimeGlobal): RuntimeCapabilities;
+
+export { type ConsoleLogLevel, type ConsoleLoggerOptions, type CorsSetting, DEFAULT_HEAP_SAMPLE_MS, DEFAULT_HEAP_WARN_PERCENT, DevStateSnapshot, type EmbeddableGraph, type FileReader, HEAP_REARM_MARGIN_PERCENT, HEAP_REARM_PERCENT, type HeapHeadroom, type HeapPressureContext, type HeapPressureMonitor, type HeapPressureMonitorOptions, type InMemoryRuntimeConfig, type IntervalHandle, type LanggraphCorsConfig, type ReloadableInMemoryRuntime, type ResolvedMemoryBusLimits, type ResolvedProtocolRuntime, type ResolvedRuntimeDeps, type RuntimeCapabilities, type RuntimeMemorySnapshot, type RuntimeSignalSubscription, type SkeinRuntimeCommonOptions, type SkeinRuntimeOptions, allowedOrigin, applyNodeCors, checkHeapHeadroom, corsFromHttpConfig, corsPreflightHeaders, corsResponseHeaders, createConsoleLogger, createInMemoryDeps, describeError, describeHeapHeadroom, describePoolPressure, detectRuntimeCapabilities, disabledRoutesFromHttpConfig, embedInMemoryGraphs, formatLogMeta, graphMapToResolver, joinList, loadInMemoryRuntime, loadReloadableInMemoryRuntime, normalizeEmbeddableGraphs, readContainerMemoryLimit, resolveCronTickMs, resolveHeapPressureOptions, resolveMaxPageSize, resolveMemoryBusLimits, resolveProtocolRuntime, resolveRunConcurrency, resolveRunTimeoutMs, resolveRuntimeDeps, resolveShutdownGraceMs, routeMatcherFor, routesFromHttpConfig, runFailureIdentity, sendNodeError, sendNodePreflight, sendNodeResponse, startHeapPressureMonitor, stripBasePath, toCorsOptions };