Configuration binding and stage execution for ordinary nodes

The policy implementation follows.

export function createContextProcessingNode<State, Result, App = undefined>(
  definition: ContextProcessingNodeDefinition<State, Result, App>,
): WorkflowNode<State, Result, App> {
  return contextNode(definition, async (work, prepared, fullLimit) => {
    await contextPolicyCatalog[work.policy.mode].run(work);
    const result = finishContextProcessing(work);
    return {
      input: { ...result.context, maxInputChars: fullLimit },
      prepared,
      report: result.report,
    };
  });
}

export function createContextSelectionNode<State, Result, App = undefined>(
  definition: ContextSelectionNodeDefinition<State, Result, App>,
): WorkflowNode<State, Result, App> {
  return contextNode(definition, async (work, prepared, fullLimit) => {
    validateReductionTargets(work);
    breakWhile(work.policy.mode !== 'reduce', 'Selection requires a reduction policy');
    const policy = work.policy as Extract<ContextPolicy, { mode: 'reduce' }>;
    work.report.selection = policy.selection?.mode ?? 'sequence';
    work.report.decisions = [];
    const stepIds = needsReduction(work, watermarks(work).trigger)
      ? await chooseSteps(work, policy.steps, policy.selection ?? { mode: 'sequence' })
      : [];
    return { ...stageResult(work, prepared, fullLimit, policy.steps), stepIds };
  });
}

export function createContextReductionNode<State, Result, App = undefined>(
  definition: ContextReductionNodeDefinition<State, Result, App>,
): WorkflowNode<State, Result, App> {
  const source = definition.stepId;
  const stepId = typeof source === 'function' ? source.bind(definition) : () => source;
  return contextNode(definition, async (work, prepared, fullLimit, state) => {
    validateReductionTargets(work);
    const policy = work.policy as Extract<ContextPolicy, { mode: 'reduce' }>;
    const id = synchronous(stepId(state), 'Context operation IDs must be synchronous');
    const step = policy.steps.find((item) => item.id === id);
    breakWhile(!step, 'Context operation is not registered');
    await applyReduction(work, step!, policy.selection ?? { mode: 'sequence' });
    return stageResult(work, prepared, fullLimit, policy.steps);
  });
}