@spexcode/spec-eval 0.6.7 → 0.7.0-next.0

package/dist/cli.js

@@ -203,7 +203,7 @@ async function scan(args = []) {
                     }
                     // an anchor is a claim a named unit exists — dead/ambiguous/unextractable is LOUD, and until it is
                     // repaired the probe issues no verdict, so the reading stays conservatively stale.
-                    for (const p of [...axis.problems, ...anchorProblems(root, axis.entries)]) {
+                    for (const p of [...axis.problems, ...(await anchorProblems(root, axis.entries))]) {
                         malformed++;
                         findings.push(`  • eval-schema: '${s.id}' scenario '${sc.name}' ${p} — fix ${y.evalPath}`);
                     }

package/dist/evaltab.d.ts

@@ -83,6 +83,7 @@ export type EvalContext = {
 export declare function evalContext(root: string, specs: Awaited<ReturnType<typeof loadSpecs>>, idx: DriftIndex, hidx: HistoryIndex, remarks?: Map<string, RemarkTrack>, ynodes?: EvalNode[]): Promise<EvalContext>;
 export declare function evalTimelines(ids: readonly string[], ctx?: EvalContext, opts?: {
     order?: boolean;
+    latestOnly?: boolean;
 }): Promise<EvalTimeline[]>;
 export declare function evalTimeline(id: string, ctx?: EvalContext): Promise<EvalTimeline>;
 export type BlobResult = {

package/dist/evaltab.js

@@ -50,9 +50,14 @@ export async function evalTimelines(ids, ctx, opts = {}) {
         const codeEntries = specs.find((s) => dirname(s.path) === relative(root, ynode.dir))?.codeEntries ?? [];
         const byName = new Map(ynode.scenarios.map((s) => [s.name, s]));
         const { readings, retractions, oks } = readSidecar(ynode.sidecarPath);
-        const rows = applyRetractions(readings, retractions).map((reading) => ({
+        const allRows = applyRetractions(readings, retractions).map((reading) => ({
             reading, axis: scenarioCodeAxis(byName.get(reading.scenario)?.code, codeEntries),
         }));
+        // The board only renders the latest state per scenario. Historical rows remain available to the
+        // session/eval detail paths, but sending them through freshness here multiplies immutable Git probes.
+        const rows = opts.latestOnly
+            ? [...allRows.reduce((latest, row) => latest.set(row.reading.scenario, row), new Map()).values()]
+            : allRows;
         return { id, ynode, codeEntries, rows, retractions, oks };
     });
     // an order-only read stops HERE, before a single probe: the rows above are already the whole answer.

package/dist/freshness.d.ts

@@ -30,7 +30,7 @@ export type AnchorDemand = {
     entries: readonly RelationEntry[];
 };
 export declare function anchorProbeFor(root: string, idx: DriftIndex): AnchorProbe;
-export declare function anchorProblems(root: string, entries: readonly RelationEntry[]): string[];
+export declare function anchorProblems(root: string, entries: readonly RelationEntry[]): Promise<string[]>;
 export type RemarkSignal = {
     resolved: boolean;
     resolvedAt?: string;

package/dist/freshness.js

@@ -497,7 +497,7 @@ const currentTreeUnitMemo = new Map();
 // caller retaining a verdict derived from these units names it by the same identity that decides the parse
 // ([[selector-anchor-scope]]). Returning the key rather than re-deriving it elsewhere is what keeps the two
 // from drifting apart.
-function currentTreeImage(root, x, path) {
+async function currentTreeImage(root, x, path) {
     const source = readFileSync(join(root, path), 'utf8');
     const key = `${x.memoKey(path)}\0${createHash('sha1').update(source).digest('hex')}`;
     const hit = currentTreeUnitMemo.get(key);
@@ -508,7 +508,7 @@ function currentTreeImage(root, x, path) {
     }
     let entry;
     try {
-        entry = { units: x.extract(source, path) };
+        entry = { units: await x.extract(source, path) };
     }
     catch (err) {
         entry = { failed: err?.message ?? String(err) };
@@ -520,15 +520,15 @@ function currentTreeImage(root, x, path) {
         throw new Error(entry.failed);
     return { key, units: entry.units };
 }
-function entryImage(root, regs, path, selector) {
+async function entryImage(root, regs, path, selector) {
     const x = extractorFor(regs, extOf(path));
     if (!x)
         return { problem: `\`code\` selector \`${path}#${selector}\` — no designated extractor for that language; drop the #anchor or add a language row` };
-    const ready = x.ready();
+    const ready = await x.ready();
     if (ready !== true)
         return { problem: `\`code\` anchors on ${path} are unverified: ${ready}` };
     try {
-        return currentTreeImage(root, x, path);
+        return await currentTreeImage(root, x, path);
     }
     catch (err) {
         return { problem: `\`code\` anchors on ${path} are unverified: ${err?.message ?? String(err)}` };
@@ -550,8 +550,8 @@ function selectorProblem(units, path, selectors) {
     }
     return null;
 }
-function entryUnverifiable(root, regs, entry) {
-    const image = entryImage(root, regs, entry.path, entry.selectors[0]);
+async function entryUnverifiable(root, regs, entry) {
+    const image = await entryImage(root, regs, entry.path, entry.selectors[0]);
     return 'problem' in image ? image.problem : selectorProblem(image.units, entry.path, entry.selectors);
 }
 // @@@ the verify sweep must reach the MACROTASK queue - resolving every reading's `code:` selectors against
@@ -603,10 +603,10 @@ export function anchorProbeFor(root, idx) {
             // one coherent read of each source per sweep: every entry on a path resolves against the same bytes,
             // and the read that names the verdict is the read the verdict was derived from.
             const images = new Map();
-            const imageOf = (path, selector) => {
+            const imageOf = async (path, selector) => {
                 let hit = images.get(path);
                 if (hit === undefined) {
-                    hit = entryImage(root, regs, path, selector);
+                    hit = await entryImage(root, regs, path, selector);
                     images.set(path, hit);
                 }
                 return hit;
@@ -630,7 +630,7 @@ export function anchorProbeFor(root, idx) {
                     const key = anchorKey(sinceSha, e.path, e.selectors);
                     if (verdicts.has(key) || queued.has(key))
                         continue;
-                    const image = imageOf(e.path, e.selectors[0]);
+                    const image = await imageOf(e.path, e.selectors[0]);
                     const name = 'problem' in image ? null : `${registry}\x1f${image.key}\x1f${key}`;
                     const remembered = scope && name !== null ? scope.anchorVerdicts.get(name) : undefined;
                     if (remembered !== undefined) {
@@ -666,13 +666,13 @@ export function anchorProbeFor(root, idx) {
 // the LOUD half: a selector is a claim that a named unit EXISTS, held to the same standard as a ghost path.
 // Dead, ambiguous, unparseable, or no designated extractor — each names itself and its repair, and until
 // repaired the probe issues no verdict, so the reading stays stale. Over-warn, never a silent pass.
-export function anchorProblems(root, entries) {
+export async function anchorProblems(root, entries) {
     const regs = extractors(root);
     const out = [];
     for (const e of entries) {
         if (!e.selectors.length)
             continue;
-        const problem = entryUnverifiable(root, regs, e);
+        const problem = await entryUnverifiable(root, regs, e);
         if (problem)
             out.push(problem);
     }

package/dist/host.d.ts

@@ -1,4 +1,5 @@
 import type { RemarkTrack } from './remarks.js';
+import type { ReviewDiffFile } from '@spexcode/spec-core';
 export type EvalHost = {
     loadConfig?: (root: string) => any;
     trackedSourceFiles?: (root: string, roots: string[], policy: any) => string[];
@@ -19,7 +20,7 @@ export type ReviewPayload = {
     label: string;
     ahead: number;
     dirtyNonRuntime: number;
-    diff: import('@spexcode/spec-core').ReviewDiffFile[];
+    diff: ReviewDiffFile[];
     gates: {
         conflictsWithMain: boolean;
         lint: {

package/dist/sessioneval.d.ts

@@ -218,7 +218,7 @@ export type SessionEvalRevision = {
 export type SessionEvalProjection = {
     epoch: string;
     generation: number;
-    phase: 'loading' | 'updating' | 'ready' | 'error';
+    phase: 'loading' | 'updating' | 'ready' | 'error' | 'dormant';
     revision?: string;
     value?: SessionEvalSummary;
     lastKnown?: {
@@ -279,6 +279,7 @@ export declare class SessionEvalProjectionCache {
     demand<T>(id: string, path: string, run: () => Promise<T>): Promise<T>;
     idle(): Promise<void>;
     accept(id: string, generation: number, revision: string, value: SessionEvalSummary): boolean;
+    private dormantEntry;
     private project;
     private matches;
     private publish;

package/dist/sessioneval.js

@@ -116,7 +116,7 @@ async function validateSelectorEntry(context, revision, entry, sourceView) {
     if (!x) {
         throw new SessionImpactUnavailableError(`session impact selector '${entry.path}#${entry.selectors[0]}' is unavailable: no designated extractor for '.${extOf(entry.path)}'`);
     }
-    const ready = x.ready();
+    const ready = await x.ready();
     if (ready !== true) {
         throw new SessionImpactUnavailableError(`session impact selectors on '${entry.path}' are unavailable: ${ready}`);
     }
@@ -132,7 +132,7 @@ async function validateSelectorEntry(context, revision, entry, sourceView) {
                 throw new SessionImpactUnavailableError(`session impact selector '${entry.path}#${entry.selectors[0]}' is dead at ${revision.slice(0, 8)}: the file does not exist`);
             }
             try {
-                return { extractor: x, units: x.extract(source, entry.path) };
+                return { extractor: x, units: await x.extract(source, entry.path) };
             }
             catch (error) {
                 throw new SessionImpactUnavailableError(`session impact selectors on '${entry.path}' are unextractable at ${revision.slice(0, 8)}: ${error?.message ?? String(error)}`);
@@ -1636,6 +1636,16 @@ export class SessionEvalProjectionCache {
         promise.finally(() => {
             if (this.demands.get(id) === promise)
                 this.demands.delete(id);
+            // The cancel above exists ONLY so the warmup does not duplicate the build this demand is about to run.
+            // Once the demand has settled that reason is spent — and a demand that REJECTED published nothing, so
+            // leaving the mark set kept `authorize` refusing this generation forever and the entry stuck at
+            // `loading`/`updating` with no build ever scheduled. A demand that published is already `ready` and
+            // needs no second build.
+            if (this.entries.get(id) !== entry || entry.demandCancelledGeneration !== entry.generation)
+                return;
+            entry.demandCancelledGeneration = null;
+            this.authorize(entry);
+            queueMicrotask(() => this.startScheduled());
         }).catch(() => { });
         return promise;
     }
@@ -1660,12 +1670,19 @@ export class SessionEvalProjectionCache {
             this.notify();
         return true;
     }
+    // Dormant offline history is demand-only BY POLICY: `authorize` refuses to schedule an offline entry, so
+    // nothing will move it until a demand builds it. `loading`/`updating` are arrival phases — a reader that
+    // renders them as progress waits forever. This names the difference at the one place that knows it.
+    dormantEntry(entry) {
+        return entry.liveness === 'offline' && entry.running == null && entry.scheduled == null
+            && entry.observerHolds.size === 0 && entry.phase !== 'ready' && entry.phase !== 'error';
+    }
     project(entry) {
         const stable = entry.current;
         return {
             epoch: this.epoch,
             generation: entry.generation,
-            phase: entry.phase,
+            phase: this.dormantEntry(entry) ? 'dormant' : entry.phase,
             ...(entry.phase === 'ready' && stable
                 ? { revision: stable.revision, value: stable.value }
                 : stable ? { lastKnown: stable } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/spec-eval",
-  "version": "0.6.7",
+  "version": "0.7.0-next.0",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -26,7 +26,7 @@
     "test": "tsx --import ../scripts/test-home.mjs --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/spec-core": "0.6.7"
+    "@spexcode/spec-core": "0.7.0-next.0"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",