deepline 0.1.243 → 0.1.244

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/map-chunk-plan.ts

@@ -1,920 +0,0 @@
-import {
-  chooseMapChunkSize,
-  EXECUTION_PLAN_DEFAULTS,
-  type ExecutionPlan,
-} from '../../../../shared_libs/play-runtime/execution-plan';
-import { TOOL_CALLING_MAP_CHUNK_SIZE } from '../../../../shared_libs/play-runtime/map-chunk-limits';
-import { getPlayRuntimeBatchStrategy } from '../../../../shared_libs/play-runtime/play-runtime-batching-registry';
-import {
-  WORKER_PLATFORM_SUBREQUESTS_PER_UNBATCHED_TOOL_CALL,
-  WORKER_PLATFORM_SUBREQUEST_SOFT_LIMIT,
-} from './worker-platform-budget';
-import {
-  flattenStaticSubsteps,
-  getTopLevelPipelineSubsteps,
-  type PlayStaticColumnProducer,
-  type PlayStaticPipeline,
-  type PlayStaticSubstep,
-} from '../../../../shared_libs/plays/static-pipeline';
-
-export const CACHE_ENABLED_SIMPLE_MAP_CHUNK_SIZE = 10_000;
-export { TOOL_CALLING_MAP_CHUNK_SIZE };
-export const WORKER_SUBREQUEST_SAFE_TOOL_CALLS_PER_CHUNK =
-  TOOL_CALLING_MAP_CHUNK_SIZE;
-export const UNBATCHED_TOOL_SUBREQUESTS_PER_CHUNK_BUDGET =
-  WORKER_PLATFORM_SUBREQUEST_SOFT_LIMIT;
-export const SUBREQUESTS_PER_UNBATCHED_TOOL_CALL =
-  WORKER_PLATFORM_SUBREQUESTS_PER_UNBATCHED_TOOL_CALL;
-
-// A batched tool over a chunk of N rows does not spend the unbatched provider
-// budget for every row. Durable receipt claim/complete/fail are bulk RPCs for
-// the whole drained tool group, but provider execution still happens once per
-// compiled batch. Static planning cannot know input-dependent bucket keys, so
-// it must assume worst-case provider fanout (one compiled batch per row) unless
-// the batching registry grows a proof that all rows share a bucket.
-export const BATCHED_TOOL_SUBREQUESTS_PER_BATCH = 2;
-export const BULK_RECEIPT_SUBREQUESTS_PER_CHUNK = 3;
-// Conservative batch size assumed only when a batchable tool's registry
-// maxBatchSize is unknown. Smaller = more batches = more subrequests = safer.
-export const ASSUMED_BATCH_SIZE_FLOOR = 100;
-const MAX_BATCHABLE_SUBREQUEST_SAFE_ROWS = 1_000_000;
-
-function assumedBatchSizeFor(minBatchableBatchSize: number): number {
-  return minBatchableBatchSize > 0
-    ? minBatchableBatchSize
-    : ASSUMED_BATCH_SIZE_FLOOR;
-}
-
-// Per-chunk subrequest cost of the batchable tool work in a map chunk. Shared
-// by the chunk sizer (inverts it to find safe rows/chunk) and the live budget
-// projection in entry.ts so the two never drift.
-export function estimateBatchedToolChunkSubrequests(input: {
-  batchableToolCallsPerRow: number;
-  coalescedBatchableToolCallsPerRow?: number;
-  rows: number;
-  assumedBatchSize: number;
-}): number {
-  if (input.batchableToolCallsPerRow <= 0 || input.rows <= 0) return 0;
-  const toolCallsPerRow = Math.max(1, input.batchableToolCallsPerRow);
-  const coalescedToolCallsPerRow = Math.min(
-    toolCallsPerRow,
-    Math.max(0, input.coalescedBatchableToolCallsPerRow ?? 0),
-  );
-  const worstCaseToolCallsPerRow = Math.max(
-    0,
-    toolCallsPerRow - coalescedToolCallsPerRow,
-  );
-  const coalescedCompiledBatches =
-    Math.ceil(input.rows / Math.max(1, input.assumedBatchSize)) *
-    coalescedToolCallsPerRow;
-  const worstCaseCompiledBatches = input.rows * worstCaseToolCallsPerRow;
-  return (
-    BATCHED_TOOL_SUBREQUESTS_PER_BATCH *
-      (coalescedCompiledBatches + worstCaseCompiledBatches) +
-    BULK_RECEIPT_SUBREQUESTS_PER_CHUNK * toolCallsPerRow
-  );
-}
-export type WorkerMapChunkPlanInput = {
-  mapName: string;
-  rowCountHint: number | null;
-  executionPlan?: ExecutionPlan | null;
-  staticPipeline?: PlayStaticPipeline | null;
-};
-
-type PlanMap = ExecutionPlan['maps'][number];
-type ChunkSizingMap = Pick<
-  PlanMap,
-  | 'mapName'
-  | 'tableNamespace'
-  | 'outputFields'
-  | 'defaultChunkSize'
-  | 'stepsPerChunk'
-> &
-  Partial<
-    Pick<PlanMap, 'externalStepFields' | 'stepFields' | 'waterfallStages'>
-  >;
-type ChunkSizingPlan = {
-  maps: ChunkSizingMap[];
-  toolDeclarations?: ExecutionPlan['toolDeclarations'];
-  softWorkflowStepBudget?: number | null;
-};
-
-type MapToolStats = [
-  totalToolCount: number,
-  unbatchedToolCount: number,
-  unbatchedSubrequestCount: number,
-  // Smallest registry maxBatchSize across the batchable tools counted so far
-  // (0 when no batchable tool has been seen). Smallest = most batches = most
-  // subrequests, so it is the conservative choice for chunk sizing.
-  minBatchableBatchSize: number,
-  coalescedBatchableToolCount: number,
-];
-type MapControlWorkStats = {
-  childPlaySubmits: number;
-  eventWaits: number;
-};
-
-const EMPTY_CONTROL_WORK_STATS: MapControlWorkStats = {
-  childPlaySubmits: 0,
-  eventWaits: 0,
-};
-
-export type WorkerMapDispatchPlan = {
-  rowsPerChunk: number;
-  estimatedExternalStepsPerRow: number;
-  workEstimate: WorkerMapWorkEstimate;
-  reason:
-    | 'external-pressure'
-    | 'tool-free-large-cache'
-    | 'tool-free-plan'
-    | 'default-plan';
-};
-
-export type WorkerMapWorkEstimate = {
-  cpuRowsPerRow: number;
-  runtimeSheetReadsPerChunk: number;
-  runtimeSheetWritesPerChunk: number;
-  durableReceiptOpsPerRow: number;
-  providerToolCallsPerRow: number;
-  unbatchedProviderToolCallsPerRow: number;
-  // Registry batch size assumed for the batchable tools in this map (smallest
-  // maxBatchSize across them, or ASSUMED_BATCH_SIZE_FLOOR when unknown). Drives
-  // the batched-tool subrequest projection.
-  assumedBatchSize: number;
-  coalescedBatchableProviderToolCallsPerRow: number;
-  childPlaySubmitsPerRow: number;
-  eventWaitsPerRow: number;
-};
-
-/**
- * Keep one externally-effectful Workflow chunk inside the same bounded row
- * window used by runtime admission. The static planner may choose a larger
- * chunk when provider calls coalesce, but a chunk is still the smallest point
- * where the dispatcher can cross a durable sleep boundary. Capping only the
- * native Workflow execution chunk prevents a slow 5k provider chunk from
- * outliving one invocation and being retried before the dispatcher can yield.
- */
-export function workflowSafeMapRowsPerChunk(input: {
-  plannedRowsPerChunk: number;
-  rowAdmissionWindow: number;
-  hasWorkflowStep: boolean;
-  hasExternalSideEffects: boolean;
-}): number {
-  const plannedRowsPerChunk = Math.max(
-    1,
-    Math.floor(input.plannedRowsPerChunk),
-  );
-  if (!input.hasWorkflowStep || !input.hasExternalSideEffects) {
-    return plannedRowsPerChunk;
-  }
-  const rowAdmissionWindow = Math.max(1, Math.floor(input.rowAdmissionWindow));
-  return Math.min(plannedRowsPerChunk, rowAdmissionWindow);
-}
-
-function fieldRoot(field: string | null | undefined): string {
-  return String(field ?? '').split('.', 1)[0] ?? '';
-}
-
-function declarationBelongsToMapOutput(
-  declaration: { field?: string | null },
-  outputFields: readonly string[],
-  externalStepFields: readonly string[] = [],
-): boolean {
-  const fieldName = declaration.field;
-  if (fieldName == null) return true;
-  if (
-    outputFields.some(
-      (field) => fieldName === field || fieldName.startsWith(`${field}.`),
-    )
-  ) {
-    return true;
-  }
-  return externalStepFields.some(
-    (field) => fieldName === field || fieldName.endsWith(`.${field}`),
-  );
-}
-
-function countTool(
-  toolId: string,
-  options?: { staticSingleBucket?: boolean },
-): MapToolStats {
-  const batchStrategy = getPlayRuntimeBatchStrategy(toolId);
-  if (batchStrategy !== null) {
-    return [
-      1,
-      0,
-      0,
-      Math.max(1, Math.floor(batchStrategy.maxBatchSize)),
-      options?.staticSingleBucket === true ? 1 : 0,
-    ];
-  }
-  return [1, 1, SUBREQUESTS_PER_UNBATCHED_TOOL_CALL, 0, 0];
-}
-
-function minPositiveBatchSize(a: number, b: number): number {
-  if (a <= 0) return Math.max(0, b);
-  if (b <= 0) return Math.max(0, a);
-  return Math.min(a, b);
-}
-
-function minProviderBranchCoalescedCount(
-  branchStats: readonly MapToolStats[],
-): number {
-  let minCoalesced: number | null = null;
-  for (const [total, , , , coalesced] of branchStats) {
-    if (total <= 0) continue;
-    minCoalesced =
-      minCoalesced === null ? coalesced : Math.min(minCoalesced, coalesced);
-  }
-  return minCoalesced ?? 0;
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-function hasStaticSingleBatchBucket(input: {
-  toolId: string;
-  paramsSource?: string | null;
-  sourceText?: string | null;
-}): boolean {
-  const strategy = getPlayRuntimeBatchStrategy(input.toolId);
-  const bucketFields = strategy?.bucketKeyPayloadFields;
-  if (!bucketFields || bucketFields.length === 0) return false;
-  const source = [input.paramsSource, input.sourceText]
-    .filter((value): value is string => typeof value === 'string')
-    .join('\n');
-  if (!source) return false;
-  return bucketFields.every((field) => {
-    const pattern = new RegExp(
-      `(^|[^A-Za-z0-9_$])${escapeRegExp(field)}([^A-Za-z0-9_$]|$)`,
-    );
-    return !pattern.test(source);
-  });
-}
-
-function addStats(
-  [total, unbatched, subrequests, batchSize, coalesced]: MapToolStats,
-  stats: MapToolStats,
-): MapToolStats {
-  return [
-    total + stats[0],
-    unbatched + stats[1],
-    subrequests + stats[2],
-    minPositiveBatchSize(batchSize, stats[3]),
-    coalesced + stats[4],
-  ];
-}
-
-function countToolSubsteps(
-  substeps: readonly PlayStaticSubstep[],
-): MapToolStats {
-  let stats: MapToolStats = [0, 0, 0, 0, 0];
-
-  for (const substep of substeps) {
-    stats = addStats(stats, countToolSubstep(substep));
-  }
-
-  return stats;
-}
-
-function countToolSubstep(substep: PlayStaticSubstep): MapToolStats {
-  if (substep.type === 'tool') {
-    return countTool(substep.toolId, {
-      staticSingleBucket: hasStaticSingleBatchBucket({
-        toolId: substep.toolId,
-        paramsSource: substep.paramsSource,
-        sourceText: substep.sourceText,
-      }),
-    });
-  }
-
-  if (substep.type === 'waterfall') {
-    let stats: MapToolStats = [0, 0, 0, 0, 0];
-    for (const step of substep.steps ?? []) {
-      if (!step.toolId) continue;
-      stats = addStats(
-        stats,
-        countTool(step.toolId, {
-          staticSingleBucket: hasStaticSingleBatchBucket({
-            toolId: step.toolId,
-            paramsSource: step.paramsSource,
-            sourceText: substep.sourceText,
-          }),
-        }),
-      );
-    }
-    return stats;
-  }
-
-  if (substep.type === 'step_suite') {
-    return countStepSuiteTools(substep);
-  }
-
-  if (substep.type === 'control_flow') {
-    if (substep.kind === 'conditional' && substep.branches?.length) {
-      const branchStats = substep.branches.map((branch) =>
-        countToolSubsteps(branch.steps),
-      );
-      const maxBranchStats = branchStats.reduce<MapToolStats>(
-        (
-          [totalMax, unbatchedMax, subrequestsMax, batchSizeMin, coalescedMax],
-          [total, unbatched, subrequests, batchSize, coalesced],
-        ) => [
-          Math.max(totalMax, total),
-          Math.max(unbatchedMax, unbatched),
-          Math.max(subrequestsMax, subrequests),
-          minPositiveBatchSize(batchSizeMin, batchSize),
-          Math.max(coalescedMax, coalesced),
-        ],
-        [0, 0, 0, 0, 0],
-      );
-      return [
-        maxBranchStats[0],
-        maxBranchStats[1],
-        maxBranchStats[2],
-        maxBranchStats[3],
-        minProviderBranchCoalescedCount(branchStats),
-      ];
-    }
-    if (substep.kind === 'loop') {
-      // The static extractor records every switch arm in `steps` when a loop
-      // walks a fixed provider list. Each arm can execute on a different
-      // iteration, so using the conditional's max-one-branch estimate would
-      // budget a seven-provider waterfall as one provider call per row.
-      return substep.steps.reduce<MapToolStats>((stats, step) => {
-        const stepStats =
-          step.type === 'control_flow' &&
-          step.kind === 'conditional' &&
-          step.steps.length > 0
-            ? countToolSubsteps(step.steps)
-            : countToolSubstep(step);
-        return addStats(stats, stepStats);
-      }, [0, 0, 0, 0, 0]);
-    }
-    return countToolSubsteps(substep.steps);
-  }
-
-  if (substep.type === 'dataset') {
-    return countToolSubsteps(substep.steps ?? []);
-  }
-
-  return [0, 0, 0, 0, 0];
-}
-
-function addControlWorkStats(
-  left: MapControlWorkStats,
-  right: MapControlWorkStats,
-): MapControlWorkStats {
-  return {
-    childPlaySubmits: left.childPlaySubmits + right.childPlaySubmits,
-    eventWaits: left.eventWaits + right.eventWaits,
-  };
-}
-
-function maxControlWorkStats(
-  left: MapControlWorkStats,
-  right: MapControlWorkStats,
-): MapControlWorkStats {
-  return {
-    childPlaySubmits: Math.max(left.childPlaySubmits, right.childPlaySubmits),
-    eventWaits: Math.max(left.eventWaits, right.eventWaits),
-  };
-}
-
-function countControlWorkSubsteps(
-  substeps: readonly PlayStaticSubstep[],
-): MapControlWorkStats {
-  return substeps.reduce<MapControlWorkStats>(
-    (acc, substep) =>
-      addControlWorkStats(acc, countControlWorkSubstep(substep)),
-    EMPTY_CONTROL_WORK_STATS,
-  );
-}
-
-function countControlWorkSubstep(
-  substep: PlayStaticSubstep,
-): MapControlWorkStats {
-  if (substep.type === 'play_call') {
-    return { childPlaySubmits: 1, eventWaits: 0 };
-  }
-
-  if (substep.type === 'tool') {
-    return {
-      childPlaySubmits: 0,
-      eventWaits:
-        substep.isEventWait === true || substep.toolId === 'test_wait_for_event'
-          ? 1
-          : 0,
-    };
-  }
-
-  if (substep.type === 'step_suite') {
-    return countControlWorkSubsteps(substep.steps);
-  }
-
-  if (substep.type === 'control_flow') {
-    if (substep.kind === 'conditional' && substep.branches?.length) {
-      return substep.branches
-        .map((branch) => countControlWorkSubsteps(branch.steps))
-        .reduce<MapControlWorkStats>(
-          (acc, stats) => maxControlWorkStats(acc, stats),
-          EMPTY_CONTROL_WORK_STATS,
-        );
-    }
-    return countControlWorkSubsteps(substep.steps);
-  }
-
-  if (substep.type === 'dataset') {
-    return countControlWorkSubsteps(substep.steps ?? []);
-  }
-
-  return EMPTY_CONTROL_WORK_STATS;
-}
-
-function countStepSuiteTools(
-  substep: Extract<PlayStaticSubstep, { type: 'step_suite' }>,
-): MapToolStats {
-  const childStats = substep.steps.map((step) => ({
-    step,
-    stats: countToolSubstep(step),
-  }));
-  const conditionalChildren = childStats.filter(
-    ({ step }) =>
-      step.conditional ||
-      (step.type === 'control_flow' && step.kind === 'conditional'),
-  );
-  if (
-    conditionalChildren.length === 0 ||
-    conditionalChildren.length < childStats.length / 2
-  ) {
-    return childStats.reduce<MapToolStats>(
-      (acc, { stats }) => addStats(acc, stats),
-      [0, 0, 0, 0, 0],
-    );
-  }
-
-  const suiteRoot = fieldRoot(substep.field);
-  const sameRoot = childStats.every(({ step }) => {
-    if (!('field' in step)) return true;
-    return fieldRoot(step.field) === suiteRoot;
-  });
-  if (!sameRoot) {
-    return childStats.reduce<MapToolStats>(
-      (acc, { stats }) => addStats(acc, stats),
-      [0, 0, 0, 0, 0],
-    );
-  }
-
-  const unconditionalStats = childStats
-    .filter(
-      ({ step }) =>
-        !step.conditional &&
-        !(step.type === 'control_flow' && step.kind === 'conditional'),
-    )
-    .reduce<MapToolStats>(
-      (acc, { stats }) => addStats(acc, stats),
-      [0, 0, 0, 0, 0],
-    );
-  const conditionalStats = conditionalChildren.reduce<MapToolStats>(
-    (acc, { stats }) => addStats(acc, stats),
-    [0, 0, 0, 0, 0],
-  );
-
-  return addStats(unconditionalStats, conditionalStats);
-}
-
-function countProducerTools(
-  producers: readonly PlayStaticColumnProducer[],
-): MapToolStats {
-  let stats: MapToolStats = [0, 0, 0, 0, 0];
-
-  for (const producer of producers) {
-    if (producer.kind === 'tool' && producer.toolId) {
-      stats = addStats(
-        stats,
-        countTool(producer.toolId, {
-          staticSingleBucket: hasStaticSingleBatchBucket({
-            toolId: producer.toolId,
-            paramsSource:
-              producer.substep.type === 'tool'
-                ? producer.substep.paramsSource
-                : undefined,
-            sourceText:
-              producer.substep.type === 'tool'
-                ? producer.substep.sourceText
-                : undefined,
-          }),
-        }),
-      );
-    }
-    if (producer.substep.type === 'waterfall') {
-      stats = addStats(stats, countToolSubstep(producer.substep));
-    }
-    if (producer.steps?.length) {
-      stats = addStats(stats, countProducerTools(producer.steps));
-    }
-  }
-
-  return stats;
-}
-
-function datasetBelongsToPlanMap(
-  dataset: Extract<PlayStaticSubstep, { type: 'dataset' }>,
-  planMap: ChunkSizingMap,
-  mapName: string,
-): boolean {
-  return [dataset.name, dataset.tableNamespace, dataset.field].some(
-    (datasetName) =>
-      typeof datasetName === 'string' &&
-      datasetName.length > 0 &&
-      (datasetName === planMap.mapName ||
-        datasetName === planMap.tableNamespace ||
-        datasetName === mapName),
-  );
-}
-
-function countMapLocalTools(input: {
-  staticPipeline: PlayStaticPipeline | null | undefined;
-  planMap: ChunkSizingMap | null | undefined;
-  mapName: string;
-}): MapToolStats | null {
-  if (!input.staticPipeline || !input.planMap) return null;
-  const planMap = input.planMap;
-  const dataset = flattenStaticSubsteps(
-    getTopLevelPipelineSubsteps(input.staticPipeline),
-  ).find(
-    (substep): substep is Extract<PlayStaticSubstep, { type: 'dataset' }> =>
-      substep.type === 'dataset' &&
-      datasetBelongsToPlanMap(substep, planMap, input.mapName),
-  );
-  if (!dataset) return null;
-
-  if (dataset.steps?.length) return countToolSubsteps(dataset.steps);
-  if (dataset.columns?.length) {
-    return countProducerTools(
-      dataset.columns.flatMap((column) => column.producers),
-    );
-  }
-  return [0, 0, 0, 0, 0];
-}
-
-function countMapLocalControlWork(input: {
-  staticPipeline: PlayStaticPipeline | null | undefined;
-  planMap: ChunkSizingMap | null | undefined;
-  mapName: string;
-}): MapControlWorkStats | null {
-  if (!input.staticPipeline || !input.planMap) return null;
-  const planMap = input.planMap;
-  const dataset = flattenStaticSubsteps(
-    getTopLevelPipelineSubsteps(input.staticPipeline),
-  ).find(
-    (substep): substep is Extract<PlayStaticSubstep, { type: 'dataset' }> =>
-      substep.type === 'dataset' &&
-      datasetBelongsToPlanMap(substep, planMap, input.mapName),
-  );
-  if (!dataset) return null;
-
-  if (dataset.steps?.length) return countControlWorkSubsteps(dataset.steps);
-  if (dataset.columns?.length) {
-    return dataset.columns
-      .flatMap((column) => column.producers)
-      .reduce<MapControlWorkStats>(
-        (acc, producer) =>
-          addControlWorkStats(acc, countControlWorkSubstep(producer.substep)),
-        EMPTY_CONTROL_WORK_STATS,
-      );
-  }
-  return EMPTY_CONTROL_WORK_STATS;
-}
-
-function countFallbackDeclarationTools(input: {
-  declarations: readonly { toolId: string; field?: string | null }[];
-  outputFields: readonly string[];
-  externalStepFields?: readonly string[];
-}): MapToolStats {
-  let stats: MapToolStats = [0, 0, 0, 0, 0];
-
-  for (const declaration of input.declarations) {
-    if (
-      !declarationBelongsToMapOutput(
-        declaration,
-        input.outputFields,
-        input.externalStepFields ?? [],
-      )
-    ) {
-      continue;
-    }
-    stats = addStats(stats, countTool(declaration.toolId));
-  }
-
-  return stats;
-}
-
-function countDeclarationTools(
-  declarations: readonly { toolId: string; field?: string | null }[],
-): MapToolStats {
-  return declarations.reduce<MapToolStats>(
-    (stats, declaration) => addStats(stats, countTool(declaration.toolId)),
-    [0, 0, 0, 0, 0],
-  );
-}
-
-function countNestedExecutionSteps(
-  substeps: readonly PlayStaticSubstep[] | undefined,
-): number {
-  let stepsPerChunk = 1;
-  for (const substep of substeps ?? []) {
-    if (substep.type === 'waterfall') {
-      stepsPerChunk = Math.max(stepsPerChunk, substep.steps?.length ?? 1);
-      continue;
-    }
-    if (substep.type === 'step_suite') {
-      stepsPerChunk = Math.max(stepsPerChunk, substep.steps.length);
-      continue;
-    }
-    if (substep.type === 'control_flow' || substep.type === 'dataset') {
-      stepsPerChunk = Math.max(
-        stepsPerChunk,
-        countNestedExecutionSteps(substep.steps),
-      );
-    }
-  }
-  return stepsPerChunk;
-}
-
-function buildStaticChunkSizingPlan(
-  staticPipeline: PlayStaticPipeline | null,
-): ChunkSizingPlan | null {
-  if (!staticPipeline) return null;
-  const datasets = flattenStaticSubsteps(
-    getTopLevelPipelineSubsteps(staticPipeline),
-  ).filter(
-    (substep): substep is Extract<PlayStaticSubstep, { type: 'dataset' }> =>
-      substep.type === 'dataset',
-  );
-  if (datasets.length === 0) return null;
-  return {
-    maps: datasets.map((dataset) => {
-      const stepsPerChunk = countNestedExecutionSteps(dataset.steps);
-      return {
-        mapName: dataset.name ?? dataset.field,
-        tableNamespace: dataset.tableNamespace ?? dataset.field,
-        outputFields: dataset.outputFields ?? [],
-        defaultChunkSize: stepsPerChunk > 1 ? 1_000 : 5_000,
-        stepsPerChunk,
-      };
-    }),
-  };
-}
-
-export function chooseWorkerMapRowsPerChunk(
-  input: WorkerMapChunkPlanInput,
-): number {
-  return chooseWorkerMapDispatchPlan(input).rowsPerChunk;
-}
-
-export function chooseWorkerMapDispatchPlan(
-  input: WorkerMapChunkPlanInput,
-): WorkerMapDispatchPlan {
-  const plan: ChunkSizingPlan | null = input.executionPlan
-    ? {
-        maps: input.executionPlan.maps,
-        toolDeclarations: input.executionPlan.toolDeclarations,
-        softWorkflowStepBudget:
-          input.executionPlan.chunkPlan.softWorkflowStepBudget,
-      }
-    : buildStaticChunkSizingPlan(input.staticPipeline ?? null);
-  const planMap = plan?.maps.find(
-    (candidate) =>
-      candidate.mapName === input.mapName ||
-      candidate.tableNamespace === input.mapName,
-  );
-  const staticMapToolStats = countMapLocalTools({
-    staticPipeline: input.staticPipeline,
-    planMap,
-    mapName: input.mapName,
-  });
-  const staticMapControlWorkStats = countMapLocalControlWork({
-    staticPipeline: input.staticPipeline,
-    planMap,
-    mapName: input.mapName,
-  });
-  const mapToolStats =
-    staticMapToolStats ??
-    (plan && planMap
-      ? countFallbackDeclarationTools({
-          declarations: plan.toolDeclarations ?? [],
-          outputFields: planMap.outputFields,
-          externalStepFields: planMap.externalStepFields ?? [],
-        })
-      : plan
-        ? countDeclarationTools(plan.toolDeclarations ?? [])
-        : [0, 0, 0, 0, 0]);
-  const estimatedExternalStepsPerRow = estimateExternalStepsForMap({
-    planMap,
-    mapToolStats,
-  });
-  const workEstimate = estimateMapWork({
-    estimatedExternalStepsPerRow,
-    mapToolStats,
-    controlWorkStats: staticMapControlWorkStats ?? EMPTY_CONTROL_WORK_STATS,
-  });
-  const controlSubrequestsPerRow =
-    workEstimate.childPlaySubmitsPerRow + workEstimate.eventWaitsPerRow;
-  const allProviderCallsAreCoalescedBatchable =
-    workEstimate.providerToolCallsPerRow > 0 &&
-    workEstimate.unbatchedProviderToolCallsPerRow === 0 &&
-    workEstimate.coalescedBatchableProviderToolCallsPerRow >=
-      workEstimate.providerToolCallsPerRow &&
-    controlSubrequestsPerRow === 0;
-  const preferredChunkSize = allProviderCallsAreCoalescedBatchable
-    ? Math.max(
-        planMap?.defaultChunkSize ?? 0,
-        EXECUTION_PLAN_DEFAULTS.largeMapChunkSize,
-      )
-    : planMap?.defaultChunkSize;
-  const rowsPerChunk = chooseMapChunkSize({
-    totalRows: input.rowCountHint,
-    mapCount: Math.max(1, plan?.maps.length ?? 1),
-    stepsPerChunk:
-      estimatedExternalStepsPerRow > 0
-        ? Math.max(estimatedExternalStepsPerRow, planMap?.stepsPerChunk ?? 1)
-        : 1,
-    preferredChunkSize,
-    softWorkflowStepBudget: plan?.softWorkflowStepBudget,
-  });
-  if (estimatedExternalStepsPerRow > 0 || controlSubrequestsPerRow > 0) {
-    const subrequestSafeRows = subrequestSafeRowsForMap({
-      planMap,
-      mapToolStats,
-      staticMapToolStats,
-      estimatedExternalStepsPerRow,
-      workEstimate,
-    });
-    if (subrequestSafeRows < rowsPerChunk) {
-      const externalPressurePlan: WorkerMapDispatchPlan = {
-        rowsPerChunk: subrequestSafeRows,
-        estimatedExternalStepsPerRow,
-        workEstimate,
-        reason: 'external-pressure',
-      };
-      return externalPressurePlan;
-    }
-    return {
-      rowsPerChunk,
-      estimatedExternalStepsPerRow,
-      workEstimate,
-      reason: 'external-pressure',
-    };
-  }
-
-  const toolFreeMap = !!planMap && mapToolStats[0] === 0;
-  const toolFreeSimpleMap = toolFreeMap && planMap.stepsPerChunk === 1;
-  if (
-    toolFreeSimpleMap &&
-    (input.rowCountHint === null ||
-      input.rowCountHint >= CACHE_ENABLED_SIMPLE_MAP_CHUNK_SIZE)
-  ) {
-    const largeRowsPerChunk = Math.max(
-      rowsPerChunk,
-      CACHE_ENABLED_SIMPLE_MAP_CHUNK_SIZE,
-    );
-    return {
-      rowsPerChunk: largeRowsPerChunk,
-      estimatedExternalStepsPerRow: 0,
-      workEstimate,
-      reason: 'tool-free-large-cache',
-    };
-  }
-
-  return {
-    rowsPerChunk,
-    estimatedExternalStepsPerRow: 0,
-    workEstimate,
-    reason: toolFreeMap ? 'tool-free-plan' : 'default-plan',
-  };
-}
-
-function estimateMapWork(input: {
-  estimatedExternalStepsPerRow: number;
-  mapToolStats: MapToolStats;
-  controlWorkStats: MapControlWorkStats;
-}): WorkerMapWorkEstimate {
-  return {
-    cpuRowsPerRow: 1,
-    runtimeSheetReadsPerChunk: 1,
-    runtimeSheetWritesPerChunk: 1,
-    durableReceiptOpsPerRow: input.estimatedExternalStepsPerRow,
-    providerToolCallsPerRow: input.mapToolStats[0],
-    unbatchedProviderToolCallsPerRow: input.mapToolStats[1],
-    assumedBatchSize: assumedBatchSizeFor(input.mapToolStats[3]),
-    coalescedBatchableProviderToolCallsPerRow: input.mapToolStats[4],
-    childPlaySubmitsPerRow: input.controlWorkStats.childPlaySubmits,
-    eventWaitsPerRow: input.controlWorkStats.eventWaits,
-  };
-}
-
-function estimateExternalStepsForMap(input: {
-  planMap: ChunkSizingMap | undefined;
-  mapToolStats: MapToolStats;
-}): number {
-  if (!input.planMap) return input.mapToolStats[0];
-  const explicitExternalSteps = Array.isArray(input.planMap.externalStepFields)
-    ? input.planMap.externalStepFields.length
-    : 0;
-  return Math.max(explicitExternalSteps, input.mapToolStats[0]);
-}
-
-function subrequestSafeRowsForMap(input: {
-  planMap: ChunkSizingMap | undefined;
-  mapToolStats: MapToolStats;
-  staticMapToolStats: MapToolStats | null;
-  estimatedExternalStepsPerRow: number;
-  workEstimate: WorkerMapWorkEstimate;
-}): number {
-  const hasToolWork = input.mapToolStats[0] > 0;
-  const unbatchedToolCount = input.mapToolStats[1];
-  const unbatchedSubrequestCount = input.mapToolStats[2];
-  const controlSubrequestsPerRow =
-    input.workEstimate.childPlaySubmitsPerRow +
-    input.workEstimate.eventWaitsPerRow;
-  const controlRows =
-    controlSubrequestsPerRow > 0
-      ? Math.max(
-          1,
-          Math.floor(
-            (UNBATCHED_TOOL_SUBREQUESTS_PER_CHUNK_BUDGET -
-              input.workEstimate.runtimeSheetReadsPerChunk -
-              input.workEstimate.runtimeSheetWritesPerChunk) /
-              controlSubrequestsPerRow,
-          ),
-        )
-      : Number.POSITIVE_INFINITY;
-  // Largest chunk whose batched tool work stays under the subrequest ceiling.
-  // Invert estimateBatchedToolChunkSubrequests. Static planning does not know
-  // bucket cardinality, so it assumes worst-case provider fanout (one compiled
-  // batch per row per batchable tool call) while keeping durable receipt RPCs
-  // fixed per drained tool group.
-  const batchableToolRows =
-    hasToolWork && unbatchedToolCount <= 0
-      ? (() => {
-          const batchableToolCallsPerRow = input.mapToolStats[0];
-          const costForRows = (rows: number) =>
-            estimateBatchedToolChunkSubrequests({
-              batchableToolCallsPerRow,
-              coalescedBatchableToolCallsPerRow:
-                input.workEstimate.coalescedBatchableProviderToolCallsPerRow,
-              rows,
-              assumedBatchSize: input.workEstimate.assumedBatchSize,
-            }) +
-            input.workEstimate.runtimeSheetReadsPerChunk +
-            input.workEstimate.runtimeSheetWritesPerChunk;
-          if (costForRows(1) > UNBATCHED_TOOL_SUBREQUESTS_PER_CHUNK_BUDGET) {
-            return 1;
-          }
-          let low = 1;
-          let high = MAX_BATCHABLE_SUBREQUEST_SAFE_ROWS;
-          while (low < high) {
-            const mid = Math.ceil((low + high) / 2);
-            if (
-              costForRows(mid) <= UNBATCHED_TOOL_SUBREQUESTS_PER_CHUNK_BUDGET
-            ) {
-              low = mid;
-            } else {
-              high = mid - 1;
-            }
-          }
-          return low;
-        })()
-      : Number.POSITIVE_INFINITY;
-  if (hasToolWork && unbatchedToolCount <= 0) {
-    return Math.min(batchableToolRows, controlRows);
-  }
-  const genericRows =
-    input.estimatedExternalStepsPerRow > 0
-      ? Math.max(
-          1,
-          Math.floor(
-            WORKER_SUBREQUEST_SAFE_TOOL_CALLS_PER_CHUNK /
-              input.estimatedExternalStepsPerRow,
-          ),
-        )
-      : Number.POSITIVE_INFINITY;
-  if (unbatchedToolCount <= 0) return Math.min(genericRows, controlRows);
-  const unbatchedSubrequestsPerRow =
-    input.staticMapToolStats !== null
-      ? unbatchedSubrequestCount
-      : Math.max(
-          (input.planMap?.stepsPerChunk ?? 1) *
-            SUBREQUESTS_PER_UNBATCHED_TOOL_CALL,
-          unbatchedSubrequestCount,
-        );
-  const unbatchedRows = Math.max(
-    1,
-    Math.floor(
-      UNBATCHED_TOOL_SUBREQUESTS_PER_CHUNK_BUDGET / unbatchedSubrequestsPerRow,
-    ),
-  );
-  return Math.min(unbatchedRows, controlRows);
-}