deepline 0.1.199 → 0.1.201

package/dist/bundling-sources/shared_libs/play-runtime/governor/app-runtime-rate-state-backend.ts

@@ -12,7 +12,7 @@ import {
 } from './rate-state-backend';
 
 /**
- * Permits leased per app-runtime round trip for the Hatchet/Node substrate.
+ * Permits leased per app-runtime round trip for the direct Node substrate.
  *
  * Eight keeps DB/API round trips amortized for batch-heavy maps while limiting
  * stale-block over-issue to 8 x live runner processes per bucket/window.

package/dist/bundling-sources/shared_libs/play-runtime/governor/governor.ts

@@ -19,11 +19,11 @@ import {
   resolveExecutionPolicy,
   resolveRowConcurrency,
 } from './policy';
+import { type PacingRule, type RateStateBackend } from './rate-state-backend';
 import {
-  noopPacingPermit,
-  type PacingRule,
-  type RateStateBackend,
-} from './rate-state-backend';
+  createInMemoryAdaptiveAdmission,
+  type RuntimeAdaptiveAdmission,
+} from './adaptive-admission';
 
 export interface WorkLease {
   /** Free the slot / pacing permit. Idempotent. MUST be called in a finally. */
@@ -74,6 +74,25 @@ export type PacingResolver = (
   toolId: string,
 ) => Promise<{ provider: string; rules: PacingRule[] } | null>;
 
+export function defaultPacingForTool(
+  toolId: string,
+  policy: ResolvedExecutionPolicy,
+): { provider: string; rules: PacingRule[] } {
+  return {
+    // Unknown providers still need a stable bucket. Tool id is the only
+    // substrate-neutral key available when the runtime has no queue hints.
+    provider: `tool:${toolId}`,
+    rules: [
+      {
+        ruleId: `default:${toolId}`,
+        requestsPerWindow: policy.pacing.defaultProviderRequestsPerSecond,
+        windowMs: 1_000,
+        maxConcurrency: null,
+      },
+    ],
+  };
+}
+
 export interface PlayExecutionGovernor {
   readonly adapter: AdapterId;
   readonly policy: ResolvedExecutionPolicy;
@@ -132,6 +151,12 @@ export interface PlayExecutionGovernor {
     retryAfterMs: number;
   }): void;
 
+  /** Feed clean provider calls back into adaptive admission. */
+  observeProviderSuccess(input: {
+    provider: string;
+    latencyMs?: number | null;
+  }): void;
+
   snapshot(): GovernanceSnapshot;
 }
 
@@ -140,6 +165,7 @@ interface GovernorInput {
   scope: { orgId: string; rootRunId: string };
   rateState: RateStateBackend;
   resolvePacing: PacingResolver;
+  adaptiveAdmission?: RuntimeAdaptiveAdmission;
   resume?: GovernanceSnapshot;
 }
 
@@ -226,35 +252,79 @@ export function createPlayExecutionGovernor(
   const rowSlots = new Semaphore(policy.concurrency.rowMax);
   const childPlaySlots = new Semaphore(policy.concurrency.childPlay);
   const toolSlots = new Semaphore(policy.concurrency.toolCalls);
+  const adaptiveAdmission =
+    input.adaptiveAdmission ??
+    createInMemoryAdaptiveAdmission({
+      initialRequestsPerSecond: policy.pacing.defaultProviderRequestsPerSecond,
+      maxRequestsPerSecond: policy.pacing.suggestedMaxParallelism,
+    });
 
   const bucketId = (provider: string) => `${input.scope.orgId}:${provider}`;
 
+  async function resolveAdaptivePacing(toolId: string): Promise<{
+    provider: string;
+    rules: PacingRule[];
+  }> {
+    const resolvedPacing = await input.resolvePacing(toolId);
+    const declaredPacing =
+      resolvedPacing && resolvedPacing.rules.length > 0 ? resolvedPacing : null;
+    return adaptiveAdmission.resolvePacing({
+      orgId: input.scope.orgId,
+      toolId,
+      declaredPacing,
+      fallbackPacing: defaultPacingForTool(toolId, policy),
+    });
+  }
+
   function chargeBudget(kind: BudgetKind, amount = 1): void {
     switch (kind) {
       case 'playCall':
         state.playCallCount += amount;
         if (state.playCallCount > policy.budgets.maxPlayCallCount)
-          throw new GovernorBudgetError('playCall', state.playCallCount, policy.budgets.maxPlayCallCount);
+          throw new GovernorBudgetError(
+            'playCall',
+            state.playCallCount,
+            policy.budgets.maxPlayCallCount,
+          );
         return;
       case 'toolCall':
         state.toolCallCount += amount;
         if (state.toolCallCount > policy.budgets.maxToolCallCount)
-          throw new GovernorBudgetError('toolCall', state.toolCallCount, policy.budgets.maxToolCallCount);
+          throw new GovernorBudgetError(
+            'toolCall',
+            state.toolCallCount,
+            policy.budgets.maxToolCallCount,
+          );
         return;
       case 'retry':
         state.retryCount += amount;
         if (state.retryCount > policy.budgets.maxRetryCount)
-          throw new GovernorBudgetError('retry', state.retryCount, policy.budgets.maxRetryCount);
+          throw new GovernorBudgetError(
+            'retry',
+            state.retryCount,
+            policy.budgets.maxRetryCount,
+          );
         return;
       case 'descendant':
         state.descendantCount += amount;
         if (state.descendantCount > policy.budgets.maxDescendants)
-          throw new GovernorBudgetError('descendant', state.descendantCount, policy.budgets.maxDescendants);
+          throw new GovernorBudgetError(
+            'descendant',
+            state.descendantCount,
+            policy.budgets.maxDescendants,
+          );
         return;
       case 'waterfallStep':
         state.waterfallStepExecutions += amount;
-        if (state.waterfallStepExecutions > policy.budgets.maxWaterfallStepExecutions)
-          throw new GovernorBudgetError('waterfallStep', state.waterfallStepExecutions, policy.budgets.maxWaterfallStepExecutions);
+        if (
+          state.waterfallStepExecutions >
+          policy.budgets.maxWaterfallStepExecutions
+        )
+          throw new GovernorBudgetError(
+            'waterfallStep',
+            state.waterfallStepExecutions,
+            policy.budgets.maxWaterfallStepExecutions,
+          );
         return;
     }
   }
@@ -273,15 +343,12 @@ export function createPlayExecutionGovernor(
       //    resolver, so callers only need the toolId. No rules → no pacing.
       let permit: { release(): void };
       try {
-        const pacing = await input.resolvePacing(toolId);
-        permit =
-          pacing && pacing.rules.length > 0
-            ? await input.rateState.acquire({
-                bucketId: bucketId(pacing.provider),
-                rules: pacing.rules,
-                signal: opts?.signal,
-              })
-            : noopPacingPermit();
+        const pacing = await resolveAdaptivePacing(toolId);
+        permit = await input.rateState.acquire({
+          bucketId: bucketId(pacing.provider),
+          rules: pacing.rules,
+          signal: opts?.signal,
+        });
       } catch (error) {
         slot.release();
         throw error;
@@ -307,8 +374,7 @@ export function createPlayExecutionGovernor(
     },
 
     async suggestedParallelism(toolId, fallback) {
-      const pacing = await input.resolvePacing(toolId);
-      if (!pacing || pacing.rules.length === 0) return fallback;
+      const pacing = await resolveAdaptivePacing(toolId);
       const limits = pacing.rules.flatMap((rule) =>
         rule.maxConcurrency != null
           ? [rule.requestsPerWindow, rule.maxConcurrency]
@@ -324,16 +390,26 @@ export function createPlayExecutionGovernor(
 
     forkChild(childInput) {
       if (state.ancestryPlayIds.includes(childInput.childPlayName)) {
-        const chain = [...state.ancestryPlayIds, childInput.childPlayName].join(' -> ');
+        const chain = [...state.ancestryPlayIds, childInput.childPlayName].join(
+          ' -> ',
+        );
         throw new Error(`Recursive play graph detected: ${chain}`);
       }
       const nextDepth = state.callDepth + 1;
       if (nextDepth > policy.budgets.maxPlayCallDepth)
-        throw new GovernorBudgetError('playDepth', nextDepth, policy.budgets.maxPlayCallDepth);
+        throw new GovernorBudgetError(
+          'playDepth',
+          nextDepth,
+          policy.budgets.maxPlayCallDepth,
+        );
       const parentKey = state.currentPlayId;
       const nextParent = (state.parentChildCalls[parentKey] ?? 0) + 1;
       if (nextParent > policy.budgets.maxChildPlayCallsPerParent)
-        throw new GovernorBudgetError('childPerParent', nextParent, policy.budgets.maxChildPlayCallsPerParent);
+        throw new GovernorBudgetError(
+          'childPerParent',
+          nextParent,
+          policy.budgets.maxChildPlayCallsPerParent,
+        );
       // Charge the run-wide play/descendant budgets on the parent. Charged at
       // fork time (not after the caller's child-play slot acquire) and never
       // refunded if that acquire fails — see the forkChild interface doc.
@@ -357,15 +433,29 @@ export function createPlayExecutionGovernor(
       };
     },
 
-    resolveRowConcurrency: (requested) => resolveRowConcurrency(policy, requested),
+    resolveRowConcurrency: (requested) =>
+      resolveRowConcurrency(policy, requested),
 
     reportProviderBackpressure(bp) {
+      adaptiveAdmission.observeProviderBackpressure({
+        orgId: input.scope.orgId,
+        provider: bp.provider,
+        retryAfterMs: bp.retryAfterMs,
+      });
       input.rateState.penalize({
         bucketId: bucketId(bp.provider),
         cooldownMs: bp.retryAfterMs,
       });
     },
 
+    observeProviderSuccess(success) {
+      adaptiveAdmission.observeProviderSuccess({
+        orgId: input.scope.orgId,
+        provider: success.provider,
+        latencyMs: success.latencyMs,
+      });
+    },
+
     snapshot: () => ({
       ...state,
       ancestryPlayIds: [...state.ancestryPlayIds],

package/dist/bundling-sources/shared_libs/play-runtime/governor/policy.ts

@@ -8,12 +8,12 @@
  * CONTEXT.md.
  *
  * Tuning philosophy (product decision):
- *  - Caps are GENEROUS and tuned for fast execution. They are runaway /
- *    anti-starvation guards, NOT per-workload throttles. A legitimate large run
- *    should never hit them.
- *  - The real-time bounds on a run are (a) the wall-clock runtime cap and
- *    (b) per-provider rate pacing. The counters below only stop pathological
- *    recursion / fan-out.
+ *  - Caps are explicit resource admission boundaries. A run should queue behind
+ *    them inside the executor instead of manufacturing thousands of promises,
+ *    receipts, sockets, or row payload copies up front.
+ *  - The real-time bounds on outbound work are still per-provider pacing and
+ *    provider latency. Row concurrency exists to keep the sandbox healthy while
+ *    enough work is admitted to saturate normal provider RPS.
  *  - Every value is an EXPLICIT, finite cap. Nothing here is unbounded — there
  *    is no `null`, no "off", no implicit infinity. Unaccounted resource use
  *    must be impossible.
@@ -90,15 +90,15 @@ export interface ResolvedExecutionPolicy {
  */
 export const SHARED_EXECUTION_POLICY: ResolvedExecutionPolicy = {
   concurrency: {
-    // Map row concurrency is platform-controlled — customers cannot set it — so
-    // every map runs at the ceiling: high enough that per-provider pacing (not
-    // the row pool) is the bottleneck even for multi-step waterfall rows. Pure-JS
-    // maps use a separate fast path and are not bound by this. Kept == rowMax so
-    // the default and the cap are the same single platform value.
-    rowDefault: 2_000,
-    // Hard cap. Above this, more in-flight rows only park memory — outbound is
-    // already bounded by tool concurrency + per-provider pacing.
-    rowMax: 2_000,
+    // Logical row target. A 1,000-row window can fill five 200-item provider
+    // batches or keep a 100-RPS unbatched provider fed; the runtime's shared
+    // resident-byte admission calculator clamps fat rows below this target.
+    // Pending rows remain indexes, not promises or pre-claimed receipts.
+    rowDefault: 1_000,
+    // Finite global ceiling across concurrent maps in one run. This intentionally
+    // matches the default: throughput grows through provider pacing/batching,
+    // while row payload size can only reduce admission through the byte budget.
+    rowMax: 1_000,
     // Concurrent child-play launches. Generous; each child is a real launch, so
     // this is the one value most likely to need a documented esm_workers
     // override if isolate pressure shows up in E2E.
@@ -121,13 +121,13 @@ export const SHARED_EXECUTION_POLICY: ResolvedExecutionPolicy = {
   pacing: {
     // Undeclared providers; declared providers (rate-limit-definitions.ts) win.
     defaultProviderRequestsPerSecond: 10,
-    suggestedMaxParallelism: 50,
+    suggestedMaxParallelism: 256,
     // Worker isolate pacing knobs. The budget module owns platform accounting;
     // the Governor owns the policy values that decide when work is chunked.
     workerYieldElapsedMs: 45_000,
     // Fallback wave width for batched tool chunks that carry no provider pacing
     // hint. This is only a floor for the undeclared case: it stays bounded by
-    // suggestedMaxParallelism (50) above, and declared providers still get
+    // suggestedMaxParallelism above, and declared providers still get
     // tightened by their per-provider pacing (rate-limit-definitions.ts). Raised
     // 4 -> 16 so full batches fan out wide enough to close the map-throughput gap
     // without over-running providers that actually declare limits.

package/dist/bundling-sources/shared_libs/play-runtime/lease-policy.ts

@@ -50,3 +50,25 @@ export function runtimeLeaseHeartbeatIntervalMs(ttlMs: number): number {
   }
   return Math.max(1, Math.floor(ttlMs / PLAY_RUNTIME_LEASE_HEARTBEAT_DIVISOR));
 }
+
+/**
+ * The receipt store is authoritative for lease duration. Executors may not
+ * inherit the coordinator's environment, so derive renewal cadence from the
+ * expiry returned with the actual claim instead of assuming a local TTL.
+ */
+export function runtimeLeaseHeartbeatIntervalFromExpiry(input: {
+  leaseExpiresAt?: string | null;
+  fallbackTtlMs: number;
+  nowMs?: number;
+}): number {
+  const expiresAtMs = input.leaseExpiresAt
+    ? Date.parse(input.leaseExpiresAt)
+    : Number.NaN;
+  const nowMs = input.nowMs ?? Date.now();
+  const remainingMs = expiresAtMs - nowMs;
+  return runtimeLeaseHeartbeatIntervalMs(
+    Number.isFinite(remainingMs) && remainingMs > 0
+      ? remainingMs
+      : input.fallbackTtlMs,
+  );
+}

package/dist/bundling-sources/shared_libs/play-runtime/ledger-safe-payload.ts

@@ -1,6 +1,7 @@
 import { createSecretRedactionContext } from './secret-redaction';
+import { RUNTIME_RECEIPT_OUTPUT_MAX_BYTES } from './output-size-limits';
 
-export const MAX_LEDGER_RESULT_PAYLOAD_BYTES = 2_500_000;
+export const MAX_LEDGER_RESULT_PAYLOAD_BYTES = RUNTIME_RECEIPT_OUTPUT_MAX_BYTES;
 export const MAX_LEDGER_LOG_LINES_PER_EVENT = 500;
 export const MAX_LEDGER_LOG_LINE_LENGTH = 2_000;
 

package/dist/bundling-sources/shared_libs/play-runtime/live-events.ts

@@ -1,6 +1,5 @@
 export type PlayLiveEventSource =
   | 'worker'
-  | 'temporal'
   | 'convex'
   | 'play'
   | 'system';

package/dist/bundling-sources/shared_libs/play-runtime/map-memory-limits.ts

@@ -0,0 +1,265 @@
+export const NODE_RUNTIME_MAP_MEMORY_BUDGET_BYTES = 512 * 1024 * 1024;
+export const NODE_RUNTIME_MAP_ACTIVE_ROWS_MEMORY_BUDGET_BYTES =
+  384 * 1024 * 1024;
+export const NODE_RUNTIME_MAP_MATERIALIZED_MEMORY_MULTIPLIER = 4;
+export const NODE_RUNTIME_MAP_ACTIVE_ROW_MEMORY_MULTIPLIER = 3;
+export const NODE_RUNTIME_MAP_ROW_OVERHEAD_BYTES = 512;
+
+export type RuntimeMapMemoryLimits = {
+  materializedBudgetBytes: number;
+  activeRowsBudgetBytes: number;
+};
+
+export type RuntimeMapMemoryEstimate = {
+  rowCount: number;
+  serializedBytes: number;
+  estimatedResidentBytes: number;
+  largestRowBytes: number;
+};
+
+export type RuntimeMapRowAdmission = {
+  concurrency: number;
+  estimatedBytesPerActiveRow: number;
+  estimatedResidentBytes: number;
+};
+
+export class RuntimeMapMemoryLimitError extends Error {
+  readonly code = 'RUNTIME_MAP_MEMORY_LIMIT_EXCEEDED';
+  constructor(input: {
+    mapName: string;
+    phase: 'materialize' | 'active_rows' | 'retained_rows';
+    estimate: RuntimeMapMemoryEstimate;
+    budgetBytes: number;
+    activeRows?: number;
+    rowConcurrency?: number;
+  }) {
+    const active =
+      input.activeRows === undefined
+        ? ''
+        : ` activeRows=${input.activeRows}` +
+          (input.rowConcurrency === undefined
+            ? ''
+            : ` rowConcurrency=${input.rowConcurrency}`);
+    const stopPoint =
+      input.phase === 'materialize'
+        ? ' before provider calls'
+        : input.phase === 'active_rows'
+          ? ' before row resolver bodies start'
+          : '';
+    super(
+      `Runtime map memory limit exceeded for ctx.dataset("${input.mapName}") during ${input.phase}: ` +
+        `estimatedResidentBytes=${input.estimate.estimatedResidentBytes} ` +
+        `budgetBytes=${input.budgetBytes} rowCount=${input.estimate.rowCount} ` +
+        `serializedBytes=${input.estimate.serializedBytes} largestRowBytes=${input.estimate.largestRowBytes}${active}. ` +
+        `This run would risk sandbox OOM. Deepline stops here${stopPoint} instead of silently lowering concurrency. ` +
+        'Reduce row payload size, stage bulky blobs, or split the input into smaller runs.',
+    );
+    this.name = 'RuntimeMapMemoryLimitError';
+  }
+}
+
+const textEncoder =
+  typeof TextEncoder === 'undefined' ? null : new TextEncoder();
+
+export function runtimeMapJsonByteLength(value: unknown): number {
+  const serialized = JSON.stringify(value);
+  if (serialized === undefined) return 0;
+  return textEncoder?.encode(serialized).byteLength ?? serialized.length;
+}
+
+export function defaultRuntimeMapMemoryLimits(): RuntimeMapMemoryLimits {
+  return {
+    materializedBudgetBytes: NODE_RUNTIME_MAP_MEMORY_BUDGET_BYTES,
+    activeRowsBudgetBytes: NODE_RUNTIME_MAP_ACTIVE_ROWS_MEMORY_BUDGET_BYTES,
+  };
+}
+
+export function resolveRuntimeMapMemoryLimits(
+  override?: Partial<RuntimeMapMemoryLimits> | null,
+): RuntimeMapMemoryLimits {
+  const defaults = defaultRuntimeMapMemoryLimits();
+  return {
+    materializedBudgetBytes: positiveBudget(
+      override?.materializedBudgetBytes,
+      defaults.materializedBudgetBytes,
+    ),
+    activeRowsBudgetBytes: positiveBudget(
+      override?.activeRowsBudgetBytes,
+      defaults.activeRowsBudgetBytes,
+    ),
+  };
+}
+
+function positiveBudget(value: number | undefined, fallback: number): number {
+  if (!Number.isFinite(value) || value === undefined) return fallback;
+  return Math.max(1, Math.floor(value));
+}
+
+export function estimateRuntimeMapMaterializedMemory(input: {
+  rowCount: number;
+  serializedBytes: number;
+  largestRowBytes: number;
+}): RuntimeMapMemoryEstimate {
+  return {
+    rowCount: input.rowCount,
+    serializedBytes: input.serializedBytes,
+    largestRowBytes: input.largestRowBytes,
+    estimatedResidentBytes:
+      input.serializedBytes * NODE_RUNTIME_MAP_MATERIALIZED_MEMORY_MULTIPLIER +
+      input.rowCount * NODE_RUNTIME_MAP_ROW_OVERHEAD_BYTES,
+  };
+}
+
+export function estimateRuntimeMapRowsMemory(
+  rows: readonly unknown[],
+): RuntimeMapMemoryEstimate {
+  let serializedBytes = 0;
+  let largestRowBytes = 0;
+  for (const row of rows) {
+    const rowBytes = runtimeMapJsonByteLength(row);
+    serializedBytes += rowBytes;
+    largestRowBytes = Math.max(largestRowBytes, rowBytes);
+  }
+  return estimateRuntimeMapMaterializedMemory({
+    rowCount: rows.length,
+    serializedBytes,
+    largestRowBytes,
+  });
+}
+
+type RuntimeMapRowsTrackerInput = {
+  mapName: string;
+  budgetBytes?: number;
+};
+
+type RuntimeMapRowsTracker = {
+  track(row: unknown): void;
+  estimate(): RuntimeMapMemoryEstimate;
+};
+
+function createRuntimeMapRowsTracker(
+  input: RuntimeMapRowsTrackerInput,
+  phase: 'materialize' | 'retained_rows',
+): RuntimeMapRowsTracker {
+  const budgetBytes = positiveBudget(
+    input.budgetBytes,
+    NODE_RUNTIME_MAP_MEMORY_BUDGET_BYTES,
+  );
+  let rowCount = 0;
+  let serializedBytes = 0;
+  let largestRowBytes = 0;
+  const estimate = () =>
+    estimateRuntimeMapMaterializedMemory({
+      rowCount,
+      serializedBytes,
+      largestRowBytes,
+    });
+  return {
+    track(row) {
+      const rowBytes = runtimeMapJsonByteLength(row);
+      rowCount += 1;
+      serializedBytes += rowBytes;
+      largestRowBytes = Math.max(largestRowBytes, rowBytes);
+      const current = estimate();
+      if (current.estimatedResidentBytes > budgetBytes) {
+        throw new RuntimeMapMemoryLimitError({
+          mapName: input.mapName,
+          phase,
+          estimate: current,
+          budgetBytes,
+        });
+      }
+    },
+    estimate,
+  };
+}
+
+export function createRuntimeMapMaterializationTracker(
+  input: RuntimeMapRowsTrackerInput,
+): RuntimeMapRowsTracker {
+  return createRuntimeMapRowsTracker(input, 'materialize');
+}
+
+export function createRuntimeMapRetainedRowsTracker(
+  input: RuntimeMapRowsTrackerInput,
+): RuntimeMapRowsTracker {
+  return createRuntimeMapRowsTracker(input, 'retained_rows');
+}
+
+export function assertRuntimeMapActiveRowsWithinMemoryLimit(input: {
+  mapName: string;
+  rowCount: number;
+  rowConcurrency: number;
+  largestRowBytes: number;
+  activeRowsBudgetBytes?: number;
+}): void {
+  const activeRows = Math.min(
+    Math.max(0, input.rowCount),
+    Math.max(1, Math.floor(input.rowConcurrency)),
+  );
+  const estimate: RuntimeMapMemoryEstimate = {
+    rowCount: input.rowCount,
+    serializedBytes: input.largestRowBytes * activeRows,
+    largestRowBytes: input.largestRowBytes,
+    estimatedResidentBytes:
+      input.largestRowBytes *
+        activeRows *
+        NODE_RUNTIME_MAP_ACTIVE_ROW_MEMORY_MULTIPLIER +
+      activeRows * NODE_RUNTIME_MAP_ROW_OVERHEAD_BYTES,
+  };
+  const budgetBytes = positiveBudget(
+    input.activeRowsBudgetBytes,
+    NODE_RUNTIME_MAP_ACTIVE_ROWS_MEMORY_BUDGET_BYTES,
+  );
+  if (estimate.estimatedResidentBytes > budgetBytes) {
+    throw new RuntimeMapMemoryLimitError({
+      mapName: input.mapName,
+      phase: 'active_rows',
+      estimate,
+      budgetBytes,
+      activeRows,
+      rowConcurrency: input.rowConcurrency,
+    });
+  }
+}
+
+/**
+ * Resolve a row-worker window from the shared concurrency target and a concrete
+ * resident-byte budget. Pending rows remain indexes, so only this admitted
+ * window contributes active row copies/promises. If one row cannot fit, fail
+ * before any resolver body starts; otherwise memory pressure is normal
+ * backpressure and reduces the window explicitly.
+ */
+export function resolveRuntimeMapRowAdmission(input: {
+  rowCount: number;
+  requestedConcurrency: number;
+  largestRowBytes: number;
+  activeRowsBudgetBytes?: number;
+}): RuntimeMapRowAdmission {
+  const rowCount = Math.max(0, Math.floor(input.rowCount));
+  const requestedConcurrency = Math.max(
+    1,
+    Math.floor(input.requestedConcurrency),
+  );
+  const largestRowBytes = Math.max(0, Math.floor(input.largestRowBytes));
+  const budgetBytes = positiveBudget(
+    input.activeRowsBudgetBytes,
+    NODE_RUNTIME_MAP_ACTIVE_ROWS_MEMORY_BUDGET_BYTES,
+  );
+  const estimatedBytesPerActiveRow =
+    largestRowBytes * NODE_RUNTIME_MAP_ACTIVE_ROW_MEMORY_MULTIPLIER +
+    NODE_RUNTIME_MAP_ROW_OVERHEAD_BYTES;
+
+  const maxConcurrencyByMemory = Math.floor(
+    budgetBytes / Math.max(1, estimatedBytesPerActiveRow),
+  );
+  const concurrency =
+    rowCount === 0
+      ? 0
+      : Math.min(rowCount, requestedConcurrency, maxConcurrencyByMemory);
+  return {
+    concurrency,
+    estimatedBytesPerActiveRow,
+    estimatedResidentBytes: estimatedBytesPerActiveRow * concurrency,
+  };
+}