A Story takes a list of Block objects and processes them as a tree (or more technically, an orchard). For each Block, it first tries to analyze the line specifically associated with the Block. It does so by calling, in order, all of the possible candidate parsers for that line in that context (it is specifically the Story's job to decide which parsers, in which order, are appropriate for the context).
For each parser, there are three possible outcomes: a valid parse tree for the kind of object(s) that the parser can recognize; null reflecting the fact that the parser does not recognize the "shape" of the line and cannot handle it; or a set of errors which reflects the notion that the parser things it should be able to parse the statement but it has issues.
The story works through all the parsers it considers appropriate for the context until either it obtains a valid parse tree from one parser or receives null or an error object for every parser. If every parser returns null, then there is no valid interpretation of the line - a generic syntax error. Otherwise, the first valid parse tree or error object is used.
Once a line has been parsed, it is up to the Story to decide whether or not any nested definitions are allowed and, if they are, which ones may be used.
A story may use multiple phases if needed to achieve its goals. For example, functions in a functional language are normally defined over multiple lines in the same block (one line for each of several cases). These need to be first collected in a list (so that the same name may appear multiple times) and then reduced to a single definition that can be inserted into the Scope.
The output of a Story is a list of Scope objects, each of which provides a mapping from a set of names to a set of valid definitions, possibly with nested Scopes.