solve-engine 2.38.21 → 2.38.23

package/dist/{PackageCompatibility-ZCZVGHws.d.ts → PackageCompatibility-C7ILySsH.d.ts}

@@ -1,4 +1,4 @@
-import { I as IEnginePackage } from './PackageRegistry-B6s8LGCu.js';
+import { I as IEnginePackage } from './PackageRegistry-D7_B0mxv.js';
 
 /**
  * Package load-time compatibility checking, the "detect overlapping

package/dist/{PackageCompatibility-Bv42nEm2.d.cts → PackageCompatibility-CzDzOIg9.d.cts}

@@ -1,4 +1,4 @@
-import { I as IEnginePackage } from './PackageRegistry-7dFbaAZp.cjs';
+import { I as IEnginePackage } from './PackageRegistry-Bd8ErpwZ.cjs';
 
 /**
  * Package load-time compatibility checking, the "detect overlapping

package/dist/{PackageRegistry-7dFbaAZp.d.cts → PackageRegistry-Bd8ErpwZ.d.cts}

@@ -2,7 +2,7 @@ import { a as PrecedenceParser, b as PrefixParselet, I as InfixParselet } from '
 import { M as MarkdownLineType, L as Lexer, e as TokenCategory, c as LexerVocabulary } from './Lexer-DaWkCu84.cjs';
 import { IAsyncResolver } from './resolvers.cjs';
 import { T as TokenFusion, c as TokenNormalizer, a as NormalizerRule } from './TokenNormalizer-D382VSYh.cjs';
-import { b as VMCheckpointer, D as DependencyGraph, V as VM, h as DagSnapshot, i as EngineContext, S as ScopeManager, P as PluginFunctionHandler, A as AsConverter } from './VMBuiltins-0C4z3yDS.cjs';
+import { b as VMCheckpointer, D as DependencyGraph, V as VM, h as DagSnapshot, i as EngineContext, S as ScopeManager, P as PluginFunctionHandler, A as AsConverter } from './VMBuiltins-Baa90D2v.cjs';
 import { V as Value, b as ValueType, D as DatetimeGrain } from './Value-B55Hvn3e.cjs';
 import { a as BytecodeProgram } from './BytecodeBuilder-DSWKZi4f.cjs';
 import { C as CalendarBackend } from './CalendarBackend-MdS3Bb4P.cjs';
@@ -2410,6 +2410,8 @@ declare class ExpressionEngine {
     private builderPool;
     private builderPoolIndex;
     private lastTelemetry;
+    /** Whether the line being evaluated sits on a cycle; see {@link setLineOnCycle}. */
+    private lineOnCycle;
     constructor(options?: EngineOptions);
     /**
      * Get the native event stream from the batcher for stream-based consumers.
@@ -2434,6 +2436,81 @@ declare class ExpressionEngine {
      * Tests use this to access `batcher._testCaptures` for synchronous
      * event observation without async stream reader timing issues.
      */
+    /**
+     * Put a name back to what the lines above `lineNumber` left it holding.
+     *
+     * The invariant a pass from scratch keeps without trying: when it reaches a
+     * line, every name holds what the lines above defined, because those lines
+     * have just run in order and stored. The incremental path keeps the VM
+     * between passes, so a line that writes a name can find the name holding
+     * its own previous answer instead. That is invisible for `:x = 5`, which
+     * stores over it, and wrong twice over for a definition that reads what it
+     * writes or fails to store:
+     *
+     * - `:v3 = 44` above `:v3 = v3 + 3` is 47 on every pass from scratch, since
+     *   line 1 puts 44 back each time. Edit line 1 away and nothing puts
+     *   anything back, so line 2 reads its own 47 and climbs by three a pass,
+     *   where a pass from scratch says `v3` is undefined.
+     * - `:x = 5` edited to `:x = zz + 1` skips the store, on both paths, and
+     *   the incremental one is left holding the 5 the same line stored before
+     *   the edit, where a pass from scratch has nothing.
+     *
+     * The checkpoint chain records what each line wrote in document order, so
+     * the value the prefix holds is the one it holds just before this line,
+     * and this puts the VM there: the value if there is one, absent if not.
+     * The evaluator calls it before a definition runs and again if it fails,
+     * both times before the line's own checkpoint is taken, so the checkpoint
+     * records the corrected state.
+     *
+     * A function is a definition too, and was the one kind nothing could
+     * undo: `f(x) = x + 4` edited into a blank left `f(9)` answering 13 for
+     * the rest of the session. The prefix is consulted for a function binding
+     * as well as a variable one, and each is put back on its own, since a
+     * name can be bound in both bags at once (`f(x) = x + 1` above `:f = 4`).
+     * A name bound to neither above is unbound from both.
+     *
+     * An accumulator is left alone. Every pass resets each running total to
+     * its seed and re-runs every line that steps it, in order, so by the time
+     * any step runs the VM already holds what the steps above built, seed
+     * included, and putting the prefix back would only undo a step.
+     *
+     * @param name - The name the line writes.
+     * @param lineNumber - The 1-based line it sits on.
+     */
+    restoreToPrefix(name: string, lineNumber: number): void;
+    /**
+     * Whether `name` is a running total, stepped by `+=` or `-=` somewhere.
+     *
+     * The evaluator's cycle walk asks, because a total's steppers depend on one
+     * another through the total in a way the graph deliberately does not
+     * record: a line is kept out of the consumers of a name it writes, which
+     * is right for `:x = 5` and hides the fold for `spent += 5`.
+     *
+     * @param name - A variable name.
+     * @returns True when a line has stepped it.
+     */
+    /**
+     * Tell the engine whether the line about to run sits on a cycle.
+     *
+     * A line that depends on itself, through positions or names or both, has
+     * no answer of its own: each value it could hold is computed from that same
+     * value a pass earlier. A single fresh pass reports that, because some
+     * member reads a line below it that has not run, and the error travels all
+     * the way round. The incremental path carries the VM between passes, so a
+     * member could find a number to start from, and the pair then chased it.
+     *
+     * While this is set, a positional read of a line below the one running
+     * answers as an unevaluated line does, which is what makes a member report
+     * the cycle rather than the number it read last pass. The evaluator sets it
+     * per line from the cycle membership it keeps, and puts the names such a
+     * line reads back to the prefix before it runs, for the same reason. A line
+     * not on a cycle keeps the incremental path's tolerance of a plain forward
+     * reference, which resolves by running the document again.
+     *
+     * @param onCycle - Whether the line about to run is on a cycle.
+     */
+    setLineOnCycle(onCycle: boolean): void;
+    isAccumulatorName(name: string): boolean;
     /** The names of every user-defined unit in scope, for detecting a removal. */
     userUnitNames(): string[];
     /**

package/dist/{PackageRegistry-B6s8LGCu.d.ts → PackageRegistry-D7_B0mxv.d.ts}

@@ -2,7 +2,7 @@ import { a as PrecedenceParser, b as PrefixParselet, I as InfixParselet } from '
 import { M as MarkdownLineType, L as Lexer, e as TokenCategory, c as LexerVocabulary } from './Lexer-DPn5dfCH.js';
 import { IAsyncResolver } from './resolvers.js';
 import { T as TokenFusion, c as TokenNormalizer, a as NormalizerRule } from './TokenNormalizer-DAzPp-j1.js';
-import { b as VMCheckpointer, D as DependencyGraph, V as VM, h as DagSnapshot, i as EngineContext, S as ScopeManager, P as PluginFunctionHandler, A as AsConverter } from './VMBuiltins-Bu6qaKi0.js';
+import { b as VMCheckpointer, D as DependencyGraph, V as VM, h as DagSnapshot, i as EngineContext, S as ScopeManager, P as PluginFunctionHandler, A as AsConverter } from './VMBuiltins-BqkoJtHt.js';
 import { V as Value, b as ValueType, D as DatetimeGrain } from './Value-B55Hvn3e.js';
 import { a as BytecodeProgram } from './BytecodeBuilder-DSWKZi4f.js';
 import { C as CalendarBackend } from './CalendarBackend-MdS3Bb4P.js';
@@ -2410,6 +2410,8 @@ declare class ExpressionEngine {
     private builderPool;
     private builderPoolIndex;
     private lastTelemetry;
+    /** Whether the line being evaluated sits on a cycle; see {@link setLineOnCycle}. */
+    private lineOnCycle;
     constructor(options?: EngineOptions);
     /**
      * Get the native event stream from the batcher for stream-based consumers.
@@ -2434,6 +2436,81 @@ declare class ExpressionEngine {
      * Tests use this to access `batcher._testCaptures` for synchronous
      * event observation without async stream reader timing issues.
      */
+    /**
+     * Put a name back to what the lines above `lineNumber` left it holding.
+     *
+     * The invariant a pass from scratch keeps without trying: when it reaches a
+     * line, every name holds what the lines above defined, because those lines
+     * have just run in order and stored. The incremental path keeps the VM
+     * between passes, so a line that writes a name can find the name holding
+     * its own previous answer instead. That is invisible for `:x = 5`, which
+     * stores over it, and wrong twice over for a definition that reads what it
+     * writes or fails to store:
+     *
+     * - `:v3 = 44` above `:v3 = v3 + 3` is 47 on every pass from scratch, since
+     *   line 1 puts 44 back each time. Edit line 1 away and nothing puts
+     *   anything back, so line 2 reads its own 47 and climbs by three a pass,
+     *   where a pass from scratch says `v3` is undefined.
+     * - `:x = 5` edited to `:x = zz + 1` skips the store, on both paths, and
+     *   the incremental one is left holding the 5 the same line stored before
+     *   the edit, where a pass from scratch has nothing.
+     *
+     * The checkpoint chain records what each line wrote in document order, so
+     * the value the prefix holds is the one it holds just before this line,
+     * and this puts the VM there: the value if there is one, absent if not.
+     * The evaluator calls it before a definition runs and again if it fails,
+     * both times before the line's own checkpoint is taken, so the checkpoint
+     * records the corrected state.
+     *
+     * A function is a definition too, and was the one kind nothing could
+     * undo: `f(x) = x + 4` edited into a blank left `f(9)` answering 13 for
+     * the rest of the session. The prefix is consulted for a function binding
+     * as well as a variable one, and each is put back on its own, since a
+     * name can be bound in both bags at once (`f(x) = x + 1` above `:f = 4`).
+     * A name bound to neither above is unbound from both.
+     *
+     * An accumulator is left alone. Every pass resets each running total to
+     * its seed and re-runs every line that steps it, in order, so by the time
+     * any step runs the VM already holds what the steps above built, seed
+     * included, and putting the prefix back would only undo a step.
+     *
+     * @param name - The name the line writes.
+     * @param lineNumber - The 1-based line it sits on.
+     */
+    restoreToPrefix(name: string, lineNumber: number): void;
+    /**
+     * Whether `name` is a running total, stepped by `+=` or `-=` somewhere.
+     *
+     * The evaluator's cycle walk asks, because a total's steppers depend on one
+     * another through the total in a way the graph deliberately does not
+     * record: a line is kept out of the consumers of a name it writes, which
+     * is right for `:x = 5` and hides the fold for `spent += 5`.
+     *
+     * @param name - A variable name.
+     * @returns True when a line has stepped it.
+     */
+    /**
+     * Tell the engine whether the line about to run sits on a cycle.
+     *
+     * A line that depends on itself, through positions or names or both, has
+     * no answer of its own: each value it could hold is computed from that same
+     * value a pass earlier. A single fresh pass reports that, because some
+     * member reads a line below it that has not run, and the error travels all
+     * the way round. The incremental path carries the VM between passes, so a
+     * member could find a number to start from, and the pair then chased it.
+     *
+     * While this is set, a positional read of a line below the one running
+     * answers as an unevaluated line does, which is what makes a member report
+     * the cycle rather than the number it read last pass. The evaluator sets it
+     * per line from the cycle membership it keeps, and puts the names such a
+     * line reads back to the prefix before it runs, for the same reason. A line
+     * not on a cycle keeps the incremental path's tolerance of a plain forward
+     * reference, which resolves by running the document again.
+     *
+     * @param onCycle - Whether the line about to run is on a cycle.
+     */
+    setLineOnCycle(onCycle: boolean): void;
+    isAccumulatorName(name: string): boolean;
     /** The names of every user-defined unit in scope, for detecting a removal. */
     userUnitNames(): string[];
     /**

package/dist/{VMBuiltins-0C4z3yDS.d.cts → VMBuiltins-Baa90D2v.d.cts}

@@ -81,6 +81,21 @@ interface Bytecode {
 interface LineExecutionContext {
     /** 1-based current line number, or -1 when there is no real document (see class doc above). */
     lineIndex: number;
+    /**
+     * How many lines the document has now; absent when there is no document.
+     *
+     * A form that declares a span before reading it (see `noteLineRead`) needs
+     * to know where the document ends: a range written as `line 1 : line
+     * 3000000` has no line to read past the last one, and declaring three
+     * million positions that exist nowhere cost the heap for nothing. The
+     * walk that reads the span already stops at the first line it cannot use.
+     *
+     * Asked for rather than copied, because one context serves a document for
+     * as long as it is open: a count taken when the context was built was the
+     * count before the last insert, and a range declared under it stopped a
+     * line short.
+     */
+    getLineCount?: () => number;
     /**
      * Whether this engine may fetch live data (`network.enabled`). A plugin
      * function that reads a resolver's cache uses it to say "live data is
@@ -98,6 +113,19 @@ interface LineExecutionContext {
     calendar?: CalendarBackend;
     /** Look up another line's cached result by 1-based line number. `undefined` = not evaluated yet (or out of range), distinct from a line that evaluated to an actual `undefined`-like Value, which can't happen (every Value type has a concrete representation). */
     getLineResult?: (lineNumber: number) => Value | undefined;
+    /**
+     * Say that this line is about to read `lineNumber`, before reading it.
+     *
+     * A form that reads several lines stops at the first it cannot use, so the
+     * lines after that one are never read and, if reading were the only way
+     * the dependency graph learned of a read, never recorded. A cycle that
+     * closes through one of those lines was then invisible from scratch and
+     * visible from a history that had once read the whole span, and the two
+     * paths disagreed about whether the line was on a cycle at all. A form
+     * declares its whole span through this first, so what the graph knows does
+     * not depend on how far the form got. Absent where there is no document.
+     */
+    noteLineRead?: (lineNumber: number) => void;
     /**
      * The 1-based positions of the lines carrying `#tag`, ascending, or
      * `undefined` when this path keeps no index and the caller should walk the
@@ -519,6 +547,8 @@ interface VM {
     defineUserFunction(name: string, params: string[], program: BytecodeProgram): void;
     getUserFunction(name: string): UserFunctionDef | undefined;
     hasUserFunction(name: string): boolean;
+    /** Unbind a user function, for a definition edited away, deleted, or failed. */
+    deleteUserFunction(name: string): void;
     /**
      * Every session-scoped variable currently defined, as `[name, value]` pairs,
      * for snapshotting the VM's state (see `engine/EngineSnapshot.ts`). The
@@ -662,6 +692,46 @@ declare class DependencyGraph {
      */
     private lastPositionReader;
     private lastPositionReads;
+    /**
+     * Readers that recorded a position they had not been recorded reading,
+     * since the evaluator last took the list.
+     *
+     * A positional edge can close a cycle, and the moment it is recorded is the
+     * one moment that is knowable: the reader has just run its current text,
+     * so the edge is real, and every other edge in the graph describes the
+     * last run of the line that holds it. The evaluator takes the list at the
+     * end of each pass and looks for a cycle through each reader on it; see
+     * `ThreeTierEvaluator.settleCycles`. A line that only
+     * re-recorded edges it already had is not on it, which is every line of
+     * every pass once a document has settled.
+     */
+    private readersThatGainedAPosition;
+    /**
+     * How many recorded positional edges point downwards, from a reader to a
+     * line below it.
+     *
+     * A cycle needs one. Every edge in a document of `prev` and `above` points
+     * upwards, positions fall strictly along any path, and no path can come
+     * back to where it started. So the evaluator asks this before walking
+     * anything, and a document with no forward reference never pays for the
+     * walk at all, which is nearly every document and every pass after the one
+     * that closed a cycle.
+     */
+    private downwardPositionReads;
+    /**
+     * Lines that registered a different edge set since the evaluator last
+     * asked, and the keys whose producer set changed.
+     *
+     * The roots of the end-of-pass cycle walk. A cycle is closed, or a name that
+     * pinned one is withdrawn, by a change in the graph; nothing else creates
+     * one. A line that re-registers the edges it had is not on the list, which
+     * is every line of a settled pass, and it is also a line that is dirty
+     * because it threw, which stays dirty and re-runs every pass: rooting the
+     * walk on "ran" rather than "changed" made such a line reset its cycle on
+     * alternate passes for ever. Taken and cleared by {@link takeEdgeChanges}.
+     */
+    private edgesChangedThisPass;
+    private producersChangedThisPass;
     /**
      * Whether this line already carries exactly these edges.
      *
@@ -729,6 +799,90 @@ declare class DependencyGraph {
      * @param dependsOnLine - 1-based line whose result it read
      */
     registerLinePositionDependency(lineNumber: number, dependsOnLine: number): void;
+    /**
+     * Cut a line's recorded positions back to the ones its last run read.
+     *
+     * For the evaluator to call once a line has executed. A positional read is
+     * discovered while the line runs, and a position the line has stopped
+     * reading cannot be discovered that way, so without this the recorded set
+     * only ever grew: `prev + 1` edited to `7` went on reading line 1 in the
+     * graph for the rest of the session, and `total above` kept its edges to
+     * the lines above a heading that had cut its block short. Anything asking
+     * the graph what a line reads was told what it used to read, and a cycle
+     * that the heading had broken was still a cycle to the graph, while a cycle
+     * that its removal re-closed was not new to it and so was never noticed.
+     *
+     * A run that read no position at all leaves the line with none. A line
+     * that did not execute (compiled only, or skipped) must not be reconciled,
+     * since it read nothing for a reason that says nothing about its text.
+     *
+     * @param lineNumber - 1-based line that has just executed
+     */
+    reconcilePositionReads(lineNumber: number): void;
+    /**
+     * Forget every position this line was recorded reading.
+     *
+     * For a line whose text has just changed, before it runs: whatever the old
+     * text read is not evidence about the new one, and a rule consulting the
+     * graph between the edit and the run would otherwise be told the old
+     * edges. The next run records what the new text reads. Only the `line:`
+     * keys go; a data-source pin is discovered the same way but is not about
+     * the text, and stays until the line is removed.
+     *
+     * @param lineNumber - 1-based line whose positions are to go
+     */
+    forgetPositionReads(lineNumber: number): void;
+    /**
+     * The positions a line has been recorded reading, as line numbers.
+     *
+     * The forward direction of {@link getAffectedLinesByPosition}: that answers
+     * "who reads this position", this answers "which positions does this line
+     * read". Both directions are what finding a cycle takes.
+     *
+     * @param lineNumber - 1-based line doing the reading
+     * @returns The positions it has read, in no particular order; empty if none
+     */
+    positionsReadBy(lineNumber: number): number[];
+    /**
+     * The readers that recorded a new position since this was last called, and
+     * an empty list until one does.
+     *
+     * Taking the list clears it. See {@link readersThatGainedAPosition}.
+     *
+     * @returns The 1-based readers, in the order they recorded
+     */
+    /**
+     * What changed in the graph since this was last called: the lines whose
+     * edge set changed, and the keys whose producer set changed. Taking it
+     * clears it. See {@link edgesChangedThisPass}.
+     *
+     * @returns The changed lines and keys, each possibly empty.
+     */
+    takeEdgeChanges(): {
+        lines: readonly number[];
+        keys: readonly string[];
+    };
+    takeReadersThatGainedAPosition(): readonly number[];
+    /**
+     * Whether any recorded positional edge points from a reader to a line
+     * below it.
+     *
+     * The precondition for a positional cycle, and so for the walk that looks
+     * for one; see {@link downwardPositionReads}.
+     *
+     * @returns True while at least one such edge is recorded
+     */
+    hasDownwardPositionRead(): boolean;
+    /** The positions an entry records, in the recorded half; the same walk {@link positionsReadBy} makes. */
+    private positionsReadFrom;
+    /**
+     * Drop one positional edge from every index that holds it.
+     *
+     * The consumer index is what says whether the edge exists, so a position the
+     * entry lists twice (in the set, and later inside the span that grew over
+     * it) is dropped once and counted once.
+     */
+    private dropPositionRead;
     /**
      * Every line that read some position's result, whichever position it was.
      *
@@ -796,6 +950,20 @@ declare class DependencyGraph {
      * @param key - The key, from {@link edgeKey}
      * @returns Set of line numbers that write this key, or empty set if none
      */
+    /**
+     * The lines that read `key`, one edge away.
+     *
+     * The consumer index, which {@link registerLine} keeps clear of the line
+     * that writes the key: a definition's read of its own name is a convention
+     * for the graph's benefit, not a dependency, and `x += 1` reads its total
+     * to step it, not to depend on another line. That is what makes this index
+     * the right one for finding a cycle, where the raw reads would make every
+     * definition a self-loop and every twice-defined name a two-cycle.
+     *
+     * @param key - An edge key.
+     * @returns The 1-based readers, or an empty set.
+     */
+    directConsumersOf(key: string): ReadonlySet<number>;
     getProducers(key: string): ReadonlySet<number>;
     /**
      * The keys a line that WRITES something reads.
@@ -1010,9 +1178,13 @@ declare class VMCheckpointer {
      * @param lineNumber 1-based line position.
      * @param lineId Persistent line ID from DocumentModel.
      * @param variableNames Names of variables that were written at this line.
+     * @param functionNames Which of those names the line defined as functions,
+     * from the bytecode it ran. Without it the VM is asked, which cannot tell
+     * a line that defined `f` from one that set the variable `f` under a
+     * function of that name defined above.
      * @returns The new checkpoint, or null if no variable names provided.
      */
-    snapshot(lineNumber: number, lineId: number, variableNames: string[]): VMCheckpoint | null;
+    snapshot(lineNumber: number, lineId: number, variableNames: string[], functionNames?: ReadonlySet<string>): VMCheckpoint | null;
     /**
      * Restore the VM to the state at or just after the given line number.
      *
@@ -1087,6 +1259,33 @@ declare class VMCheckpointer {
      *
      * @param names - The names no line defines any more.
      */
+    /**
+     * Drop the entry a line holds, because the line no longer writes anything.
+     *
+     * A line's entry is replaced when the line writes again and left alone
+     * otherwise, so a definition edited into an expression with no definition in
+     * it (`:v3 = 44` edited to `7 + 7`) kept saying `v3 = 44` in the chain. The
+     * lines below it that asked what the prefix holds were told 44, where a pass
+     * from scratch has nothing there. The entry after it is re-parented to the
+     * one before, the same way {@link snapshot} keeps the links straight.
+     *
+     * @param lineNumber - 1-based line whose entry, if any, goes.
+     */
+    dropCheckpointAt(lineNumber: number): void;
+    /**
+     * Follow every line to its new position after a structural edit.
+     *
+     * An insert or a delete moves every line below it, and the chain is read
+     * by position. It used to be cleared instead and rebuilt as lines ran, but
+     * a clean line above the viewport never runs, so its entry was gone for
+     * good and a line below asking what the prefix held was told nothing:
+     * `:a = 5` above the viewport was reported as undefined by `:b = a + c`
+     * under it. Each entry follows its line by id, the entry of a deleted
+     * line goes, and the parents are linked again in the new order.
+     *
+     * @param positionOf - The 1-based position a line id has now, or -1 for a line that is gone.
+     */
+    renumber(positionOf: (lineId: number) => number): void;
     forget(names: readonly string[]): void;
     /**
      * Find the nearest checkpoint at or before the given line number.
@@ -1122,6 +1321,38 @@ declare class VMCheckpointer {
      *
      * @returns The Value, or undefined if the variable was never set.
      */
+    /**
+     * The value a name held at the end of the line before `lineNumber`, or
+     * undefined if no line above it had set one.
+     *
+     * What a definition that failed leaves behind. A pass from scratch skips
+     * the store when the right-hand side errors, so the name keeps whatever the
+     * lines above it had put there: `:x = 1` then `:x = zz` leaves `x` at 1,
+     * and `:x = zz` on its own leaves it undefined. The incremental path holds
+     * the value from the previous pass instead, which for the line that failed
+     * is its own old answer, so the evaluator asks here what the prefix holds
+     * and puts that back. The chain records what each line wrote, in document
+     * order, so the entry nearest before the line, followed through its
+     * parents, is exactly the prefix.
+     *
+     * @param name - The variable.
+     * @param lineNumber - The 1-based line whose own entry is to be excluded.
+     * @returns The value the lines above set, or undefined.
+     */
+    /**
+     * The function a name was bound to at the end of the line before
+     * `lineNumber`, or undefined if no line above it had defined one.
+     *
+     * {@link lookupVariableBefore}, for the functions bag: a function
+     * definition is a definition, and one edited away or failed leaves the name
+     * as the lines above left it just as a variable does.
+     *
+     * @param name - The function name.
+     * @param lineNumber - The 1-based line whose own entry is to be excluded.
+     * @returns The definition the lines above made, or undefined.
+     */
+    lookupFunctionBefore(name: string, lineNumber: number): UserFunctionDef | undefined;
+    lookupVariableBefore(name: string, lineNumber: number): Value | undefined;
     lookupVariable(name: string): Value | undefined;
     /**
      * Clear all checkpoints. The underlying VM is NOT reset, call