@reticlehq/server 3.5.0 → 3.7.0

package/dist/memory/cloud/sync-screenshots.js

@@ -0,0 +1,105 @@
+/**
+ * The step screenshots of each run the platform has accepted, sent once each.
+ *
+ * A run goes up first, through the sync; its screenshots follow, one request per image, to
+ * `POST /v1/runs/:runId/screenshots` — only once the platform holds the run, because the endpoint
+ * answers 404 for a run it does not. What was sent is remembered by `seq:sha256`, like runs by hash,
+ * so a quiet cycle sends nothing.
+ *
+ * An OLDER platform has no such endpoint and answers 404 or 405. That run's screenshots stay on
+ * this machine and are not offered again: the alternative is one refused request per image on every
+ * cycle, forever. A newer platform picks up the next run's. Anything else that failed (the network,
+ * a 5xx) is simply retried next cycle.
+ */
+import { createHash } from 'node:crypto';
+import { RunScreenshotSchema, STEP_SCREENSHOT } from '@reticlehq/core';
+const SCREENSHOTS_PATH = (runId) => `/v1/runs/${encodeURIComponent(runId)}/screenshots`;
+const HTTP_CREATED = 201;
+const HTTP_OK = 200;
+/** An older platform: no route (404), or a route that takes no POST (405). */
+const NOT_THERE = new Set([404, 405]);
+/** Refused for good: too large (413), too many for one run (409). Retrying cannot change it. */
+const REFUSED_FOR_GOOD = new Set([409, 413]);
+/** The screenshots a run artifact lists, read defensively: a malformed entry is skipped. */
+function listed(payload) {
+    const raw = 'object' === typeof payload && null !== payload
+        ? payload['screenshots']
+        : undefined;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((entry) => {
+        const parsed = RunScreenshotSchema.safeParse(entry);
+        return parsed.success ? [parsed.data] : [];
+    });
+}
+const keyOf = (shot) => `${String(shot.seq)}:${shot.sha256}`;
+/** The upload body for one screenshot — the shape `ScreenshotUploadSchema` reads. */
+function bodyOf(shot, image) {
+    return {
+        seq: shot.seq,
+        file: shot.file,
+        ...(shot.step === undefined ? {} : { step: shot.step }),
+        tool: shot.tool,
+        ...(shot.checkId === undefined ? {} : { checkId: shot.checkId }),
+        source: shot.source,
+        width: shot.width,
+        height: shot.height,
+        sha256: shot.sha256,
+        jpeg: Buffer.from(image).toString('base64'),
+    };
+}
+/** Send what is owed. Never throws; the record is bounded by the runs still on disk. */
+export async function syncScreenshots(deps) {
+    const onDisk = new Set(deps.runs.map((run) => run.runId));
+    const sent = {};
+    for (const [runId, keys] of Object.entries(deps.state.sentScreenshots ?? {}))
+        if (onDisk.has(runId) && Array.isArray(keys))
+            sent[runId] = keys.filter((k) => 'string' === typeof k);
+    const heldLocal = new Set((deps.state.screenshotsHeldLocal ?? []).filter((id) => onDisk.has(id)));
+    const finish = (count, error) => ({
+        sent: count,
+        state: { sentScreenshots: sent, screenshotsHeldLocal: [...heldLocal] },
+        ...(error === undefined ? {} : { error }),
+    });
+    let count = 0;
+    try {
+        for (const run of deps.runs) {
+            if (heldLocal.has(run.runId) || !deps.accepted(run.runId))
+                continue;
+            const done = new Set(sent[run.runId] ?? []);
+            for (const shot of listed(run.payload)) {
+                if (done.has(keyOf(shot)))
+                    continue;
+                const image = deps.readImage(run.runId, shot.file);
+                // Gone (retention took it) or changed under its name: nothing true is left to send.
+                if (image === undefined || createHash('sha256').update(image).digest('hex') !== shot.sha256)
+                    continue;
+                const markDone = () => {
+                    done.add(keyOf(shot));
+                    sent[run.runId] = [...done];
+                };
+                if (image.byteLength > STEP_SCREENSHOT.MAX_BYTES) {
+                    markDone();
+                    continue;
+                }
+                const res = await deps.post(SCREENSHOTS_PATH(run.runId), JSON.stringify(bodyOf(shot, image)));
+                if (HTTP_CREATED === res.status || HTTP_OK === res.status) {
+                    markDone();
+                    count += 1;
+                }
+                else if (NOT_THERE.has(res.status)) {
+                    heldLocal.add(run.runId);
+                    return finish(count, `screenshots ${String(res.status)}: this platform does not take screenshots yet, so run ${run.runId}'s stay on this machine`);
+                }
+                else if (REFUSED_FOR_GOOD.has(res.status))
+                    markDone();
+                else
+                    return finish(count, `screenshots ${String(res.status)}: ${res.text.slice(0, 200)}`);
+            }
+        }
+    }
+    catch (error) {
+        return finish(count, error instanceof Error ? error.message : String(error));
+    }
+    return finish(count);
+}

package/dist/memory/cloud/unsynced-roots.d.ts

@@ -0,0 +1,47 @@
+export interface UnsyncedRoot {
+    root: string;
+    /** Runs on disk the platform has not accepted. */
+    runs: number;
+    /** Flows on disk nothing will send: see `unsentFlowCount`. */
+    flows: number;
+    /** Whether this folder holds a link. False is the case nothing will ever send. */
+    linked: boolean;
+    /**
+     * The project it belongs to: the linked one, else the id its `.reticle.json` names. A machine
+     * reports every folder to each workspace it is linked to; this is how a board keeps only its own.
+     */
+    projectId?: string;
+}
+/**
+ * Run files in `root` the platform never accepted. Ids only — a run file is named by its id — so
+ * this costs a directory listing, never a payload read. Never throws.
+ */
+export declare function unsentRunCount(root: string): number;
+/**
+ * Flows in `root` that will not reach the platform: all of them when nothing sends them (the root is
+ * not linked, has no key for its host, or has flow sync switched off), else the ones the platform
+ * refused. A flow waiting on a root that does send them is not counted: a save wakes the next cycle.
+ * Never throws.
+ */
+export declare function unsentFlowCount(root: string, sendsFlows: boolean): number;
+/**
+ * Every root here with runs or flows the platform does not have. Roots are deduped; order is kept.
+ * `sendsFlows` defaults to `isLinked`: a linked root sends its flows unless flow sync is off.
+ */
+export declare function unsyncedRoots(roots: readonly string[], isLinked: (root: string) => Promise<boolean>, sendsFlows?: (root: string) => Promise<boolean>): Promise<UnsyncedRoot[]>;
+/**
+ * The buckets under `~/.reticle/unmatched/` — evidence no project claimed, which nothing sends. After
+ * the first warning nothing named them again: not `status`, not `connect`, not the dashboard's
+ * unsent list. Never throws.
+ */
+export declare function unmatchedRoots(home: string): string[];
+/** The project a `.reticle` folder belongs to: where a person runs the command that sends it. */
+export declare function projectFolderOf(root: string): string;
+/** One line a person can act on: where the runs are, and the command that sends them. */
+export declare function describeUnsynced(entry: UnsyncedRoot, from: string): string;
+/**
+ * The unsent folders as a command's few lines: every unclaimed bucket in one (they all need the same
+ * thing, and `reticle connect` printed ninety near-identical lines of them before "Connected"), the
+ * rest one by one up to a handful, then a count and where the full list is.
+ */
+export declare function describeUnsyncedBriefly(entries: readonly UnsyncedRoot[], from: string): string[];

package/dist/memory/cloud/unsynced-roots.js

@@ -0,0 +1,166 @@
+/**
+ * `.reticle` folders whose runs never reached the platform, and why.
+ *
+ * The daemon skipped every root without a link and said nothing: one repo held 31 runs nobody sent
+ * while the log repeated `reticle_cloud_unlinked` about a different folder. Counted here, from run
+ * ids on disk against the ids the platform accepted, so `reticle sync`, `doctor`, the HUD and the
+ * platform report can each name the folder and the one command that fixes it.
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, dirname, join, relative, sep } from 'node:path';
+import { ReticleDir } from '@reticlehq/core';
+import { DRIVE_RECORD_SUFFIX, UNMATCHED_SUBDIR, isUnmatchedRoot, } from '../project/dir/reticle-dir.js';
+import { diskSource, readCloudState } from './sync-disk.js';
+/** The project's own config, beside its `.reticle` folder. */
+const PROJECT_CONFIG = '.reticle.json';
+/** `projectId` out of a JSON file, or undefined. Never throws. */
+function projectIdIn(path) {
+    try {
+        const id = JSON.parse(readFileSync(path, 'utf8'))?.['projectId'];
+        return 'string' === typeof id && 0 < id.length ? id : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The project a `.reticle` folder belongs to, as the platform keys it. */
+function projectOfRoot(root) {
+    return (projectIdIn(join(root, ReticleDir.CLOUD_LINK_FILE)) ??
+        projectIdIn(join(projectFolderOf(root), PROJECT_CONFIG)));
+}
+const RUN_SUFFIX = '.json';
+/** The folder the command is run from, named when it is the one the person is already in. */
+const HERE = 'this folder';
+/**
+ * Run files in `root` the platform never accepted. Ids only — a run file is named by its id — so
+ * this costs a directory listing, never a payload read. Never throws.
+ */
+export function unsentRunCount(root) {
+    try {
+        const dir = join(root, ReticleDir.RUNS_SUBDIR);
+        if (!existsSync(dir))
+            return 0;
+        const state = readCloudState(root);
+        const sent = new Set([...Object.keys(state.sentRunHashes ?? {}), ...(state.sentRunIds ?? [])]);
+        // Made before the folder was linked here: held for `--move-history`, so not waiting for a sync.
+        const linkedAt = state.linkedAt;
+        const heldBack = (file) => {
+            if (linkedAt === undefined)
+                return false;
+            try {
+                const at = JSON.parse(readFileSync(join(dir, file), 'utf8'))
+                    .createdAt;
+                return !('number' === typeof at && at >= linkedAt);
+            }
+            catch {
+                return false;
+            }
+        };
+        return readdirSync(dir)
+            .filter((file) => file.endsWith(RUN_SUFFIX) && !file.endsWith(DRIVE_RECORD_SUFFIX))
+            .filter((file) => !sent.has(file.slice(0, -RUN_SUFFIX.length)) && !heldBack(file)).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Flows in `root` that will not reach the platform: all of them when nothing sends them (the root is
+ * not linked, has no key for its host, or has flow sync switched off), else the ones the platform
+ * refused. A flow waiting on a root that does send them is not counted: a save wakes the next cycle.
+ * Never throws.
+ */
+export function unsentFlowCount(root, sendsFlows) {
+    try {
+        if (!sendsFlows)
+            return diskSource(root).flows().length;
+        return readCloudState(root).refusedSets?.flow?.count ?? 0;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Every root here with runs or flows the platform does not have. Roots are deduped; order is kept.
+ * `sendsFlows` defaults to `isLinked`: a linked root sends its flows unless flow sync is off.
+ */
+export async function unsyncedRoots(roots, isLinked, sendsFlows = isLinked) {
+    const out = [];
+    for (const root of new Set(roots)) {
+        const runs = unsentRunCount(root);
+        const linked = await isLinked(root).catch(() => false);
+        const flows = unsentFlowCount(root, linked && (await sendsFlows(root).catch(() => false)));
+        if (0 === runs && 0 === flows)
+            continue;
+        const projectId = projectOfRoot(root);
+        out.push({ root, runs, flows, linked, ...(projectId === undefined ? {} : { projectId }) });
+    }
+    return out;
+}
+/**
+ * The buckets under `~/.reticle/unmatched/` — evidence no project claimed, which nothing sends. After
+ * the first warning nothing named them again: not `status`, not `connect`, not the dashboard's
+ * unsent list. Never throws.
+ */
+export function unmatchedRoots(home) {
+    const dir = join(home, ReticleDir.ROOT, UNMATCHED_SUBDIR);
+    try {
+        return readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => join(dir, entry.name));
+    }
+    catch {
+        return [];
+    }
+}
+/** The project a `.reticle` folder belongs to: where a person runs the command that sends it. */
+export function projectFolderOf(root) {
+    return ReticleDir.ROOT === basename(root) ? dirname(root) : root;
+}
+/** One line a person can act on: where the runs are, and the command that sends them. */
+export function describeUnsynced(entry, from) {
+    // Forward slashes on every platform, as the platform report writes `~/...`: one spelling of a
+    // folder whether it is read in a Windows terminal, the HUD or the dashboard.
+    const folder = projectFolderOf(entry.root);
+    const where = 0 === relative(from, folder).length ? HERE : relative(from, folder).split(sep).join('/');
+    const what = [
+        ...(0 < entry.runs ? [`${String(entry.runs)} run(s)`] : []),
+        ...(0 < entry.flows ? [`${String(entry.flows)} flow(s)`] : []),
+    ].join(' and ');
+    if (isUnmatchedRoot(entry.root)) {
+        return (`${what} in ${entry.root.split(sep).join('/')} are not on your dashboard: no project claimed ` +
+            'them — the checkout that made them shares its project id with another, or has none. They stay ' +
+            'on this machine; serve the app from the checkout that owns the id, or give this one its own, so new work reaches it');
+    }
+    // `connect`, not `link`: it signs in first when it has to, so it is the one command that works.
+    if (!entry.linked)
+        return `${what} in ${where} are not on your dashboard: run \`reticle connect\` there`;
+    // A linked root counts flows only when flow sync is off or the platform refused them.
+    return 0 < entry.flows
+        ? `${what} in ${where} are not on your dashboard: \`reticle config --flows on\` there if flow ` +
+            'sync is off; `reticle sync` names any the platform refused'
+        : `${what} in ${where} are waiting to be sent: run \`reticle sync\` there`;
+}
+/** Folders named one by one before the rest are counted. */
+const FOLDERS_SHOWN = 5;
+/**
+ * The unsent folders as a command's few lines: every unclaimed bucket in one (they all need the same
+ * thing, and `reticle connect` printed ninety near-identical lines of them before "Connected"), the
+ * rest one by one up to a handful, then a count and where the full list is.
+ */
+export function describeUnsyncedBriefly(entries, from) {
+    const unclaimed = entries.filter((entry) => isUnmatchedRoot(entry.root));
+    const claimed = entries.filter((entry) => !isUnmatchedRoot(entry.root));
+    if (entries.length <= FOLDERS_SHOWN)
+        return entries.map((entry) => describeUnsynced(entry, from));
+    const runs = unclaimed.reduce((sum, entry) => sum + entry.runs, 0);
+    const lines = claimed.slice(0, FOLDERS_SHOWN).map((entry) => describeUnsynced(entry, from));
+    if (0 < unclaimed.length)
+        lines.unshift(`${String(runs)} run(s) in ${String(unclaimed.length)} folders under ~/${ReticleDir.ROOT}/${UNMATCHED_SUBDIR} ` +
+            'are not on your dashboard: no project claimed them, so they stay on this machine');
+    const more = claimed.length - FOLDERS_SHOWN;
+    if (0 < more || 0 < unclaimed.length)
+        lines.push(`${0 < more ? `${String(more)} more folder(s) hold work not on your dashboard. ` : ''}` +
+            '`reticle doctor` lists every one');
+    return lines;
+}

package/dist/memory/impact/account-watch.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Repaint the HUD when sign-in or a project link changes on disk.
+ *
+ * The impact snapshot already reads both files fresh, but it is only PUSHED when a tab attaches,
+ * a tool call lands, or the HUD's own Sign in completes. `reticle logout` and `reticle link` run in
+ * another process, so neither caused a push: a signed-out machine kept showing the old name, and a
+ * freshly linked project kept saying "Not linked", until somebody reloaded or drove something.
+ *
+ * ponytail: stat polling (`fs.watchFile`), not `fs.watch`. It works on a file that does not exist
+ * yet — the usual state of `cloud.json` before a link — and costs one stat per file per interval.
+ */
+import type { ImpactSnapshot } from '@reticlehq/core';
+/** How often each watched file is stat'ed. A second reads as live to somebody switching windows. */
+export declare const ACCOUNT_WATCH_INTERVAL_MS = 1000;
+/** How often `onTick` re-reads what has no file to watch; the platform config is polled as often. */
+export declare const HUD_REFRESH_MS = 30000;
+export interface AccountFilesWatch {
+    /** Start watching one file. Watching the same path twice is a no-op. */
+    watch(path: string): void;
+    close(): void;
+}
+export declare function watchAccountFiles(onChange: () => void, intervalMs?: number, 
+/** The rest of the platform's side of the HUD, which has no file to watch: run every 30s. */
+onTick?: () => void): AccountFilesWatch;
+/**
+ * Push a tab its impact snapshot, or, with `ifChanged`, only when it moved since this last pushed it.
+ *
+ * The daemon re-reads every tab on a timer so the platform's side of the HUD (sync status, runs on
+ * the dashboard, days left) reaches an idle tab without a tool call; resending an unchanged snapshot
+ * on every tick would repaint every HUD for nothing.
+ */
+export declare function pushIfMoved(tab: {
+    pushImpact(read: () => ImpactSnapshot | undefined, immediate: boolean): void;
+}, read: () => ImpactSnapshot | undefined, ifChanged: boolean): void;

package/dist/memory/impact/account-watch.js

@@ -0,0 +1,59 @@
+/**
+ * Repaint the HUD when sign-in or a project link changes on disk.
+ *
+ * The impact snapshot already reads both files fresh, but it is only PUSHED when a tab attaches,
+ * a tool call lands, or the HUD's own Sign in completes. `reticle logout` and `reticle link` run in
+ * another process, so neither caused a push: a signed-out machine kept showing the old name, and a
+ * freshly linked project kept saying "Not linked", until somebody reloaded or drove something.
+ *
+ * ponytail: stat polling (`fs.watchFile`), not `fs.watch`. It works on a file that does not exist
+ * yet — the usual state of `cloud.json` before a link — and costs one stat per file per interval.
+ */
+import { unwatchFile, watchFile } from 'node:fs';
+/** How often each watched file is stat'ed. A second reads as live to somebody switching windows. */
+export const ACCOUNT_WATCH_INTERVAL_MS = 1_000;
+/** How often `onTick` re-reads what has no file to watch; the platform config is polled as often. */
+export const HUD_REFRESH_MS = 30_000;
+export function watchAccountFiles(onChange, intervalMs = ACCOUNT_WATCH_INTERVAL_MS, 
+/** The rest of the platform's side of the HUD, which has no file to watch: run every 30s. */
+onTick) {
+    const watched = new Set();
+    const ticker = onTick === undefined ? undefined : setInterval(onTick, HUD_REFRESH_MS);
+    ticker?.unref();
+    const listener = () => {
+        onChange();
+    };
+    return {
+        watch(path) {
+            if (watched.has(path))
+                return;
+            watched.add(path);
+            // Not persistent: a watcher must never be the reason a daemon cannot exit.
+            watchFile(path, { persistent: false, interval: intervalMs }, listener);
+        },
+        close() {
+            if (ticker !== undefined)
+                clearInterval(ticker);
+            for (const path of watched)
+                unwatchFile(path, listener);
+            watched.clear();
+        },
+    };
+}
+/** What each tab was last sent by `pushIfMoved`, so an unchanged snapshot is not sent again. */
+const sent = new WeakMap();
+/**
+ * Push a tab its impact snapshot, or, with `ifChanged`, only when it moved since this last pushed it.
+ *
+ * The daemon re-reads every tab on a timer so the platform's side of the HUD (sync status, runs on
+ * the dashboard, days left) reaches an idle tab without a tool call; resending an unchanged snapshot
+ * on every tick would repaint every HUD for nothing.
+ */
+export function pushIfMoved(tab, read, ifChanged) {
+    const snapshot = read();
+    const json = JSON.stringify(snapshot);
+    if (ifChanged && sent.get(tab) === json)
+        return;
+    sent.set(tab, json);
+    tab.pushImpact(() => snapshot, true);
+}

package/dist/memory/impact/impact-recorder.d.ts

@@ -16,9 +16,17 @@ export declare function initImpact(opts: {
      * directory may not reach for it. The daemon owns both sides.
      */
     config?: ConfigSource;
+    /** Resolve credentials per project when one daemon serves multiple linked apps. */
+    configForRoot?: (root: string) => ConfigSource;
+    /** Reticle Coverage for a project root, supplied by the daemon (the ledger is a feature's). */
+    coverageForRoot?: (root: string) => () => Record<string, number> | undefined;
     reticleRoot: string | undefined;
     projectName?: string;
     now?: () => number;
+    /** Where the machine-wide `~/.reticle` lives. Tests pass a temp dir so they never write the real one. */
+    globalRoot?: string;
+    /** This build's version, for HUD notices that need a newer SDK. */
+    sdkVersion?: string;
 }): ImpactStore | undefined;
 /** The live store for a root (default when omitted), if one has been initialised. */
 export declare function impactStore(root?: string): ImpactStore | undefined;

package/dist/memory/impact/impact-recorder.js

@@ -31,7 +31,13 @@ function storeFor(root) {
         return undefined;
     let found = stores.get(key);
     if (found === undefined) {
-        found = new ImpactStore({ ...storeOpts, reticleRoot: key });
+        const { configForRoot, coverageForRoot, ...opts } = storeOpts;
+        found = new ImpactStore({
+            ...opts,
+            ...(configForRoot === undefined ? {} : { config: configForRoot(key) }),
+            ...(coverageForRoot === undefined ? {} : { coverage: coverageForRoot(key) }),
+            reticleRoot: key,
+        });
         stores.set(key, found);
     }
     return found;
@@ -50,11 +56,15 @@ export function initImpact(opts) {
         return storeFor(undefined);
     if (defaultRoot === undefined) {
         defaultRoot = opts.reticleRoot;
-        const { projectName, now, config } = opts;
+        const { projectName, now, config, configForRoot, coverageForRoot, globalRoot, sdkVersion } = opts;
         storeOpts = {
             ...(projectName === undefined ? {} : { projectName }),
             ...(now === undefined ? {} : { now }),
+            ...(globalRoot === undefined ? {} : { globalRoot }),
+            ...(sdkVersion === undefined ? {} : { sdkVersion }),
             ...(config === undefined ? {} : { config }),
+            ...(configForRoot === undefined ? {} : { configForRoot }),
+            ...(coverageForRoot === undefined ? {} : { coverageForRoot }),
         };
     }
     return storeFor(opts.reticleRoot);

package/dist/memory/impact/impact-store.d.ts

@@ -1,5 +1,5 @@
-import { type OfferSource } from '../cloud/harness-offer.js';
-import type { ConfigSource } from '../cloud/harness-config.js';
+import { type ConfigSource } from '../cloud/harness-config.js';
+import { type NoticesSource } from '../cloud/hud-notices-source.js';
 import { type ImpactCounts, type ImpactDefect, type AccountState, type ImpactScope, type ImpactSnapshot } from '@reticlehq/core';
 /** Read a scope, tolerating absence and corruption: a broken file starts over rather than throwing. */
 export declare function readScope(path: string, now: number): ImpactScope;
@@ -23,6 +23,15 @@ export interface ImpactFoldMeta {
 }
 /** Fold one delta into a scope: totals, today's bucket, records and streak. Pure. */
 export declare function applyDelta(scope: ImpactScope, delta: Partial<ImpactCounts>, now: number, meta?: ImpactFoldMeta): ImpactScope;
+/**
+ * All time, never smaller than the project being looked at.
+ *
+ * The two scopes live in different files: the project's in its `.reticle`, the machine's in the
+ * home directory. A project whose history began before this machine's ledger (an upgrade, a new
+ * laptop, a moved checkout) showed more under "This project" than under "All time", which no reader
+ * can believe. The machine has done at least what any one of its projects has.
+ */
+export declare function atLeastProject(global: ImpactScope, project: ImpactScope): ImpactScope;
 /**
  * The live impact record for one project.
  *
@@ -39,9 +48,13 @@ export declare class ImpactStore {
         globalRoot?: string;
         /** Reads whether this machine is signed in. Injected so the store stays testable and pure-ish. */
         account?: () => AccountState;
-        /** Where the workspace stands with the free harness offer. Injected so no test touches a network. */
-        offer?: OfferSource;
         config?: ConfigSource;
+        /** The HUD rail's notices. Defaults to the daemon's cached copy of the published file. */
+        notices?: NoticesSource;
+        /** This build's version, for notices that need a newer SDK. Passed in: the store reads no package. */
+        sdkVersion?: string;
+        /** Reticle Coverage per level, as percentages. Injected: the ledger lives in `features/exhaust`. */
+        coverage?: () => Record<string, number> | undefined;
     });
     /** Notified after every fold, so the HUD can be pushed a fresh snapshot. */
     onChange(fn: () => void): void;