@fnndsc/salsa 3.21.2 → 4.0.1

package/dist/vfs/providers/proc.d.ts

@@ -6,10 +6,15 @@
  * immutable and whose freshness is visit-driven.
  *
  * Freshness model (every visit is a cheap delta, never a re-crawl):
- * - ls /proc/jobs        → roster delta (feeds newer than the highest known
- *                          id), and a full index walk once the roster is older
- *                          than {@link ROSTER_FULL_WALK_MS} — so a feed shared
- *                          later still appears within that window;
+ * - ls /proc/jobs        → roster delta: each collection's newest page, read
+ *                          unfiltered, brings in the feeds newer than the
+ *                          highest known id, and its total is compared with
+ *                          the last walk's — a total that moved (a share, an
+ *                          unshare, a deletion) promotes the visit to the
+ *                          full index walk, which also runs once the roster
+ *                          is older than {@link ROSTER_FULL_WALK_MS};
+ * - a feed the roster lacks, asked for by name or id, is asked of CUBE live
+ *                          and adopted ({@link procFeed_probe});
  * - ls /proc/jobs/N      → first visit loads the topology once; every later
  *                          visit runs {@link feedVisit_sync}: one feed-row
  *                          fetch (job counters), then, only when something
@@ -22,6 +27,7 @@
  *
  * @module
  */
+import { type VfsOutcome } from '@fnndsc/fond';
 import { type ProcRosterSyncKind, ProcCache, ProcFeed, Result } from '@fnndsc/cumin';
 import { VFSProvider, VFSItem, CpOptions } from '../provider.js';
 /** Pages of one feed's topology walk fetched at once (PACS plural's precedent: four). */
@@ -32,6 +38,13 @@ export declare const FEED_RECHECK_MS: number;
 export declare const ROSTER_FULL_WALK_MS: number;
 /** Visits to one feed closer together than this share the first visit's result. */
 export declare const FEED_VISIT_COALESCE_MS: number;
+/**
+ * Rows of a collection's newest page a roster delta reads. CUBE orders feeds
+ * newest first, so the page holds every feed newer than the roster unless
+ * more than this many arrived between two visits; it is small because the
+ * surfaces re-ask the roster on a timer.
+ */
+export declare const ROSTER_DELTA_PAGE: number;
 /** Lifecycle states for the session's global topology sweep. */
 export type ProcTopologyState = 'idle' | 'running' | 'complete' | 'failed';
 /**
@@ -103,6 +116,8 @@ export declare class ProcVfsProvider implements VFSProvider {
         sort?: 'name' | 'size' | 'date' | 'owner';
         reverse?: boolean;
     }): Promise<Result<VFSItem[]>>;
+    /** @inheritdoc */
+    readBinary(pathStr: string): Promise<VfsOutcome<Buffer>>;
     /**
      * Raw bytes exist only under the `data` link (an image in a job's output
      * space); everything else in `/proc` is synthesized text, served as its
@@ -112,16 +127,22 @@ export declare class ProcVfsProvider implements VFSProvider {
      * @param pathStr - Absolute `/proc/...` path.
      * @returns The file's bytes.
      */
-    readBinary(pathStr: string): Promise<Result<Buffer>>;
-    read(pathStr: string): Promise<Result<string>>;
-    rm(pathStr: string, _options?: {
+    private bytes_read;
+    /** @inheritdoc */
+    read(pathStr: string): Promise<VfsOutcome<string>>;
+    private text_read;
+    feedJobs_cancel(pathStr: string, _options?: {
         recursive?: boolean;
         force?: boolean;
     }): Promise<boolean>;
-    cp(_src: string, _dst: string, _options?: CpOptions): Promise<boolean>;
+    /** @inheritdoc */
+    cp(_src: string, _dst: string, _options?: CpOptions): Promise<VfsOutcome>;
+    private copy_run;
     mv(_src: string, _dst: string): Promise<boolean>;
     touch(_pathStr: string): Promise<boolean>;
     upload(_localPath: string, _remotePath: string): Promise<boolean>;
+    /** @inheritdoc */
+    write(pathStr: string, content: string): Promise<VfsOutcome>;
     /**
      * Writes a projected file. One file under /proc takes writes: a feed's
      * note (`/proc/jobs/feed_N/note`), whose content is replaced whole; its
@@ -131,7 +152,7 @@ export declare class ProcVfsProvider implements VFSProvider {
      * @param content - The new content, whole.
      * @returns True when it was written.
      */
-    write(pathStr: string, content: string): Promise<boolean>;
+    private file_write;
 }
 /**
  * Ensures instance topology is loaded for a feed without clearing existing data.
@@ -157,6 +178,20 @@ export declare function procFeed_ensureLoaded(feedID: number): Promise<void>;
  * @param feedID - Feed whose metadata to ensure.
  */
 export declare function feedMeta_ensure(feedID: number): Promise<void>;
+/**
+ * Asks CUBE for one feed, live, and adopts it into the roster: the way a
+ * feed shared to this identity, or made public, since the roster was
+ * walked is seen when it is asked for by name or id. A feed the roster
+ * already holds has its row refreshed. The yardsticks move with an
+ * adoption, so the next delta does not walk again for what this ask found.
+ *
+ * @param feedID - The feed to ask for.
+ * @returns The feed as the roster now holds it, or null when CUBE lists it
+ *   in neither collection for this identity — not shared, or shared to a
+ *   group the identity is not in.
+ * @throws {Error} When not connected.
+ */
+export declare function procFeed_probe(feedID: number): Promise<ProcFeed | null>;
 export declare function feedStatus_refresh(feedID: number): Promise<void>;
 /**
  * Whether every cached instance of a feed carries a terminal status. A fully
@@ -250,6 +285,46 @@ export declare function procTopologyCatchup_status(): {
  * @returns Resolves when no walk is queued or running.
  */
 export declare function procTopologyCatchup_await(): Promise<void>;
+/**
+ * One place a jump can land: a feed, or a node within one.
+ *
+ * @property kind - A feed, or a node (plugin instance).
+ * @property feedId - The feed, or the node's feed.
+ * @property nodeId - The node, for a node.
+ * @property name - The `/proc` name: `feed_4389`, or `pl-dicom_repack_639204`.
+ * @property title - The feed's title.
+ */
+export interface ProcLocation {
+    kind: 'feed' | 'node';
+    feedId: number;
+    nodeId?: number;
+    name: string;
+    title: string;
+}
+/**
+ * What a jump target names: a feed only (`feed_4389`), a node only
+ * (`pl-dicom_repack_639204`, or `_639204`), or a bare number that may be
+ * either. Null for anything else.
+ *
+ * @param target - What the operator typed.
+ * @returns The id and which kinds it may name, or null.
+ */
+export declare function procTarget_parse(target: string): {
+    id: number;
+    feed: boolean;
+    node: boolean;
+} | null;
+/**
+ * Finds where a jump target lands, asking CUBE live for what the roster
+ * and the index lack: a feed shared since the roster was walked, or a node
+ * in one. A node's feed is adopted into the roster on the way, so the
+ * place the answer names can be entered at once. A bare number that is
+ * both a feed and a node answers both; the caller asks which.
+ *
+ * @param target - A feed id, a node id, or a `feed_N` / `<plugin>_N` name.
+ * @returns Every place it names that this identity can see; empty for none.
+ */
+export declare function procTarget_locate(target: string): Promise<ProcLocation[]>;
 /**
  * Forgets all visit bookkeeping (tests, and a cache cleared underneath us).
  */

package/dist/vfs/providers/proc.js

@@ -7,10 +7,15 @@
  * immutable and whose freshness is visit-driven.
  *
  * Freshness model (every visit is a cheap delta, never a re-crawl):
- * - ls /proc/jobs        → roster delta (feeds newer than the highest known
- *                          id), and a full index walk once the roster is older
- *                          than {@link ROSTER_FULL_WALK_MS} — so a feed shared
- *                          later still appears within that window;
+ * - ls /proc/jobs        → roster delta: each collection's newest page, read
+ *                          unfiltered, brings in the feeds newer than the
+ *                          highest known id, and its total is compared with
+ *                          the last walk's — a total that moved (a share, an
+ *                          unshare, a deletion) promotes the visit to the
+ *                          full index walk, which also runs once the roster
+ *                          is older than {@link ROSTER_FULL_WALK_MS};
+ * - a feed the roster lacks, asked for by name or id, is asked of CUBE live
+ *                          and adopted ({@link procFeed_probe});
  * - ls /proc/jobs/N      → first visit loads the topology once; every later
  *                          visit runs {@link feedVisit_sync}: one feed-row
  *                          fetch (job counters), then, only when something
@@ -24,7 +29,7 @@
  * @module
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProcVfsProvider = exports.FEED_VISIT_COALESCE_MS = exports.ROSTER_FULL_WALK_MS = exports.FEED_RECHECK_MS = exports.FEED_WALK_IN_FLIGHT = void 0;
+exports.ProcVfsProvider = exports.ROSTER_DELTA_PAGE = exports.FEED_VISIT_COALESCE_MS = exports.ROSTER_FULL_WALK_MS = exports.FEED_RECHECK_MS = exports.FEED_WALK_IN_FLIGHT = void 0;
 exports.feedInstances_ensureStarted = feedInstances_ensureStarted;
 exports.procFeed_refreshStart = procFeed_refreshStart;
 exports.feedInstances_ensureLoaded = feedInstances_ensureLoaded;
@@ -32,6 +37,7 @@ exports.feedStatus_derive = feedStatus_derive;
 exports.procPath_parse = procPath_parse;
 exports.procFeed_ensureLoaded = procFeed_ensureLoaded;
 exports.feedMeta_ensure = feedMeta_ensure;
+exports.procFeed_probe = procFeed_probe;
 exports.feedStatus_refresh = feedStatus_refresh;
 exports.feedCached_isSettled = feedCached_isSettled;
 exports.feedVisit_sync = feedVisit_sync;
@@ -41,6 +47,8 @@ exports.procRoster_bootSync = procRoster_bootSync;
 exports.procTopologyCatchup_enqueue = procTopologyCatchup_enqueue;
 exports.procTopologyCatchup_status = procTopologyCatchup_status;
 exports.procTopologyCatchup_await = procTopologyCatchup_await;
+exports.procTarget_parse = procTarget_parse;
+exports.procTarget_locate = procTarget_locate;
 exports.procVisitState_reset = procVisitState_reset;
 exports.procDataFacts_start = procDataFacts_start;
 exports.procTopology_warmup = procTopology_warmup;
@@ -49,6 +57,7 @@ exports.procTopology_retry = procTopology_retry;
 exports.procTopology_status = procTopology_status;
 exports.procTopology_await = procTopology_await;
 exports.procCache_refresh = procCache_refresh;
+const fond_1 = require("@fnndsc/fond");
 const cumin_1 = require("@fnndsc/cumin");
 const index_js_1 = require("../../jobs/index.js");
 const feedJoins_js_1 = require("../../dag/feedJoins.js");
@@ -68,10 +77,18 @@ exports.FEED_RECHECK_MS = 10 * 60 * 1000;
 exports.ROSTER_FULL_WALK_MS = 10 * 60 * 1000;
 /** Visits to one feed closer together than this share the first visit's result. */
 exports.FEED_VISIT_COALESCE_MS = 1000;
+/**
+ * Rows of a collection's newest page a roster delta reads. CUBE orders feeds
+ * newest first, so the page holds every feed newer than the roster unless
+ * more than this many arrived between two visits; it is small because the
+ * surfaces re-ask the roster on a timer.
+ */
+exports.ROSTER_DELTA_PAGE = 20;
 const feedVisits = new Map();
 const feedVisitInflight = new Map();
 let rosterWalkedAt = 0;
 let rosterSyncInflight = null;
+let rosterTotals = { owned: null, public: null };
 let procTopologyPromise = null;
 let procTopologyFailure;
 let procTopologyResumeState = null;
@@ -92,14 +109,23 @@ function procFeed_create(feed) {
         createdJobs: Number(feed.created_jobs ?? 0),
     };
 }
-/** Indexes one complete paginated CUBE feed collection into the shared cache. */
+/**
+ * Indexes one complete paginated CUBE feed collection into the shared cache.
+ *
+ * @param page_fetch - Fetches one page of the collection.
+ * @param indexed - The feeds indexed so far, keyed by id; this walk adds to it.
+ * @returns The collection's total as the walk latched it, or null when no page carried one.
+ */
 async function procFeeds_index(page_fetch, indexed) {
+    let total = null;
     for await (const step of (0, cumin_1.listPages_walk)((offset, limit) => page_fetch({ limit, offset }), { pageSize: PAGE })) {
+        total = step.total ?? total;
         for (const feed of step.items) {
             const procFeed = procFeed_create(feed);
             indexed.set(procFeed.id, procFeed);
         }
     }
+    return total;
 }
 // ── Cache build ────────────────────────────────────────────────────────────
 /**
@@ -114,11 +140,11 @@ async function procCache_build() {
         throw new Error('not connected');
     }
     const indexed = new Map();
-    await procFeeds_index((params) => (0, cumin_1.feedsPage_get)(client, params), indexed);
+    const ownedTotal = await procFeeds_index((params) => (0, cumin_1.feedsPage_get)(client, params), indexed);
     // Older CUBEs lack a public-feeds endpoint: the contract answers null
     // without a wire call, and an empty first page ends the index loop.
     const publicBefore = indexed.size;
-    await procFeeds_index(async (params) => (await (0, cumin_1.publicFeedsPage_get)(client, params)) ?? { data: [], totalCount: 0 }, indexed);
+    let publicTotal = await procFeeds_index(async (params) => (await (0, cumin_1.publicFeedsPage_get)(client, params)) ?? { data: [], totalCount: 0 }, indexed);
     // An empty public walk while the cache already holds public feeds is a
     // failed SOURCE, not an authoritative absence: reconciling against it
     // would amputate every public feed from the roster (and the checkpoint
@@ -129,8 +155,11 @@ async function procCache_build() {
             cumin_1.errorStack.stack_push('warning', `proc roster: public-feeds source returned nothing while ${knownPublic.length} public feeds are known; keeping them`);
             for (const feed of knownPublic)
                 indexed.set(feed.id, feed);
+            // No yardstick from a failed source: the next delta takes what it reads.
+            publicTotal = null;
         }
     }
+    rosterTotals = { owned: ownedTotal, public: publicTotal };
     const knownBefore = new Set(cache.feedIDs_get());
     const reconciliationTargets = cache.feeds_reconcile(Array.from(indexed.values()));
     for (const feedID of reconciliationTargets)
@@ -294,11 +323,9 @@ async function procFeed_evict(feedID) {
     const client = await cumin_1.chrisConnection.client_get();
     if (!client)
         return;
-    const own = await (0, cumin_1.feedsPage_get)(client, { id: feedID, limit: 1, offset: 0 });
-    const row = own.data[0]
-        ?? ((await (0, cumin_1.publicFeedsPage_get)(client, { id: feedID, limit: 1, offset: 0 })) ?? { data: [], totalCount: 0 }).data[0];
+    const row = await feedRow_fetch(client, feedID);
     if (row)
-        cache.feed_add(procFeed_create(row));
+        cache.feed_add(procFeed_create(row.feed));
 }
 /**
  * The operator's `proc refresh <feed>`: evicts the feed and STARTS its
@@ -544,6 +571,11 @@ class ProcVfsProvider {
         }
         // /proc/jobs/feed_N — list root instances + feed virtual files
         if (feedID !== null && instanceID === null) {
+            // A feed the roster lacks is asked of CUBE first: shared to this
+            // identity, or made public, since the walk, it is adopted here and
+            // listed as any other; a feed CUBE does not list is an empty listing.
+            if (cache.feed_get(feedID) === undefined && (await procFeedAbsent_probe(feedID)) === null)
+                return (0, cumin_1.Ok)([]);
             const wasLoaded = cache.topologyLoaded_has(feedID);
             await feedInstances_ensureLoaded(feedID);
             const feed = cache.feed_get(feedID);
@@ -614,6 +646,10 @@ class ProcVfsProvider {
         }
         return (0, cumin_1.Ok)([]);
     }
+    /** @inheritdoc */
+    async readBinary(pathStr) {
+        return (0, fond_1.vfsOutcome_ofResult)(await this.bytes_read(pathStr), 'ENOENT');
+    }
     /**
      * Raw bytes exist only under the `data` link (an image in a job's output
      * space); everything else in `/proc` is synthesized text, served as its
@@ -623,7 +659,7 @@ class ProcVfsProvider {
      * @param pathStr - Absolute `/proc/...` path.
      * @returns The file's bytes.
      */
-    async readBinary(pathStr) {
+    async bytes_read(pathStr) {
         await cache_ensure();
         const clean = pathStr.replace(/\/$/, '');
         const { instanceID, virtualFile, dataRemainder } = procPath_parse(clean);
@@ -641,7 +677,11 @@ class ProcVfsProvider {
         const text = await this.read(pathStr);
         return text.ok ? (0, cumin_1.Ok)(Buffer.from(text.value, 'utf8')) : text;
     }
+    /** @inheritdoc */
     async read(pathStr) {
+        return (0, fond_1.vfsOutcome_ofResult)(await this.text_read(pathStr), 'ENOENT');
+    }
+    async text_read(pathStr) {
         await cache_ensure();
         const cache = (0, cumin_1.procCache_get)();
         const clean = pathStr.replace(/\/$/, '');
@@ -667,7 +707,7 @@ class ProcVfsProvider {
                 const note = await (0, cumin_1.feedNote_get)(feedID);
                 return note.ok ? (0, cumin_1.Ok)(note.value.content) : (0, cumin_1.Err)();
             }
-            return (0, cumin_1.Ok)('');
+            return (0, cumin_1.Err)();
         }
         // Instance-level virtual files — all live or cached-on-first-read
         if (instanceID !== null && virtualFile !== null) {
@@ -709,9 +749,11 @@ class ProcVfsProvider {
                 return (0, cumin_1.Ok)(logResult.ok ? logResult.value : '(log unavailable)');
             }
         }
-        return (0, cumin_1.Ok)('');
+        // Anything else is no file /proc reads: a folder (the dispatcher then
+        // says it is a directory) or nothing there.
+        return (0, cumin_1.Err)();
     }
-    async rm(pathStr, _options) {
+    async feedJobs_cancel(pathStr, _options) {
         await cache_ensure();
         const cache = (0, cumin_1.procCache_get)();
         const clean = pathStr.replace(/\/$/, '');
@@ -754,10 +796,18 @@ class ProcVfsProvider {
         }
         return false;
     }
-    async cp(_src, _dst, _options) { return false; }
+    /** @inheritdoc */
+    async cp(_src, _dst, _options) {
+        return (0, fond_1.vfsOutcome_ofBoolean)(await this.copy_run(_src, _dst, _options), 'EROFS');
+    }
+    async copy_run(_src, _dst, _options) { return false; }
     async mv(_src, _dst) { return false; }
     async touch(_pathStr) { return false; }
     async upload(_localPath, _remotePath) { return false; }
+    /** @inheritdoc */
+    async write(pathStr, content) {
+        return (0, fond_1.vfsOutcome_ofBoolean)(await this.file_write(pathStr, content), 'EROFS');
+    }
     /**
      * Writes a projected file. One file under /proc takes writes: a feed's
      * note (`/proc/jobs/feed_N/note`), whose content is replaced whole; its
@@ -767,7 +817,7 @@ class ProcVfsProvider {
      * @param content - The new content, whole.
      * @returns True when it was written.
      */
-    async write(pathStr, content) {
+    async file_write(pathStr, content) {
         const { feedID, instanceID, virtualFile } = procPath_parse(pathStr.replace(/\/$/, ''));
         if (feedID !== null && instanceID === null && virtualFile === 'note') {
             const done = await (0, cumin_1.feedNote_update)(feedID, { content });
@@ -829,14 +879,81 @@ async function feedMeta_ensure(feedID) {
     const existing = cache.feed_get(feedID);
     if (existing && existing.creationDate !== '')
         return;
+    await procFeed_probe(feedID);
+}
+/**
+ * Reads one feed's row, from the owned-and-shared collection first and the
+ * public one after.
+ *
+ * @param client - Connected chrisapi client.
+ * @param feedID - The feed to read.
+ * @returns The row and its collection, or null when neither lists the feed for this identity.
+ */
+async function feedRow_fetch(client, feedID) {
+    const own = await (0, cumin_1.feedsPage_get)(client, { id: feedID, limit: 1, offset: 0 });
+    const ownRow = own.data[0];
+    if (ownRow)
+        return { feed: ownRow, collection: 'owned' };
+    const pub = (await (0, cumin_1.publicFeedsPage_get)(client, { id: feedID, limit: 1, offset: 0 })) ?? { data: [], totalCount: 0 };
+    const pubRow = pub.data[0];
+    return pubRow ? { feed: pubRow, collection: 'public' } : null;
+}
+/**
+ * Asks CUBE for one feed, live, and adopts it into the roster: the way a
+ * feed shared to this identity, or made public, since the roster was
+ * walked is seen when it is asked for by name or id. A feed the roster
+ * already holds has its row refreshed. The yardsticks move with an
+ * adoption, so the next delta does not walk again for what this ask found.
+ *
+ * @param feedID - The feed to ask for.
+ * @returns The feed as the roster now holds it, or null when CUBE lists it
+ *   in neither collection for this identity — not shared, or shared to a
+ *   group the identity is not in.
+ * @throws {Error} When not connected.
+ */
+async function procFeed_probe(feedID) {
+    const cache = (0, cumin_1.procCache_get)();
     const client = await cumin_1.chrisConnection.client_get();
     if (!client)
         throw new Error('not connected');
-    const page = await (0, cumin_1.feedsPage_get)(client, { id: feedID, limit: 1, offset: 0 });
-    const f = page.data[0];
-    if (!f)
-        return;
-    cache.feed_add(procFeed_create(f));
+    const row = await feedRow_fetch(client, feedID);
+    if (row === null)
+        return null;
+    const feed = procFeed_create(row.feed);
+    const known = cache.feed_get(feedID) !== undefined;
+    cache.feed_add(feed);
+    if (!known) {
+        rosterTotal_bump(row.collection);
+        // A public feed is in the public collection whichever one listed it first.
+        if (feed.public && row.collection === 'owned')
+            rosterTotal_bump('public');
+        cache.arrivals_note([feedID]);
+        procTopologyCatchup_enqueue([feedID]);
+    }
+    return feed;
+}
+/**
+ * Asks CUBE for a feed the roster lacks, on a visit to its path, and says
+ * on the error stack when the ask itself failed; an absent feed is a null.
+ *
+ * @param feedID - The feed to ask for.
+ * @returns The adopted feed, or null.
+ */
+async function procFeedAbsent_probe(feedID) {
+    try {
+        return await procFeed_probe(feedID);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        cumin_1.errorStack.stack_push('warning', `proc: asking CUBE for feed_${feedID} failed (${msg})`);
+        return null;
+    }
+}
+/** Moves one collection's yardstick by one adopted feed; an unknown yardstick stays unknown. */
+function rosterTotal_bump(collection) {
+    const total = rosterTotals[collection];
+    if (total !== null)
+        rosterTotals[collection] = total + 1;
 }
 async function feedStatus_refresh(feedID) {
     const cache = (0, cumin_1.procCache_get)();
@@ -1046,19 +1163,72 @@ async function procRoster_run(force) {
     return procRosterDelta_run(cache, client);
 }
 /**
- * Walks the feeds newer than the highest known id, in both collections,
- * and adds them to the roster.
+ * One collection's newest page, read unfiltered. CUBE orders feeds newest
+ * first, so the page carries every feed newer than the roster's highest id
+ * unless more than a page arrived, and its total is the collection's whole
+ * count — the yardstick a share, an unshare or a deletion moves.
+ *
+ * @param page_fetch - Fetches one page of the collection.
+ * @param maxKnown - The roster's highest feed id (0 for an empty roster).
+ * @returns The newer feeds, the total, and whether the page overflowed.
+ */
+async function rosterCollection_peek(page_fetch, maxKnown) {
+    const page = await page_fetch({ limit: exports.ROSTER_DELTA_PAGE, offset: 0 });
+    const rows = page.data.map(procFeed_create);
+    const newer = rows.filter((feed) => feed.id > maxKnown);
+    const overflow = rows.length > 0 && newer.length === rows.length
+        && page.totalCount !== null && page.totalCount > rows.length;
+    return { newer, total: page.totalCount, overflow };
+}
+/**
+ * Whether a collection's total moved by more than its newer rows account
+ * for: a feed arrived or left under the newest page, which only the full
+ * walk can place. An overflowed page, or a collection without a yardstick,
+ * cannot say.
+ *
+ * @param collection - The collection peeked.
+ * @param peek - What its newest page read.
+ * @returns True when the total moved.
+ */
+function rosterTotal_moved(collection, peek) {
+    const expected = rosterTotals[collection];
+    if (expected === null || peek.total === null || peek.overflow)
+        return false;
+    return peek.total !== expected + peek.newer.length;
+}
+/**
+ * Brings the roster up to date without walking the whole index: each
+ * collection's newest page is read, its feeds newer than the roster are
+ * adopted, and its total is held against the last walk's. A total that
+ * moved otherwise — a feed shared to this identity, one unshared, one
+ * deleted — promotes the visit to the full walk, which places it. A page
+ * that overflowed is followed by the walk of everything newer than the
+ * roster, by id.
  *
  * @param cache - The process cache.
  * @param client - Connected chrisapi client.
- * @returns The feed IDs added.
+ * @returns The feed IDs added; after a promotion, the full walk's reconciliation targets.
  */
 async function procRosterDelta_run(cache, client) {
     const knownIDs = cache.feedIDs_get();
-    const minID = (knownIDs.length > 0 ? Math.max(...knownIDs) : 0) + 1;
+    const maxKnown = knownIDs.length > 0 ? Math.max(...knownIDs) : 0;
+    const ownedFetch = (params) => (0, cumin_1.feedsPage_get)(client, params);
+    const publicFetch = async (params) => (await (0, cumin_1.publicFeedsPage_get)(client, params)) ?? { data: [], totalCount: 0 };
+    const owned = await rosterCollection_peek(ownedFetch, maxKnown);
+    const pub = await rosterCollection_peek(publicFetch, maxKnown);
+    if (rosterTotal_moved('owned', owned) || rosterTotal_moved('public', pub)) {
+        cache.rosterSync_progress('full');
+        return procCache_build();
+    }
     const fresh = new Map();
-    await procFeeds_index((params) => (0, cumin_1.feedsPage_get)(client, { ...params, min_id: minID }), fresh);
-    await procFeeds_index(async (params) => (await (0, cumin_1.publicFeedsPage_get)(client, { ...params, min_id: minID })) ?? { data: [], totalCount: 0 }, fresh);
+    for (const feed of [...owned.newer, ...pub.newer])
+        fresh.set(feed.id, feed);
+    if (owned.overflow || pub.overflow) {
+        const minID = maxKnown + 1;
+        await procFeeds_index((params) => ownedFetch({ ...params, min_id: minID }), fresh);
+        await procFeeds_index((params) => publicFetch({ ...params, min_id: minID }), fresh);
+    }
+    rosterTotals = { owned: owned.total, public: pub.total };
     for (const feed of fresh.values())
         cache.feed_add(feed);
     cache.arrivals_note(Array.from(fresh.keys()));
@@ -1183,6 +1353,82 @@ function procTopologyCatchup_reset() {
 function procTopologyCatchup_roster(cache) {
     return procTopologyCatchup_enqueue(cache.feedIDs_get());
 }
+/**
+ * What a jump target names: a feed only (`feed_4389`), a node only
+ * (`pl-dicom_repack_639204`, or `_639204`), or a bare number that may be
+ * either. Null for anything else.
+ *
+ * @param target - What the operator typed.
+ * @returns The id and which kinds it may name, or null.
+ */
+function procTarget_parse(target) {
+    const text = target.trim();
+    const feed = /^feed_(\d+)$/.exec(text);
+    if (feed !== null)
+        return { id: Number(feed[1]), feed: true, node: false };
+    const node = /^[\w.-]*_(\d+)$/.exec(text);
+    if (node !== null)
+        return { id: Number(node[1]), feed: false, node: true };
+    if (/^\d+$/.test(text))
+        return { id: Number(text), feed: true, node: true };
+    return null;
+}
+/**
+ * Finds where a jump target lands, asking CUBE live for what the roster
+ * and the index lack: a feed shared since the roster was walked, or a node
+ * in one. A node's feed is adopted into the roster on the way, so the
+ * place the answer names can be entered at once. A bare number that is
+ * both a feed and a node answers both; the caller asks which.
+ *
+ * @param target - A feed id, a node id, or a `feed_N` / `<plugin>_N` name.
+ * @returns Every place it names that this identity can see; empty for none.
+ */
+async function procTarget_locate(target) {
+    const parsed = procTarget_parse(target);
+    if (parsed === null)
+        return [];
+    const cache = (0, cumin_1.procCache_get)();
+    const found = [];
+    if (parsed.feed) {
+        const feed = cache.feed_get(parsed.id) ?? (await procFeedAbsent_probe(parsed.id));
+        if (feed !== null)
+            found.push({ kind: 'feed', feedId: feed.id, name: `feed_${feed.id}`, title: feed.title });
+    }
+    if (parsed.node) {
+        const node = await procNode_find(parsed.id);
+        if (node !== null) {
+            const feed = cache.feed_get(node.feedId) ?? (await procFeedAbsent_probe(node.feedId));
+            if (feed !== null) {
+                found.push({ kind: 'node', feedId: node.feedId, nodeId: parsed.id, name: `${node.pluginName}_${parsed.id}`, title: feed.title });
+            }
+        }
+    }
+    return found;
+}
+/**
+ * A node's feed and plugin, from the index or, when the index lacks it,
+ * from CUBE.
+ *
+ * @param nodeId - The plugin instance id.
+ * @returns Its feed and plugin name, or null when CUBE shows no such node to this identity.
+ */
+async function procNode_find(nodeId) {
+    const known = (0, cumin_1.procCache_get)().instance_get(nodeId);
+    if (known !== undefined)
+        return { feedId: known.feedID, pluginName: known.pluginName };
+    const client = await cumin_1.chrisConnection.client_get();
+    if (!client)
+        return null;
+    try {
+        const handle = await (0, cumin_1.pluginInstance_get)(client, nodeId);
+        const feedId = Number(handle?.data?.feed_id);
+        const pluginName = String(handle?.data?.plugin_name ?? '');
+        return Number.isFinite(feedId) && feedId > 0 && pluginName !== '' ? { feedId, pluginName } : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Forgets all visit bookkeeping (tests, and a cache cleared underneath us).
  */
@@ -1191,6 +1437,7 @@ function procVisitState_reset() {
     feedVisitInflight.clear();
     rosterWalkedAt = 0;
     rosterSyncInflight = null;
+    rosterTotals = { owned: null, public: null };
     procTopologyCatchup_reset();
 }
 /**