solve-engine 2.38.17 → 2.38.19

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

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

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

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

package/dist/{PackageRegistry-bOwZZ3Co.d.cts → PackageRegistry-7dFbaAZp.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-8xIW2gTv.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 { 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';
@@ -464,6 +464,21 @@ declare class DocumentModel {
     /**
      * Mark a line as clean (re-evaluated successfully).
      */
+    /**
+     * Forget what a line answered, without forgetting the line.
+     *
+     * For a line whose answer was computed about a document that no longer
+     * exists. Marking it dirty says it must run again; this says that until it
+     * does, it has nothing to tell anyone who asks, which is the state a pass
+     * over the text from scratch would be in.
+     *
+     * The bytecode is left alone. It is compiled from the line's own text, which
+     * a structural edit does not change, and dropping it would recompile the
+     * document for nothing.
+     *
+     * @param lineId - Persistent line identifier.
+     */
+    forgetResult(lineId: number): void;
     markClean(lineId: number): void;
     /**
      * Mark a line as dirty (needs re-evaluation) by its 1-based position.
@@ -910,11 +925,37 @@ declare class AsyncResolutionBatcher {
     constructor(dag: DependencyGraph, lineCache: LineCache, vm: VM, highWaterMark?: number);
     /**
      * Create a fresh internal event stream and wire its controller.
-     * Called from the constructor and again from clearAll() so the batcher
-     * keeps emitting events after an engine clear, the engine instance
-     * (and this batcher) live on across clear() calls.
+     *
+     * Called from {@link eventStream} on first use and again after clearAll(),
+     * so the batcher keeps emitting events after an engine clear: the engine
+     * instance (and this batcher) live on across clear() calls.
      */
     private createEventStream;
+    /**
+     * The event stream, built the first time anything needs one.
+     *
+     * It used to be built in the constructor, and a ReadableStream is not free
+     * to build: its start algorithm queues promise reactions, so every engine
+     * paid for a stream, and a host that constructs engines in a synchronous
+     * loop accumulated one engine's worth of pending microtasks per engine
+     * because nothing drained them until the loop ended. At roughly nine
+     * kilobytes each that is ninety megabytes over ten thousand engines, for a
+     * stream almost none of them ever read.
+     *
+     * Building it on first use rather than on first subscribe is what keeps the
+     * behaviour identical. The stream buffers up to `highWaterMark` events with
+     * no reader attached, so a consumer that subscribes after some events have
+     * already flowed still receives them; deferring until {@link getEventStream}
+     * would have dropped exactly those. So the emit path asks for it too, and
+     * the engine that never resolves anything asynchronously and never
+     * subscribes is the only one that never builds it, which is the case worth
+     * optimising.
+     *
+     * A cancelled stream is not rebuilt: cancellation clears the controller but
+     * leaves the stream itself in place, so the check below sees one and the
+     * events go nowhere, which is what cancelling asked for.
+     */
+    private eventStream;
     /**
      * Add a resolved query key to the pending batch.
      *

package/dist/{PackageRegistry-BF6WA6w6.d.ts → PackageRegistry-B6s8LGCu.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-ChJ7Joj0.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 { 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';
@@ -464,6 +464,21 @@ declare class DocumentModel {
     /**
      * Mark a line as clean (re-evaluated successfully).
      */
+    /**
+     * Forget what a line answered, without forgetting the line.
+     *
+     * For a line whose answer was computed about a document that no longer
+     * exists. Marking it dirty says it must run again; this says that until it
+     * does, it has nothing to tell anyone who asks, which is the state a pass
+     * over the text from scratch would be in.
+     *
+     * The bytecode is left alone. It is compiled from the line's own text, which
+     * a structural edit does not change, and dropping it would recompile the
+     * document for nothing.
+     *
+     * @param lineId - Persistent line identifier.
+     */
+    forgetResult(lineId: number): void;
     markClean(lineId: number): void;
     /**
      * Mark a line as dirty (needs re-evaluation) by its 1-based position.
@@ -910,11 +925,37 @@ declare class AsyncResolutionBatcher {
     constructor(dag: DependencyGraph, lineCache: LineCache, vm: VM, highWaterMark?: number);
     /**
      * Create a fresh internal event stream and wire its controller.
-     * Called from the constructor and again from clearAll() so the batcher
-     * keeps emitting events after an engine clear, the engine instance
-     * (and this batcher) live on across clear() calls.
+     *
+     * Called from {@link eventStream} on first use and again after clearAll(),
+     * so the batcher keeps emitting events after an engine clear: the engine
+     * instance (and this batcher) live on across clear() calls.
      */
     private createEventStream;
+    /**
+     * The event stream, built the first time anything needs one.
+     *
+     * It used to be built in the constructor, and a ReadableStream is not free
+     * to build: its start algorithm queues promise reactions, so every engine
+     * paid for a stream, and a host that constructs engines in a synchronous
+     * loop accumulated one engine's worth of pending microtasks per engine
+     * because nothing drained them until the loop ended. At roughly nine
+     * kilobytes each that is ninety megabytes over ten thousand engines, for a
+     * stream almost none of them ever read.
+     *
+     * Building it on first use rather than on first subscribe is what keeps the
+     * behaviour identical. The stream buffers up to `highWaterMark` events with
+     * no reader attached, so a consumer that subscribes after some events have
+     * already flowed still receives them; deferring until {@link getEventStream}
+     * would have dropped exactly those. So the emit path asks for it too, and
+     * the engine that never resolves anything asynchronously and never
+     * subscribes is the only one that never builds it, which is the case worth
+     * optimising.
+     *
+     * A cancelled stream is not rebuilt: cancellation clears the controller but
+     * leaves the stream itself in place, so the check below sees one and the
+     * events go nowhere, which is what cancelling asked for.
+     */
+    private eventStream;
     /**
      * Add a resolved query key to the pending batch.
      *

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

@@ -729,6 +729,25 @@ declare class DependencyGraph {
      * @param dependsOnLine - 1-based line whose result it read
      */
     registerLinePositionDependency(lineNumber: number, dependsOnLine: number): void;
+    /**
+     * Every line that read some position's result, whichever position it was.
+     *
+     * For a structural edit, which changes what a position *means* rather than
+     * what any line says. Inserting a line moves everything below it, so `line 5`
+     * now names different text, `prev` names a different neighbour, and an
+     * `above` aggregate covers a different block, all without a character
+     * changing on the line that reads them.
+     *
+     * Deliberately not filtered by which positions moved. A reader whose target
+     * shifted has to re-run, and so does one that shifted past its own target and
+     * became a self-reference, and the second is not visible from the target
+     * alone. Positional readers are a small minority of a document's lines, so
+     * re-running all of them costs almost nothing and cannot be wrong.
+     *
+     * @returns The 1-based line numbers doing the reading, valid until the next
+     * structural change.
+     */
+    linesReadingAPosition(): Iterable<number>;
     /**
      * The lines that read the result of line `lineNumber`.
      *

package/dist/{VMBuiltins-ChJ7Joj0.d.ts → VMBuiltins-Bu6qaKi0.d.ts}

@@ -729,6 +729,25 @@ declare class DependencyGraph {
      * @param dependsOnLine - 1-based line whose result it read
      */
     registerLinePositionDependency(lineNumber: number, dependsOnLine: number): void;
+    /**
+     * Every line that read some position's result, whichever position it was.
+     *
+     * For a structural edit, which changes what a position *means* rather than
+     * what any line says. Inserting a line moves everything below it, so `line 5`
+     * now names different text, `prev` names a different neighbour, and an
+     * `above` aggregate covers a different block, all without a character
+     * changing on the line that reads them.
+     *
+     * Deliberately not filtered by which positions moved. A reader whose target
+     * shifted has to re-run, and so does one that shifted past its own target and
+     * became a self-reference, and the second is not visible from the target
+     * alone. Positional readers are a small minority of a document's lines, so
+     * re-running all of them costs almost nothing and cannot be wrong.
+     *
+     * @returns The 1-based line numbers doing the reading, valid until the next
+     * structural change.
+     */
+    linesReadingAPosition(): Iterable<number>;
     /**
      * The lines that read the result of line `lineNumber`.
      *