@suss/resolution 0.27.0 → 0.29.0

package/dist/index.d.cts

@@ -1,5 +1,72 @@
 import * as _suss_datalog from '@suss/datalog';
-import { Database, Atom, Tuple, Proof, Rule } from '@suss/datalog';
+import { Database, OnDemandRules, Atom, Tuple, Proof, Rule } from '@suss/datalog';
+
+/**
+ * What a call's callee is, and when the rules settle on nothing, why.
+ *
+ * `resolves` comes back with a function and stays quiet otherwise, and a
+ * caller recording a gap needs the quiet cases told apart: a method on
+ * what a caller passed in is a different stop from a method on a value
+ * this run never read. So when the rules settle nothing, this walks down
+ * the facts the value was built from, one construct at a time, until it
+ * meets something that says where the value came from.
+ *
+ * Both halves are here because every language emits the same facts and
+ * meets the same stops. The words for an outcome stay with a language.
+ */
+
+/** What a value a call is made through turns out to be. */
+type CalleeOutcome = 
+/** One function in this run. */
+{
+    readonly kind: "function";
+    readonly key: string;
+}
+/** One object in this run, which is a class where a language writes classes as objects. */
+ | {
+    readonly kind: "object";
+    readonly key: string;
+}
+/** More than one, so no single answer, and `sources` tells them apart. */
+ | {
+    readonly kind: "severalSources";
+    readonly sources: readonly string[];
+}
+/** A parameter, whose key is here so a caller can say whose parameter it is. */
+ | {
+    readonly kind: "callerSupplied";
+    readonly key: string;
+}
+/** Something a dependency built, or a name from a module this run never read. */
+ | {
+    readonly kind: "outsideRun";
+}
+/** Built in this run by something the rules could not follow through. */
+ | {
+    readonly kind: "unsettled";
+}
+/** Nothing in this run says anything about it. */
+ | {
+    readonly kind: "undeclared";
+};
+/**
+ * What each of these callees is. One batch, so evaluation runs per wave
+ * rather than per callee. A language whose adapter states rules of its
+ * own passes the program those rules were built into, so this runs over
+ * the same evaluation state the rest of that run uses.
+ */
+declare function calleeOutcomes(db: Database, keys: readonly string[], program?: OnDemandRules): Map<string, CalleeOutcome>;
+/** What one callee is, for a caller with a single key in hand. */
+declare function calleeOutcomeOf(db: Database, key: string, program?: OnDemandRules): CalleeOutcome;
+/**
+ * Whether this run says anything at all about the key: it is a value
+ * itself, or something built it. A key that fails this settles on
+ * nothing, and asking anyway adds a `wanted` fact that every later
+ * question has to derive over, so a caller with a batch of keys and a
+ * cheap question about each one puts this in front of the batch.
+ */
+declare function couldBeSettled(db: Database, key: string): boolean;
+declare function writtenSourcesOf(db: Database, key: string): string[];
 
 /** The tuples of one relation, as strings, which is all a case compares. */
 type FactsOf = (relation: string) => string[][];
@@ -148,6 +215,84 @@ declare function mountPathsOf(edges: MountEdges, childId: string): readonly stri
  */
 declare function agreedMountPrefix(edges: MountEdges, childId: string): string | null;
 
+/**
+ * Where a name is read, over whatever parse tree an adapter hands in.
+ *
+ * `valueLeftByWrites` needs to know whether a name's writes run once each
+ * in source order, and that answer comes from the tree: every write has to
+ * be a statement of the scope's own list, and nothing before the last of
+ * them may read the name. The walk is the same in every language, so it
+ * lives here and each adapter passes a description of its grammar.
+ *
+ * A description says four things: which node types spell a name, which
+ * of them open a body that runs later, how to enumerate a node's
+ * children, and which spellings of a name are reads rather than writes or
+ * declarations. Nothing here touches a parser.
+ */
+/** The parts of a parse-tree node these walks read. */
+interface ReadNode {
+    readonly type: string;
+    readonly text: string;
+    readonly startIndex: number;
+}
+/** What one language says about finding reads of a name in its trees. */
+interface NameReads<N extends ReadNode> {
+    /** The node types a name is spelled with. Ruby has two, one of them `@name`. */
+    nameTypes: ReadonlySet<string>;
+    /**
+     * The types that open a body running later than the statements around
+     * it, so a function, a class, or a Ruby block. A read in there happens
+     * when something calls or enters the body, not where it is written.
+     */
+    laterBodies: ReadonlySet<string>;
+    /** A node's children, in source order. */
+    childrenOf: (node: N) => N[];
+    /**
+     * Whether a node spelling the name reads it, rather than being written
+     * to, declared, or spelled as somebody else's member.
+     */
+    isRead: (node: N) => boolean;
+}
+/** What one language says about which part of a chained expression is read first. */
+interface ChainReads<N extends ReadNode> {
+    /** The node types a name is spelled with. Ruby has two, one of them `@name`. */
+    nameTypes: ReadonlySet<string>;
+    /**
+     * The part of an expression read before the rest of it, so a call's
+     * callee or a member read's object, or null when nothing is read before
+     * this node.
+     */
+    readFirst: (node: N) => N | null;
+}
+/** One write to a name, in the order it is written. */
+interface OrderedWrite<N extends ReadNode> {
+    /** The node whose position orders this write among the scope's others. */
+    at: N;
+    /** Whether the write is a statement of the scope's own statement list. */
+    direct: boolean;
+}
+/**
+ * Whether the writes run once each, in the order they are written.
+ *
+ * They do when every one of them is a statement of the scope's own list.
+ * That list runs through once, top to bottom: nothing repeats and nothing
+ * is skipped. A write inside a branch, a loop, a block or a nested
+ * definition runs when something reaches it, and how many times is not a
+ * question this reads.
+ *
+ * The last write also has to be the one every read sees, so a read before
+ * it makes the answer depend on where the reader is, which the rules
+ * cannot express.
+ */
+declare function writesRunInOrder<N extends ReadNode>(scope: N | null, name: string, writes: readonly OrderedWrite<N>[], rules: NameReads<N>): boolean;
+/**
+ * Whether reading this expression starts by reading `name`, through
+ * however many calls, member reads and parentheses. That is what makes
+ * `query = query.filter(x)` a write narrowing what the other writes gave
+ * the name rather than one replacing it.
+ */
+declare function startsAtName<N extends ReadNode>(node: N, name: string, rules: ChainReads<N>): boolean;
+
 /**
  * The tree-sitter adapters key a node by its file and byte span,
  * `file:start-end`. This finds the node a key refers to again, for an
@@ -167,6 +312,52 @@ interface SpannedNode<N> {
  */
 declare function nodeOfKey<N extends SpannedNode<N>>(rootsByFile: ReadonlyMap<string, N>, key: string): N | null;
 
+/**
+ * The rules an adapter evaluates, and how a question is put to them.
+ *
+ * A demand-rewritten rule set is named by its shape, so two adapters
+ * that build the same array share one evaluation state and clearing
+ * under one of them resets the other. Every adapter builds its program
+ * here instead, and a language that states rules of its own gets one
+ * program of its own to pass around.
+ */
+
+/**
+ * The facts that say somebody is asking. Each seeds one family of
+ * questions, and none of them is derived, so these are what a caller
+ * adds and what it takes back once it has read the answer.
+ */
+declare const ASKING_RELATIONS: readonly string[];
+/**
+ * The shared rules, whatever the language states of its own, and the
+ * questions, rewritten so a relation is derived only where a question
+ * reaches it. Built once per language and kept, because the rewrite
+ * does not depend on the facts.
+ *
+ * `SUSS_RESOLUTION_ON_DEMAND=0` runs the same rules unrestricted. Both
+ * settings give the same answers; they differ in how much never gets
+ * derived at all.
+ */
+declare function resolutionProgram(languageRules?: readonly Rule[]): OnDemandRules;
+/**
+ * What a caller takes back once it has read an answer: the question and
+ * every relation derived under it. Empty when nothing is demand-driven,
+ * since then the answers themselves are what clearing would remove.
+ */
+declare function queryFacts(program: OnDemandRules): readonly string[];
+/**
+ * Ask about these values, derive, and take the question back.
+ *
+ * Asking about everything in a project costs seconds on a large one and
+ * settles questions nobody has, so a caller lists the keys it needs. The
+ * answers stay in the database; the question and the chain that settled
+ * it go, so the next question does not derive over every question asked
+ * before it. What has already been asked is remembered, so asking twice
+ * costs nothing. That wants every fact in the database before the first
+ * question, which is how each adapter reads a project.
+ */
+declare function askResolution(db: Database, keys: Iterable<string>, asking?: string, program?: OnDemandRules): void;
+
 /**
  * The result shape a why session hands back, shared by every language
  * adapter so the CLI reads one type regardless of which adapter
@@ -243,6 +434,55 @@ declare function singleAnswers(rows: Iterable<Tuple>, placeholders?: ReadonlySet
 /** The keys an adapter marked `placeholderValue`, for passing to `singleAnswers`. */
 declare function placeholderValues(db: Database): ReadonlySet<string>;
 
+/**
+ * What a name written more than once comes down to.
+ *
+ * Each adapter reads writes out of a different parser, so the reading
+ * stays with the adapter and the decision lives here, over a
+ * description of the writes that nothing parser-shaped reaches. While
+ * each adapter decided for itself, the same source resolved in one
+ * language and not in another.
+ *
+ * Whether the writes run in order is a question about statement
+ * structure, and `writesRunInOrder` works that out beside this.
+ */
+/** One write to a name, in the order it is written. */
+interface NameWrite {
+    /**
+     * The key of the value written, or null when the write states no
+     * value of its own, as `count += 1` and `index++` do.
+     */
+    value: string | null;
+    /** Whether a later write is expected to replace this value: `null`, `undefined`, `None`, `nil`. */
+    placeholder: boolean;
+    /**
+     * The value's source text when it is built where it is written, so a
+     * call, a `new`, or an object or array literal. Null otherwise.
+     */
+    construction: string | null;
+    /**
+     * Whether the value is a call on the name being written, `query =
+     * query.filter(x)`, which leaves the name what the other writes gave
+     * it with a method applied. A call returning something of another kind
+     * is not told apart, and a narrowing written through a second name,
+     * `tmp = query.limit(1)` then `query = tmp`, is not recognized.
+     */
+    narrowsName: boolean;
+}
+/**
+ * The value a name comes down to, or null when the writes leave it
+ * undecided.
+ *
+ * With `ordered`, every write runs once in the order it is written and
+ * nothing reads the name in between, so the last write is what a reader
+ * sees. Otherwise the writes are candidates the caller cannot order,
+ * and they settle the name only when they all build the same thing.
+ *
+ * A write with no value of its own puts a hole in the sequence, and then
+ * no write can be called the last one. A narrowing write is set aside.
+ */
+declare function valueLeftByWrites(writes: readonly NameWrite[], ordered: boolean): string | null;
+
 /**
  * The single expression a value was written as, once the caller has
  * asked the rules about `key`. A call to a project function is asked
@@ -299,4 +539,4 @@ declare const RESOLUTION_QUESTIONS: _suss_datalog.Rule[];
 /** The relations `RESOLUTION_QUESTIONS` answers into. */
 declare const ANSWER_RELATIONS: string[];
 
-export { ANSWER_RELATIONS, type CaseFiles, type ContractCase, type ContractOptions, type DescribeAtom, type ExplainOptions, type ExplainResolvedKeyOptions, type ExplainStats, FACT_CONTRACT_CASES, type FactsOf, type MountEdge, type MountEdges, NAMESPACE_IMPORT, NAMESPACE_IMPORT_NAME, RESOLUTION_QUESTIONS, RESOLUTION_RULES, RESULT_STEP, type ResolutionExplanation, type ResolutionStep, type SpannedNode, type StepContext, type StepPhrase, VALUE_STEP, type ValueLocation, type WhyExplained, agreedMountPrefix, checkFactContract, explainResolutionProof, explainResolvedKey, joinMountedPath, mountPathsOf, nodeOfKey, placeholderValues, renderExplanation, singleAnswers, writtenValueOf };
+export { ANSWER_RELATIONS, ASKING_RELATIONS, type CalleeOutcome, type CaseFiles, type ChainReads, type ContractCase, type ContractOptions, type DescribeAtom, type ExplainOptions, type ExplainResolvedKeyOptions, type ExplainStats, FACT_CONTRACT_CASES, type FactsOf, type MountEdge, type MountEdges, NAMESPACE_IMPORT, NAMESPACE_IMPORT_NAME, type NameReads, type NameWrite, type OrderedWrite, RESOLUTION_QUESTIONS, RESOLUTION_RULES, RESULT_STEP, type ReadNode, type ResolutionExplanation, type ResolutionStep, type SpannedNode, type StepContext, type StepPhrase, VALUE_STEP, type ValueLocation, type WhyExplained, agreedMountPrefix, askResolution, calleeOutcomeOf, calleeOutcomes, checkFactContract, couldBeSettled, explainResolutionProof, explainResolvedKey, joinMountedPath, mountPathsOf, nodeOfKey, placeholderValues, queryFacts, renderExplanation, resolutionProgram, singleAnswers, startsAtName, valueLeftByWrites, writesRunInOrder, writtenSourcesOf, writtenValueOf };

package/dist/index.d.ts

@@ -1,5 +1,72 @@
 import * as _suss_datalog from '@suss/datalog';
-import { Database, Atom, Tuple, Proof, Rule } from '@suss/datalog';
+import { Database, OnDemandRules, Atom, Tuple, Proof, Rule } from '@suss/datalog';
+
+/**
+ * What a call's callee is, and when the rules settle on nothing, why.
+ *
+ * `resolves` comes back with a function and stays quiet otherwise, and a
+ * caller recording a gap needs the quiet cases told apart: a method on
+ * what a caller passed in is a different stop from a method on a value
+ * this run never read. So when the rules settle nothing, this walks down
+ * the facts the value was built from, one construct at a time, until it
+ * meets something that says where the value came from.
+ *
+ * Both halves are here because every language emits the same facts and
+ * meets the same stops. The words for an outcome stay with a language.
+ */
+
+/** What a value a call is made through turns out to be. */
+type CalleeOutcome = 
+/** One function in this run. */
+{
+    readonly kind: "function";
+    readonly key: string;
+}
+/** One object in this run, which is a class where a language writes classes as objects. */
+ | {
+    readonly kind: "object";
+    readonly key: string;
+}
+/** More than one, so no single answer, and `sources` tells them apart. */
+ | {
+    readonly kind: "severalSources";
+    readonly sources: readonly string[];
+}
+/** A parameter, whose key is here so a caller can say whose parameter it is. */
+ | {
+    readonly kind: "callerSupplied";
+    readonly key: string;
+}
+/** Something a dependency built, or a name from a module this run never read. */
+ | {
+    readonly kind: "outsideRun";
+}
+/** Built in this run by something the rules could not follow through. */
+ | {
+    readonly kind: "unsettled";
+}
+/** Nothing in this run says anything about it. */
+ | {
+    readonly kind: "undeclared";
+};
+/**
+ * What each of these callees is. One batch, so evaluation runs per wave
+ * rather than per callee. A language whose adapter states rules of its
+ * own passes the program those rules were built into, so this runs over
+ * the same evaluation state the rest of that run uses.
+ */
+declare function calleeOutcomes(db: Database, keys: readonly string[], program?: OnDemandRules): Map<string, CalleeOutcome>;
+/** What one callee is, for a caller with a single key in hand. */
+declare function calleeOutcomeOf(db: Database, key: string, program?: OnDemandRules): CalleeOutcome;
+/**
+ * Whether this run says anything at all about the key: it is a value
+ * itself, or something built it. A key that fails this settles on
+ * nothing, and asking anyway adds a `wanted` fact that every later
+ * question has to derive over, so a caller with a batch of keys and a
+ * cheap question about each one puts this in front of the batch.
+ */
+declare function couldBeSettled(db: Database, key: string): boolean;
+declare function writtenSourcesOf(db: Database, key: string): string[];
 
 /** The tuples of one relation, as strings, which is all a case compares. */
 type FactsOf = (relation: string) => string[][];
@@ -148,6 +215,84 @@ declare function mountPathsOf(edges: MountEdges, childId: string): readonly stri
  */
 declare function agreedMountPrefix(edges: MountEdges, childId: string): string | null;
 
+/**
+ * Where a name is read, over whatever parse tree an adapter hands in.
+ *
+ * `valueLeftByWrites` needs to know whether a name's writes run once each
+ * in source order, and that answer comes from the tree: every write has to
+ * be a statement of the scope's own list, and nothing before the last of
+ * them may read the name. The walk is the same in every language, so it
+ * lives here and each adapter passes a description of its grammar.
+ *
+ * A description says four things: which node types spell a name, which
+ * of them open a body that runs later, how to enumerate a node's
+ * children, and which spellings of a name are reads rather than writes or
+ * declarations. Nothing here touches a parser.
+ */
+/** The parts of a parse-tree node these walks read. */
+interface ReadNode {
+    readonly type: string;
+    readonly text: string;
+    readonly startIndex: number;
+}
+/** What one language says about finding reads of a name in its trees. */
+interface NameReads<N extends ReadNode> {
+    /** The node types a name is spelled with. Ruby has two, one of them `@name`. */
+    nameTypes: ReadonlySet<string>;
+    /**
+     * The types that open a body running later than the statements around
+     * it, so a function, a class, or a Ruby block. A read in there happens
+     * when something calls or enters the body, not where it is written.
+     */
+    laterBodies: ReadonlySet<string>;
+    /** A node's children, in source order. */
+    childrenOf: (node: N) => N[];
+    /**
+     * Whether a node spelling the name reads it, rather than being written
+     * to, declared, or spelled as somebody else's member.
+     */
+    isRead: (node: N) => boolean;
+}
+/** What one language says about which part of a chained expression is read first. */
+interface ChainReads<N extends ReadNode> {
+    /** The node types a name is spelled with. Ruby has two, one of them `@name`. */
+    nameTypes: ReadonlySet<string>;
+    /**
+     * The part of an expression read before the rest of it, so a call's
+     * callee or a member read's object, or null when nothing is read before
+     * this node.
+     */
+    readFirst: (node: N) => N | null;
+}
+/** One write to a name, in the order it is written. */
+interface OrderedWrite<N extends ReadNode> {
+    /** The node whose position orders this write among the scope's others. */
+    at: N;
+    /** Whether the write is a statement of the scope's own statement list. */
+    direct: boolean;
+}
+/**
+ * Whether the writes run once each, in the order they are written.
+ *
+ * They do when every one of them is a statement of the scope's own list.
+ * That list runs through once, top to bottom: nothing repeats and nothing
+ * is skipped. A write inside a branch, a loop, a block or a nested
+ * definition runs when something reaches it, and how many times is not a
+ * question this reads.
+ *
+ * The last write also has to be the one every read sees, so a read before
+ * it makes the answer depend on where the reader is, which the rules
+ * cannot express.
+ */
+declare function writesRunInOrder<N extends ReadNode>(scope: N | null, name: string, writes: readonly OrderedWrite<N>[], rules: NameReads<N>): boolean;
+/**
+ * Whether reading this expression starts by reading `name`, through
+ * however many calls, member reads and parentheses. That is what makes
+ * `query = query.filter(x)` a write narrowing what the other writes gave
+ * the name rather than one replacing it.
+ */
+declare function startsAtName<N extends ReadNode>(node: N, name: string, rules: ChainReads<N>): boolean;
+
 /**
  * The tree-sitter adapters key a node by its file and byte span,
  * `file:start-end`. This finds the node a key refers to again, for an
@@ -167,6 +312,52 @@ interface SpannedNode<N> {
  */
 declare function nodeOfKey<N extends SpannedNode<N>>(rootsByFile: ReadonlyMap<string, N>, key: string): N | null;
 
+/**
+ * The rules an adapter evaluates, and how a question is put to them.
+ *
+ * A demand-rewritten rule set is named by its shape, so two adapters
+ * that build the same array share one evaluation state and clearing
+ * under one of them resets the other. Every adapter builds its program
+ * here instead, and a language that states rules of its own gets one
+ * program of its own to pass around.
+ */
+
+/**
+ * The facts that say somebody is asking. Each seeds one family of
+ * questions, and none of them is derived, so these are what a caller
+ * adds and what it takes back once it has read the answer.
+ */
+declare const ASKING_RELATIONS: readonly string[];
+/**
+ * The shared rules, whatever the language states of its own, and the
+ * questions, rewritten so a relation is derived only where a question
+ * reaches it. Built once per language and kept, because the rewrite
+ * does not depend on the facts.
+ *
+ * `SUSS_RESOLUTION_ON_DEMAND=0` runs the same rules unrestricted. Both
+ * settings give the same answers; they differ in how much never gets
+ * derived at all.
+ */
+declare function resolutionProgram(languageRules?: readonly Rule[]): OnDemandRules;
+/**
+ * What a caller takes back once it has read an answer: the question and
+ * every relation derived under it. Empty when nothing is demand-driven,
+ * since then the answers themselves are what clearing would remove.
+ */
+declare function queryFacts(program: OnDemandRules): readonly string[];
+/**
+ * Ask about these values, derive, and take the question back.
+ *
+ * Asking about everything in a project costs seconds on a large one and
+ * settles questions nobody has, so a caller lists the keys it needs. The
+ * answers stay in the database; the question and the chain that settled
+ * it go, so the next question does not derive over every question asked
+ * before it. What has already been asked is remembered, so asking twice
+ * costs nothing. That wants every fact in the database before the first
+ * question, which is how each adapter reads a project.
+ */
+declare function askResolution(db: Database, keys: Iterable<string>, asking?: string, program?: OnDemandRules): void;
+
 /**
  * The result shape a why session hands back, shared by every language
  * adapter so the CLI reads one type regardless of which adapter
@@ -243,6 +434,55 @@ declare function singleAnswers(rows: Iterable<Tuple>, placeholders?: ReadonlySet
 /** The keys an adapter marked `placeholderValue`, for passing to `singleAnswers`. */
 declare function placeholderValues(db: Database): ReadonlySet<string>;
 
+/**
+ * What a name written more than once comes down to.
+ *
+ * Each adapter reads writes out of a different parser, so the reading
+ * stays with the adapter and the decision lives here, over a
+ * description of the writes that nothing parser-shaped reaches. While
+ * each adapter decided for itself, the same source resolved in one
+ * language and not in another.
+ *
+ * Whether the writes run in order is a question about statement
+ * structure, and `writesRunInOrder` works that out beside this.
+ */
+/** One write to a name, in the order it is written. */
+interface NameWrite {
+    /**
+     * The key of the value written, or null when the write states no
+     * value of its own, as `count += 1` and `index++` do.
+     */
+    value: string | null;
+    /** Whether a later write is expected to replace this value: `null`, `undefined`, `None`, `nil`. */
+    placeholder: boolean;
+    /**
+     * The value's source text when it is built where it is written, so a
+     * call, a `new`, or an object or array literal. Null otherwise.
+     */
+    construction: string | null;
+    /**
+     * Whether the value is a call on the name being written, `query =
+     * query.filter(x)`, which leaves the name what the other writes gave
+     * it with a method applied. A call returning something of another kind
+     * is not told apart, and a narrowing written through a second name,
+     * `tmp = query.limit(1)` then `query = tmp`, is not recognized.
+     */
+    narrowsName: boolean;
+}
+/**
+ * The value a name comes down to, or null when the writes leave it
+ * undecided.
+ *
+ * With `ordered`, every write runs once in the order it is written and
+ * nothing reads the name in between, so the last write is what a reader
+ * sees. Otherwise the writes are candidates the caller cannot order,
+ * and they settle the name only when they all build the same thing.
+ *
+ * A write with no value of its own puts a hole in the sequence, and then
+ * no write can be called the last one. A narrowing write is set aside.
+ */
+declare function valueLeftByWrites(writes: readonly NameWrite[], ordered: boolean): string | null;
+
 /**
  * The single expression a value was written as, once the caller has
  * asked the rules about `key`. A call to a project function is asked
@@ -299,4 +539,4 @@ declare const RESOLUTION_QUESTIONS: _suss_datalog.Rule[];
 /** The relations `RESOLUTION_QUESTIONS` answers into. */
 declare const ANSWER_RELATIONS: string[];
 
-export { ANSWER_RELATIONS, type CaseFiles, type ContractCase, type ContractOptions, type DescribeAtom, type ExplainOptions, type ExplainResolvedKeyOptions, type ExplainStats, FACT_CONTRACT_CASES, type FactsOf, type MountEdge, type MountEdges, NAMESPACE_IMPORT, NAMESPACE_IMPORT_NAME, RESOLUTION_QUESTIONS, RESOLUTION_RULES, RESULT_STEP, type ResolutionExplanation, type ResolutionStep, type SpannedNode, type StepContext, type StepPhrase, VALUE_STEP, type ValueLocation, type WhyExplained, agreedMountPrefix, checkFactContract, explainResolutionProof, explainResolvedKey, joinMountedPath, mountPathsOf, nodeOfKey, placeholderValues, renderExplanation, singleAnswers, writtenValueOf };
+export { ANSWER_RELATIONS, ASKING_RELATIONS, type CalleeOutcome, type CaseFiles, type ChainReads, type ContractCase, type ContractOptions, type DescribeAtom, type ExplainOptions, type ExplainResolvedKeyOptions, type ExplainStats, FACT_CONTRACT_CASES, type FactsOf, type MountEdge, type MountEdges, NAMESPACE_IMPORT, NAMESPACE_IMPORT_NAME, type NameReads, type NameWrite, type OrderedWrite, RESOLUTION_QUESTIONS, RESOLUTION_RULES, RESULT_STEP, type ReadNode, type ResolutionExplanation, type ResolutionStep, type SpannedNode, type StepContext, type StepPhrase, VALUE_STEP, type ValueLocation, type WhyExplained, agreedMountPrefix, askResolution, calleeOutcomeOf, calleeOutcomes, checkFactContract, couldBeSettled, explainResolutionProof, explainResolvedKey, joinMountedPath, mountPathsOf, nodeOfKey, placeholderValues, queryFacts, renderExplanation, resolutionProgram, singleAnswers, startsAtName, valueLeftByWrites, writesRunInOrder, writtenSourcesOf, writtenValueOf };