@descryy/core 0.2.0 → 0.3.0

package/dist/graph/observed-tests.js

@@ -0,0 +1,123 @@
+/**
+ * `observed_tests` — the EARNED record of which tests actually ran.
+ *
+ * This is the coverage axis, and coverage is deliberately not confidence: AI
+ * layer §20 separates *"what I actually verified"* from *"how sure am I"*, and
+ * the five report categories say nothing about the first. This module is the
+ * carrier for that separation, ruled in
+ * `documents/decisions-inbox/DEC-NEXT-test-run-coverage-has-no-carrier.md`.
+ *
+ * ## Why this is a table and not an R4 edge promotion
+ *
+ * The obvious-looking design is to run the suite and promote each `TESTS` edge
+ * it exercised to R4, reusing {@link applyRuntimeObservations}. That is not
+ * available, and the reason is the same one `observe-runtime.ts`'s header
+ * already gives for refusing to derive edges from correlated evidence.
+ *
+ * An edge needs **two endpoints and a witnessed relationship between them**. A
+ * test-runner's evidence carries no stack — every item it emits has
+ * `stackTrace: null` — so an observed test names exactly one node, its own
+ * `TEST_CASE`. Nothing in the run witnesses which function that test reached.
+ * Pairing the test with a function that merely co-occurred in the same run
+ * would mint an edge from temporal coincidence, which is precisely the
+ * wrong-direction failure rule 2 exists to prevent, arriving through the one
+ * mechanism built to make the graph *more* trustworthy.
+ *
+ * So the honest fact a test run establishes is a fact about **one node**: this
+ * test case executed, and this is what happened. That is not an edge and R4 in
+ * this store is a property of an edge, so it needs a carrier of its own.
+ *
+ * ## Why EARNED
+ *
+ * Same argument as `observed_edges`, one step over. Nothing in the source says
+ * which tests ran — the source says which tests *exist*. A rebuild that dropped
+ * this table would silently turn "what I actually verified" back into "what
+ * might be affected", which is the exact collapse the coverage axis exists to
+ * prevent.
+ *
+ * ## What this module refuses to do
+ *
+ * - **Invent a node.** An observation naming a node this graph does not hold is
+ *   refused with its reason, never created — rule 2, and the same posture
+ *   {@link applyRuntimeObservations} takes for an edge endpoint.
+ * - **Accept a category error.** A test outcome against a node that is not a
+ *   `TEST_CASE` is refused rather than written. The graph holds the id, so this
+ *   is not a missing-node refusal; it is a claim that would make every later
+ *   coverage read meaningless, and it is far more likely to be a resolver bug
+ *   than a real observation.
+ * - **Judge anything.** No finding, no hypothesis, no report category. It
+ *   records what ran; whether that is *enough* is a judgement for a layer above
+ *   this one.
+ *
+ * @see `packages/core/src/graph/runtime-confirmation.ts` — the edge half.
+ */
+const SYSTEM_CLOCK = { now: () => Date.now() };
+function nodeTypeOf(driver, id) {
+    const row = driver.prepare("SELECT type FROM nodes WHERE id = ?").get(id);
+    return row?.type;
+}
+/**
+ * Record a run's test observations.
+ *
+ * Total over its input: every observation lands in exactly one of
+ * {@link ObservedTestsResult.recorded} or {@link ObservedTestsResult.refused},
+ * so a caller can account for all of them without inspecting the store. Never
+ * throws for an observation it cannot act on — that is a refusal, per the
+ * five-result-states rule the tool contract applies one layer up.
+ */
+export function applyObservedTests(driver, input, clock = SYSTEM_CLOCK) {
+    const recorded = [];
+    const refused = [];
+    const now = clock.now();
+    driver.transaction(() => {
+        for (const observation of input.observations) {
+            const type = nodeTypeOf(driver, observation.nodeId);
+            if (type === undefined) {
+                refused.push({
+                    nodeId: observation.nodeId,
+                    qualifiedName: observation.qualifiedName,
+                    reason: `${observation.nodeId} is not in this graph, so the observed test cannot be recorded against it. ` +
+                        "The graph is not extended from a runtime name.",
+                });
+                continue;
+            }
+            if (type !== "TEST_CASE") {
+                refused.push({
+                    nodeId: observation.nodeId,
+                    qualifiedName: observation.qualifiedName,
+                    reason: `${observation.nodeId} is a ${type}, not a TEST_CASE — a test outcome recorded against it would ` +
+                        "make every later coverage read meaningless. Refused rather than written.",
+                });
+                continue;
+            }
+            driver
+                .prepare("INSERT INTO observed_tests (node_id, run_id, qualified_name, outcome, duration_ms, commit_sha, observed_at)" +
+                " VALUES (?, ?, ?, ?, ?, ?, ?)" +
+                " ON CONFLICT(node_id, run_id) DO UPDATE SET qualified_name = excluded.qualified_name," +
+                " outcome = excluded.outcome, duration_ms = excluded.duration_ms, observed_at = excluded.observed_at")
+                .run(observation.nodeId, input.runId, observation.qualifiedName, observation.outcome, observation.durationMs, input.commitSha, now);
+            recorded.push(observation.nodeId);
+        }
+    });
+    return { recorded, refused };
+}
+/** Read the EARNED ledger, newest observation first, optionally for one run. */
+export function observedTests(driver, options = {}) {
+    const where = options.runId === undefined ? "" : " WHERE run_id = ?";
+    const sql = "SELECT node_id, run_id, qualified_name, outcome, duration_ms, commit_sha, observed_at" +
+        ` FROM observed_tests${where} ORDER BY observed_at DESC, node_id ASC`;
+    const args = options.runId === undefined ? [] : [options.runId];
+    return driver
+        .prepare(sql)
+        .all(...args)
+        .map((row) => ({
+        nodeId: row.node_id,
+        runId: row.run_id,
+        qualifiedName: row.qualified_name,
+        outcome: row.outcome,
+        durationMs: row.duration_ms,
+        commitSha: row.commit_sha,
+        observedAt: row.observed_at,
+    }));
+}
+//# sourceMappingURL=observed-tests.js.map

package/dist/graph/observed-tests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observed-tests.js","sourceRoot":"","sources":["../../src/graph/observed-tests.ts"],"names":[],"mappings":"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"}

package/dist/query/index.d.ts

@@ -3,7 +3,7 @@ export type { AdjacencyProvider, AdjacencyOptions, GraphStamp, QueryResult, } fr
 export { createMemoryProvider } from "./memory.ts";
 export type { MemoryGraph } from "./memory.ts";
 export { createStoreProvider, commitSpread } from "./sqlite.ts";
-export { bfs, weightedBfs, findPath, API_JOIN_EDGE_TYPES } from "./traverse.ts";
+export { bfs, weightedBfs, findPath, defaultTraversalWeight, API_JOIN_EDGE_TYPES } from "./traverse.ts";
 export type { Direction, Reached, TraversalOptions, TraversalOutcome, WeightedOptions } from "./traverse.ts";
 export { impactOf, rootCauseSearch, testsCovering, dataFlowFrom, DATA_FLOW_EDGE_TYPES, traceApi, changeRisk, changesWith, } from "./queries.ts";
 export type { ImpactOptions, RootCauseMatch, ChangeRisk, CoChange } from "./queries.ts";
@@ -18,6 +18,10 @@ export type { RefusalSite, RefusalQuestion, RefusalDropCounts, GroupingResult, }
 export { summariseRefusals, fetchRefusalPage } from "./refusal-fetch.ts";
 export type { RefusalSummary, RefusalPage, RefusalPageOk, RefusalPageRefused } from "./refusal-fetch.ts";
 export { computeVerificationStatus, resolutionOfExercised } from "./verification-status.ts";
+export { observedTestCoverage } from "./test-coverage.ts";
+export type { ObservedTestFor, TestCoverageForRef } from "./test-coverage.ts";
+export { prominenceOf, withProminence, prominenceCounts, PROMINENCE_CUTOFFS } from "./prominence.ts";
+export type { Prominence, Ranked } from "./prominence.ts";
 export type { CoverageCheck, ScopeItem } from "./verification-status.ts";
 export { applyDeclaredValues, DECLARED_VALUE_RELIABILITY } from "./declared-value-closure.ts";
 export type { ClosureState, DeclaredValueClosure, DeclaredValueApplication, } from "./declared-value-closure.ts";

package/dist/query/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/query/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACjE,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,UAAU,EACV,WAAW,GACZ,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAChF,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE7G,OAAO,EACL,QAAQ,EACR,eAAe,EACf,aAAa,EACb,YAAY,EACZ,oBAAoB,EACpB,QAAQ,EACR,UAAU,EACV,WAAW,GACZ,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExF,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AACrG,YAAY,EACV,mBAAmB,EACnB,oBAAoB,EACpB,sBAAsB,EACtB,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC9E,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3F,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,YAAY,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAEzF,OAAO,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC7G,YAAY,EACV,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,cAAc,GACf,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACzE,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAEzG,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAC5F,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAEzE,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAC9F,YAAY,EACV,YAAY,EACZ,oBAAoB,EACpB,wBAAwB,GACzB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,YAAY,EACV,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,aAAa,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACpI,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,wBAAwB,EACxB,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/query/index.ts"],"names":[],"mappings":"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"}

package/dist/query/index.js

@@ -1,7 +1,7 @@
 export { rankEdges, applyAdjacencyOptions } from "./provider.js";
 export { createMemoryProvider } from "./memory.js";
 export { createStoreProvider, commitSpread } from "./sqlite.js";
-export { bfs, weightedBfs, findPath, API_JOIN_EDGE_TYPES } from "./traverse.js";
+export { bfs, weightedBfs, findPath, defaultTraversalWeight, API_JOIN_EDGE_TYPES } from "./traverse.js";
 export { impactOf, rootCauseSearch, testsCovering, dataFlowFrom, DATA_FLOW_EDGE_TYPES, traceApi, changeRisk, changesWith, } from "./queries.js";
 export { similarIncidents, tokenSetSimilarity, fileOverlapSimilarity } from "./similar-incidents.js";
 export { classifyRefusal, classifyRefusals, readRate } from "./unresolved.js";
@@ -9,6 +9,8 @@ export { applyConfirmedFacts } from "./confirmed-facts.js";
 export { groupRefusalsIntoQuestions, groupRefusalsAcrossRepos, askableHandle } from "./refusal-questions.js";
 export { summariseRefusals, fetchRefusalPage } from "./refusal-fetch.js";
 export { computeVerificationStatus, resolutionOfExercised } from "./verification-status.js";
+export { observedTestCoverage } from "./test-coverage.js";
+export { prominenceOf, withProminence, prominenceCounts, PROMINENCE_CUTOFFS } from "./prominence.js";
 export { applyDeclaredValues, DECLARED_VALUE_RELIABILITY } from "./declared-value-closure.js";
 export { describeRowClosures } from "./row-closure-picture.js";
 export { rankRootCause, DEFAULT_ROOT_CAUSE_WEIGHTS, ROOT_CAUSE_TRACE_EDGE_TYPES, INCIDENT_SATURATION } from "./root-cause-score.js";

package/dist/query/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/query/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAQjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGnD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGhF,OAAO,EACL,QAAQ,EACR,eAAe,EACf,aAAa,EACb,YAAY,EACZ,oBAAoB,EACpB,QAAQ,EACR,UAAU,EACV,WAAW,GACZ,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AASrG,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAG9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAQ7G,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGzE,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAG5F,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAO9F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAQ/D,OAAO,EAAE,aAAa,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AASpI,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/query/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAQjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGnD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,QAAQ,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGxG,OAAO,EACL,QAAQ,EACR,eAAe,EACf,aAAa,EACb,YAAY,EACZ,oBAAoB,EACpB,QAAQ,EACR,UAAU,EACV,WAAW,GACZ,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AASrG,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAG9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAQ7G,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGzE,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAC5F,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAIrG,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAO9F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAQ/D,OAAO,EAAE,aAAa,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AASpI,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/query/prominence.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Prominence — "show me the top few, not a flat list", without borrowing a
+ * calibration that does not apply.
+ *
+ * ## Why this is not `tierFor`
+ *
+ * `scoping/tiers.ts` already bands a score into §12.7's tiers 1-4 on **absolute
+ * thresholds** (0.7 and 0.3). Reusing it here was the obvious move and it is
+ * the wrong one, for a reason that is invisible from the type: the two scores
+ * are different quantities that happen to share the range (0, 1].
+ *
+ * - `scope` scores through `scoping/`: designed per-edge weights, then
+ *   `finalScore` applies co-change and incident boosts. `weights.ts` says in
+ *   its own comment that these must "stay on the same scale as an absolute tier
+ *   threshold" — the thresholds were calibrated against *this* pipeline.
+ * - `impact` and `pr_analysis` score through `weightedBfs`, whose default
+ *   `weightFor` is `edge.confidence` and nothing else. No designed weights, no
+ *   boosts. `pr_analysis` passes only a budget, so it takes that default.
+ *
+ * Feeding the second into thresholds calibrated for the first would produce
+ * bands that look like §12.7's and mean something else — a calibrated label on
+ * an uncalibrated number, which is worse than no band at all because it reads
+ * as more precise than it is.
+ *
+ * ## So this bands on rank, and rank is a fact about the answer
+ *
+ * "This was the highest-scoring item in this reply" is true whatever produced
+ * the score, and it is exactly what "show me the top few" asks for. It claims
+ * nothing about magnitude, nothing about a threshold, and nothing that a change
+ * of scoring pipeline could silently falsify.
+ *
+ * The cut-offs are reading-surface sizes rather than measurements — the same
+ * footing `NODE_BUDGETS`'s own comment puts its figures on. Tune from data.
+ */
+/** Where an item falls in its answer's own ordering. */
+export type Prominence = "top" | "notable" | "rest";
+/**
+ * Rank cut-offs, inclusive upper bounds.
+ *
+ * `top` is three because that is what a developer reads before acting; the
+ * same figure `FINDING_CAPS["pre-push"]` reaches independently, from the same
+ * reasoning about a blocked developer's attention. It is **not** imported from
+ * there: that cap governs findings through the governance funnel, this governs
+ * presentation ordering, and coupling them would make a change to either mean
+ * a change to both.
+ */
+export declare const PROMINENCE_CUTOFFS: {
+    readonly top: 3;
+    readonly notable: 10;
+};
+/** `rank` is 1-based: the highest-scoring item in an answer is rank 1. */
+export declare function prominenceOf(rank: number): Prominence;
+export interface Ranked {
+    /** 1-based position in this answer, highest score first. */
+    readonly rank: number;
+    readonly prominence: Prominence;
+}
+/**
+ * Attach `rank` and `prominence` to items already ordered highest-first.
+ *
+ * Deliberately does **not** sort. Every caller here already orders its own
+ * list, and re-sorting would either be a no-op or silently disagree with the
+ * order the caller reported elsewhere in the same reply. Ranking a list that
+ * is not in score order is a caller bug this function cannot detect, which is
+ * why it says so here rather than pretending to be total over any input.
+ */
+export declare function withProminence<T>(ordered: readonly T[]): readonly (T & Ranked)[];
+/**
+ * How many of each band a list holds — the counts a reply shows so a reader
+ * knows what the shown items were selected from.
+ */
+export declare function prominenceCounts(total: number): Readonly<Record<Prominence, number>>;
+//# sourceMappingURL=prominence.d.ts.map

package/dist/query/prominence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prominence.d.ts","sourceRoot":"","sources":["../../src/query/prominence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,wDAAwD;AACxD,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,SAAS,GAAG,MAAM,CAAC;AAEpD;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB;;;CAAmC,CAAC;AAEnE,0EAA0E;AAC1E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAIrD;AAED,MAAM,WAAW,MAAM;IACrB,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC,GAAG,MAAM,CAAC,EAAE,CAMhF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAIpF"}

package/dist/query/prominence.js

@@ -0,0 +1,79 @@
+/**
+ * Prominence — "show me the top few, not a flat list", without borrowing a
+ * calibration that does not apply.
+ *
+ * ## Why this is not `tierFor`
+ *
+ * `scoping/tiers.ts` already bands a score into §12.7's tiers 1-4 on **absolute
+ * thresholds** (0.7 and 0.3). Reusing it here was the obvious move and it is
+ * the wrong one, for a reason that is invisible from the type: the two scores
+ * are different quantities that happen to share the range (0, 1].
+ *
+ * - `scope` scores through `scoping/`: designed per-edge weights, then
+ *   `finalScore` applies co-change and incident boosts. `weights.ts` says in
+ *   its own comment that these must "stay on the same scale as an absolute tier
+ *   threshold" — the thresholds were calibrated against *this* pipeline.
+ * - `impact` and `pr_analysis` score through `weightedBfs`, whose default
+ *   `weightFor` is `edge.confidence` and nothing else. No designed weights, no
+ *   boosts. `pr_analysis` passes only a budget, so it takes that default.
+ *
+ * Feeding the second into thresholds calibrated for the first would produce
+ * bands that look like §12.7's and mean something else — a calibrated label on
+ * an uncalibrated number, which is worse than no band at all because it reads
+ * as more precise than it is.
+ *
+ * ## So this bands on rank, and rank is a fact about the answer
+ *
+ * "This was the highest-scoring item in this reply" is true whatever produced
+ * the score, and it is exactly what "show me the top few" asks for. It claims
+ * nothing about magnitude, nothing about a threshold, and nothing that a change
+ * of scoring pipeline could silently falsify.
+ *
+ * The cut-offs are reading-surface sizes rather than measurements — the same
+ * footing `NODE_BUDGETS`'s own comment puts its figures on. Tune from data.
+ */
+/**
+ * Rank cut-offs, inclusive upper bounds.
+ *
+ * `top` is three because that is what a developer reads before acting; the
+ * same figure `FINDING_CAPS["pre-push"]` reaches independently, from the same
+ * reasoning about a blocked developer's attention. It is **not** imported from
+ * there: that cap governs findings through the governance funnel, this governs
+ * presentation ordering, and coupling them would make a change to either mean
+ * a change to both.
+ */
+export const PROMINENCE_CUTOFFS = { top: 3, notable: 10 };
+/** `rank` is 1-based: the highest-scoring item in an answer is rank 1. */
+export function prominenceOf(rank) {
+    if (rank <= PROMINENCE_CUTOFFS.top)
+        return "top";
+    if (rank <= PROMINENCE_CUTOFFS.notable)
+        return "notable";
+    return "rest";
+}
+/**
+ * Attach `rank` and `prominence` to items already ordered highest-first.
+ *
+ * Deliberately does **not** sort. Every caller here already orders its own
+ * list, and re-sorting would either be a no-op or silently disagree with the
+ * order the caller reported elsewhere in the same reply. Ranking a list that
+ * is not in score order is a caller bug this function cannot detect, which is
+ * why it says so here rather than pretending to be total over any input.
+ */
+export function withProminence(ordered) {
+    return ordered.map((item, index) => ({
+        ...item,
+        rank: index + 1,
+        prominence: prominenceOf(index + 1),
+    }));
+}
+/**
+ * How many of each band a list holds — the counts a reply shows so a reader
+ * knows what the shown items were selected from.
+ */
+export function prominenceCounts(total) {
+    const top = Math.min(total, PROMINENCE_CUTOFFS.top);
+    const notable = Math.max(0, Math.min(total, PROMINENCE_CUTOFFS.notable) - top);
+    return { top, notable, rest: Math.max(0, total - top - notable) };
+}
+//# sourceMappingURL=prominence.js.map

package/dist/query/prominence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prominence.js","sourceRoot":"","sources":["../../src/query/prominence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAKH;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAW,CAAC;AAEnE,0EAA0E;AAC1E,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,IAAI,IAAI,IAAI,kBAAkB,CAAC,GAAG;QAAE,OAAO,KAAK,CAAC;IACjD,IAAI,IAAI,IAAI,kBAAkB,CAAC,OAAO;QAAE,OAAO,SAAS,CAAC;IACzD,OAAO,MAAM,CAAC;AAChB,CAAC;AAQD;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAI,OAAqB;IACrD,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;QACnC,GAAG,IAAI;QACP,IAAI,EAAE,KAAK,GAAG,CAAC;QACf,UAAU,EAAE,YAAY,CAAC,KAAK,GAAG,CAAC,CAAC;KACpC,CAAC,CAAC,CAAC;AACN,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAa;IAC5C,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACpD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC;IAC/E,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,GAAG,GAAG,OAAO,CAAC,EAAE,CAAC;AACpE,CAAC"}

package/dist/query/test-coverage.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The join from `observed_tests` to the code a caller actually asked about.
+ *
+ * `observed_tests` records facts about `TEST_CASE` nodes: this test ran, and
+ * this is how it finished. Almost nobody asks about a test case. They ask about
+ * a function, a file, a scope from an earlier `impact` call, and getting from
+ * one to the other crosses a `TESTS` edge.
+ *
+ * ## What the crossing costs, and why it is disclosed rather than hidden
+ *
+ * The `TESTS` edge is **static**. An adapter inferred it, at whatever
+ * resolution that adapter reached, and nothing in a test run witnesses it: the
+ * run witnessed that a test executed, not which functions it touched. So the
+ * honest claim this query supports is *"a test that claims to cover this ran,
+ * and here is how it finished"* and **not** *"this function executed"*. The two
+ * are close enough in English to be conflated by a reader in a hurry, and far
+ * enough apart that conflating them turns an inference into a fabricated
+ * observation. {@link ObservedTestFor} carries `direct` for exactly this
+ * reason: `true` means the caller asked about the test case itself and the
+ * answer is witnessed end to end; `false` means the answer leans on an edge no
+ * run confirmed.
+ *
+ * That is also why this lives here rather than inside
+ * `computeVerificationStatus`. That module's contract is the *static* half, it
+ * says so in its own header, and it stays that way. Composing the static half
+ * with this earned one is the tool layer's job, the same place `observe_runtime`
+ * composes rather than absorbs.
+ *
+ * ## Absent, not empty
+ *
+ * A node no observed test reaches is missing from the returned map rather than
+ * present with an empty list. Inventing a key would let a caller iterate the
+ * map and believe it had asked about everything.
+ */
+import type { ObservedTestOutcome } from "../graph/observed-tests.ts";
+import type { SqlDriver } from "../store/driver/driver.ts";
+export interface ObservedTestFor {
+    /** The `TEST_CASE` node that ran. */
+    readonly nodeId: string;
+    /** The name the run itself printed. */
+    readonly qualifiedName: string;
+    readonly outcome: ObservedTestOutcome;
+    readonly runId: string;
+    readonly observedAt: number;
+    /**
+     * `true` when the caller asked about this very test case, witnessed end to
+     * end. `false` when the answer was reached across a static `TESTS` edge,
+     * which no run confirmed. See the module header.
+     */
+    readonly direct: boolean;
+}
+export interface TestCoverageForRef {
+    readonly ref: string;
+    readonly tests: readonly ObservedTestFor[];
+}
+/**
+ * For each requested node id, the observed tests that bear on it.
+ *
+ * One test contributes at most one entry per ref: a test re-run across several
+ * runs is still one test, and the **most recent** observation is what the code
+ * stands verified against now. Reporting every historical run instead would
+ * make a flaky test look like broad coverage.
+ */
+export declare function observedTestCoverage(driver: SqlDriver, refs: readonly string[]): ReadonlyMap<string, TestCoverageForRef>;
+//# sourceMappingURL=test-coverage.d.ts.map

package/dist/query/test-coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-coverage.d.ts","sourceRoot":"","sources":["../../src/query/test-coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAE3D,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,uCAAuC;IACvC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,SAAS,eAAe,EAAE,CAAC;CAC5C;AAaD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,WAAW,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAwDzC"}

package/dist/query/test-coverage.js

@@ -0,0 +1,95 @@
+/**
+ * The join from `observed_tests` to the code a caller actually asked about.
+ *
+ * `observed_tests` records facts about `TEST_CASE` nodes: this test ran, and
+ * this is how it finished. Almost nobody asks about a test case. They ask about
+ * a function, a file, a scope from an earlier `impact` call, and getting from
+ * one to the other crosses a `TESTS` edge.
+ *
+ * ## What the crossing costs, and why it is disclosed rather than hidden
+ *
+ * The `TESTS` edge is **static**. An adapter inferred it, at whatever
+ * resolution that adapter reached, and nothing in a test run witnesses it: the
+ * run witnessed that a test executed, not which functions it touched. So the
+ * honest claim this query supports is *"a test that claims to cover this ran,
+ * and here is how it finished"* and **not** *"this function executed"*. The two
+ * are close enough in English to be conflated by a reader in a hurry, and far
+ * enough apart that conflating them turns an inference into a fabricated
+ * observation. {@link ObservedTestFor} carries `direct` for exactly this
+ * reason: `true` means the caller asked about the test case itself and the
+ * answer is witnessed end to end; `false` means the answer leans on an edge no
+ * run confirmed.
+ *
+ * That is also why this lives here rather than inside
+ * `computeVerificationStatus`. That module's contract is the *static* half, it
+ * says so in its own header, and it stays that way. Composing the static half
+ * with this earned one is the tool layer's job, the same place `observe_runtime`
+ * composes rather than absorbs.
+ *
+ * ## Absent, not empty
+ *
+ * A node no observed test reaches is missing from the returned map rather than
+ * present with an empty list. Inventing a key would let a caller iterate the
+ * map and believe it had asked about everything.
+ */
+/**
+ * For each requested node id, the observed tests that bear on it.
+ *
+ * One test contributes at most one entry per ref: a test re-run across several
+ * runs is still one test, and the **most recent** observation is what the code
+ * stands verified against now. Reporting every historical run instead would
+ * make a flaky test look like broad coverage.
+ */
+export function observedTestCoverage(driver, refs) {
+    const out = new Map();
+    if (refs.length === 0)
+        return out;
+    const placeholders = refs.map(() => "?").join(", ");
+    // Two arms, unioned rather than fetched separately so the de-duplication
+    // below sees both at once: a test case that both ran itself and is joined to
+    // by a TESTS edge must not be counted twice for one subject.
+    const sql = "SELECT e.target AS subject, o.node_id, o.qualified_name, o.outcome, o.run_id, o.observed_at," +
+        " 0 AS direct, o.rowid AS seq" +
+        " FROM observed_tests o" +
+        " JOIN edges e ON e.source = o.node_id AND e.type = 'TESTS'" +
+        ` WHERE e.target IN (${placeholders})` +
+        " UNION ALL " +
+        "SELECT o.node_id AS subject, o.node_id, o.qualified_name, o.outcome, o.run_id, o.observed_at," +
+        " 1 AS direct, o.rowid AS seq" +
+        " FROM observed_tests o" +
+        ` WHERE o.node_id IN (${placeholders})` +
+        // `seq` breaks the tie, and the tie is real rather than theoretical: two
+        // runs of one suite land in the same millisecond easily, and `observed_at`
+        // alone then leaves SQLite free to return the older run first. That made
+        // this query answer "verified against a failing run" when a later run had
+        // passed. rowid is monotonic for an ordinary (non-WITHOUT ROWID) table, so
+        // ordering by it is exactly "whichever row was written last" -- which is
+        // the semantics the timestamp was reaching for and could not express at
+        // millisecond resolution.
+        " ORDER BY observed_at DESC, seq DESC, node_id ASC";
+    const rows = driver.prepare(sql).all(...refs, ...refs);
+    // Rows arrive newest first, so the first sighting of a (subject, test) pair
+    // is the observation that stands. Later ones are older runs of the same test.
+    const seen = new Set();
+    for (const row of rows) {
+        const key = `${row.subject} ${row.node_id}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const entry = {
+            nodeId: row.node_id,
+            qualifiedName: row.qualified_name,
+            outcome: row.outcome,
+            runId: row.run_id,
+            observedAt: row.observed_at,
+            direct: row.direct === 1,
+        };
+        const existing = out.get(row.subject);
+        out.set(row.subject, {
+            ref: row.subject,
+            tests: existing === undefined ? [entry] : [...existing.tests, entry],
+        });
+    }
+    return out;
+}
+//# sourceMappingURL=test-coverage.js.map

package/dist/query/test-coverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-coverage.js","sourceRoot":"","sources":["../../src/query/test-coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAqCH;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB,CAClC,MAAiB,EACjB,IAAuB;IAEvB,MAAM,GAAG,GAAG,IAAI,GAAG,EAA8B,CAAC;IAClD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,CAAC;IAElC,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpD,yEAAyE;IACzE,6EAA6E;IAC7E,6DAA6D;IAC7D,MAAM,GAAG,GACP,8FAA8F;QAC9F,8BAA8B;QAC9B,wBAAwB;QACxB,4DAA4D;QAC5D,uBAAuB,YAAY,GAAG;QACtC,aAAa;QACb,+FAA+F;QAC/F,8BAA8B;QAC9B,wBAAwB;QACxB,wBAAwB,YAAY,GAAG;QACvC,yEAAyE;QACzE,2EAA2E;QAC3E,yEAAyE;QACzE,0EAA0E;QAC1E,2EAA2E;QAC3E,yEAAyE;QACzE,wEAAwE;QACxE,0BAA0B;QAC1B,mDAAmD,CAAC;IAEtD,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAc,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;IAEpE,4EAA4E;IAC5E,8EAA8E;IAC9E,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,GAAG,GAAG,GAAG,GAAG,CAAC,OAAO,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;QAC5C,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,SAAS;QAC5B,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEd,MAAM,KAAK,GAAoB;YAC7B,MAAM,EAAE,GAAG,CAAC,OAAO;YACnB,aAAa,EAAE,GAAG,CAAC,cAAc;YACjC,OAAO,EAAE,GAAG,CAAC,OAA8B;YAC3C,KAAK,EAAE,GAAG,CAAC,MAAM;YACjB,UAAU,EAAE,GAAG,CAAC,WAAW;YAC3B,MAAM,EAAE,GAAG,CAAC,MAAM,KAAK,CAAC;SACzB,CAAC;QAEF,MAAM,QAAQ,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACtC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE;YACnB,GAAG,EAAE,GAAG,CAAC,OAAO;YAChB,KAAK,EAAE,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;SACrE,CAAC,CAAC;IACL,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/query/traverse.d.ts

@@ -24,6 +24,43 @@
  * improvement (relaxation), and any hop whose combined factor reaches 1.0 is
  * rejected with an error naming the edge. Step 12 supplies the weights; this is
  * the layer that refuses to run with weights that cannot terminate.
+ *
+ * ## Confidence is not the traversal weight
+ *
+ * This module's default `weightFor` used to be `edge.confidence` and nothing
+ * else, which made two shipped modules contradict each other. `runtime-
+ * confirmation.ts` writes `confidence = 1.0` on every edge it promotes or mints
+ * at R4 — correctly, because rule 3 makes R4 unconditionally class A and a
+ * witnessed edge is not 99% believed. The old default then handed that same 1.0
+ * to the guard above as a *weight*, so the strongest edge in the graph was the
+ * one edge `impact` refused to walk. Any graph that had ever had a runtime
+ * observation applied threw.
+ *
+ * The two quantities were never the same thing, and `weights.ts` has said so
+ * all along: `validateScopingConfig` asserts
+ * `0 < edgeWeight x maxFanOutMultiplier x maxConfidence < 1` and notes in its
+ * own comment that *"maxConfidence is 1.0 by definition"*. Termination is the
+ * **edge weight's** job; confidence is evidence strength and is entitled to
+ * reach 1.0. The old default was the degenerate weight table with every edge
+ * type at 1.0 — precisely the configuration `validateScopingConfig` refuses to
+ * load. The in-process path was running a config the config loader would
+ * reject, while the worker path passed a real table and did not.
+ *
+ * So the default is now {@link defaultTraversalWeight}: the per-edge-type decay
+ * of `DEFAULT_EDGE_WEIGHTS` times the edge's confidence — the same product
+ * `weightFromTable` builds for the worker. Termination survives on three
+ * independent legs, none of which is a stored confidence value:
+ *
+ * 1. every weight in `DEFAULT_EDGE_WEIGHTS` is <= 0.95, and confidence is
+ *    capped at 1.0 by the IR, so the per-hop factor is <= 0.95 < 1 by
+ *    construction rather than by data;
+ * 2. `validateScopingConfig` refuses, at config load, any table that would
+ *    break leg 1;
+ * 3. the per-hop `RangeError` below is unchanged and still refuses any weight
+ *    outside (0, 1), which is what holds a caller-supplied `weightFor` to the
+ *    same rule.
+ *
+ * Ruled in `DEC-386`.
  */
 import type { EdgeType, IREdge, ResolutionLevel } from "@descryy/ir";
 import type { AdjacencyProvider } from "./provider.ts";
@@ -79,11 +116,32 @@ export interface TraversalOutcome {
  * here precisely because there is no score to improve on a second visit.
  */
 export declare function bfs(provider: AdjacencyProvider, seeds: readonly string[], options?: TraversalOptions): TraversalOutcome;
+/**
+ * The default per-hop decay: §12.4's `EdgeWeight` for the edge's *type*, times
+ * the edge's own confidence.
+ *
+ * Both terms are §12.4's, and neither one alone is the weight. Confidence
+ * carries how much the producer believes the edge; the type weight carries how
+ * far a change actually travels along that kind of edge — an `IMPORTS` hop at
+ * 0.4 is a weak signal even when it is certain, and a witnessed `CALLS` hop at
+ * 0.95 x 1.0 is strong precisely because it was witnessed.
+ *
+ * Exported so a caller can compose with it rather than reconstruct it, and so
+ * the in-process and worker paths are demonstrably the same function — see the
+ * parity test in `worker.test.ts`. It is the callback form of
+ * `weightFromTable({ weights: DEFAULT_EDGE_WEIGHTS, fallback: ... })`.
+ */
+export declare function defaultTraversalWeight(edge: {
+    readonly type: EdgeType;
+    readonly confidence: number;
+}): number;
 export interface WeightedOptions extends TraversalOptions {
     /**
      * The per-hop decay factor for an edge. Must be strictly less than 1.0 —
-     * see the note at the top of this file. Defaults to the edge's own confidence,
-     * which §12.4 makes one term of the real formula.
+     * see the note at the top of this file. Defaults to
+     * {@link defaultTraversalWeight}: the edge type's §12.4 weight times the
+     * edge's confidence. **Not confidence alone** — that conflated evidence
+     * strength with decay and made a witnessed R4 edge untraversable.
      */
     readonly weightFor?: (edge: IREdge) => number;
     /** Stop expanding below this score. The main reason traversal ends before the budget. */

package/dist/query/traverse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traverse.d.ts","sourceRoot":"","sources":["../../src/query/traverse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAIrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,IAAI,GAAG,MAAM,CAAC;AAE9C;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,QAAQ,EAA+B,CAAC;AAEnF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,qFAAqF;IACrF,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,sFAAsF;IACtF,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;CAC3C;AA2CD;;;;;GAKG;AACH,wBAAgB,GAAG,CACjB,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,GAAE,gBAAqB,GAC7B,gBAAgB,CAqClB;AAED,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IACvD;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9C,yFAAyF;IACzF,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,GAAE,eAAoB,GAC5B,gBAAgB,CAyDlB;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,gBAAqB,GAC7B,SAAS,MAAM,EAAE,CA8BnB"}
+{"version":3,"file":"traverse.d.ts","sourceRoot":"","sources":["../../src/query/traverse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAMrE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,IAAI,GAAG,MAAM,CAAC;AAE9C;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,QAAQ,EAA+B,CAAC;AAEnF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,qFAAqF;IACrF,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,CAAC;IACrC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,sFAAsF;IACtF,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;CAC3C;AA2CD;;;;;GAKG;AACH,wBAAgB,GAAG,CACjB,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,GAAE,gBAAqB,GAC7B,gBAAgB,CAqClB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE7G;AAED,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IACvD;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9C,yFAAyF;IACzF,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,GAAE,eAAoB,GAC5B,gBAAgB,CAyDlB;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,gBAAqB,GAC7B,SAAS,MAAM,EAAE,CA8BnB"}