@xano/cli 1.0.6-beta.5 → 1.0.6-beta.6

package/dist/commands/workflow_test/run_all/index.js

@@ -1,5 +1,7 @@
 import { Flags } from '@oclif/core';
 import BaseCommand from '../../../base-command.js';
+import { createOrderedEmitter, mapWithConcurrency } from '../../../utils/concurrency.js';
+import { collectAllPages, INTERNAL_PAGE_SIZE, normalizeListResponse } from '../../../utils/paging.js';
 export default class WorkflowTestRunAll extends BaseCommand {
     static description = 'Run all workflow tests in a workspace';
     static examples = [
@@ -22,6 +24,11 @@ Results: 2 passed, 1 failed (2.691s total)
             description: 'Filter by branch name',
             required: false,
         }),
+        concurrency: Flags.integer({
+            default: 1,
+            description: 'Run this many tests in parallel. Tests share the workspace database, so raise this only when your tests do not depend on shared state.',
+            required: false,
+        }),
         output: Flags.string({
             char: 'o',
             default: 'summary',
@@ -45,32 +52,35 @@ Results: 2 passed, 1 failed (2.691s total)
         const baseUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/workflow_test`;
         try {
             // Step 1: List all workflow tests
-            const listParams = new URLSearchParams({ include_xanoscript: 'false' });
-            if (flags.branch) {
-                listParams.set('branch', flags.branch);
-            }
-            const listResponse = await this.verboseFetch(`${baseUrl}?${listParams}`, {
-                headers: {
-                    accept: 'application/json',
-                    Authorization: `Bearer ${profile.access_token}`,
+            // Page the list rather than asking for everything at once: 100 per
+            // request is plenty for typical suites and does not make the instance
+            // build one enormous response. Termination is the server's own nextPage,
+            // never "the page came back full".
+            const branchValue = flags.branch;
+            const tests = await collectAllPages(async (page) => {
+                const listParams = new URLSearchParams();
+                listParams.set('page', String(page));
+                listParams.set('per_page', String(INTERNAL_PAGE_SIZE));
+                if (branchValue)
+                    listParams.set('branch', branchValue);
+                listParams.set('include_xanoscript', 'false');
+                const listResponse = await this.verboseFetch(`${baseUrl}?${listParams}`, {
+                    headers: {
+                        accept: 'application/json',
+                        Authorization: `Bearer ${profile.access_token}`,
+                    },
+                    method: 'GET',
+                }, flags.verbose, profile.access_token);
+                if (!listResponse.ok) {
+                    const errorText = await listResponse.text();
+                    this.error(`Failed to list workflow tests: ${listResponse.status}: ${listResponse.statusText}\n${errorText}`);
+                }
+                return normalizeListResponse(await listResponse.json());
+            }, {
+                onTruncate: (collected) => {
+                    this.warn(`Stopped after ${collected} workflow tests — the list did not terminate. Some tests may not have run.`);
                 },
-                method: 'GET',
-            }, flags.verbose, profile.access_token);
-            if (!listResponse.ok) {
-                const errorText = await listResponse.text();
-                this.error(`Failed to list workflow tests: ${listResponse.status}: ${listResponse.statusText}\n${errorText}`);
-            }
-            const data = (await listResponse.json());
-            let tests;
-            if (Array.isArray(data)) {
-                tests = data;
-            }
-            else if (data && typeof data === 'object' && 'items' in data && Array.isArray(data.items)) {
-                tests = data.items;
-            }
-            else {
-                this.error('Unexpected API response format');
-            }
+            });
             if (tests.length === 0) {
                 this.log('No workflow tests found');
                 return;
@@ -81,7 +91,15 @@ Results: 2 passed, 1 failed (2.691s total)
             // Step 2: Run each test
             const results = [];
             let totalTiming = 0;
-            for (const test of tests) {
+            const runOne = async (test) => {
+                // Shadowed accumulators: the body below is the original sequential
+                // logic, but it records output instead of printing it so a concurrent
+                // run can still emit in input order.
+                const results = [];
+                const lines = [];
+                const log = (message) => {
+                    lines.push(message);
+                };
                 const runUrl = `${baseUrl}/${test.id}/run`;
                 try {
                     const runResponse = await this.verboseFetch(runUrl, {
@@ -102,10 +120,10 @@ Results: 2 passed, 1 failed (2.691s total)
                         };
                         results.push(result);
                         if (flags.output === 'summary') {
-                            this.log(`FAIL  ${test.name} (0.000s)`);
-                            this.log(`      Error: API error ${runResponse.status}`);
+                            log(`FAIL  ${test.name} (0.000s)`);
+                            log(`      Error: API error ${runResponse.status}`);
                         }
-                        continue;
+                        return { lines, results };
                     }
                     const runResult = (await runResponse.json());
                     const passed = runResult.status === 'ok';
@@ -120,12 +138,12 @@ Results: 2 passed, 1 failed (2.691s total)
                     if (flags.output === 'summary') {
                         const timing = `(${runResult.timing.toFixed(3)}s)`;
                         if (passed) {
-                            this.log(`PASS  ${test.name} ${timing}`);
+                            log(`PASS  ${test.name} ${timing}`);
                         }
                         else {
-                            this.log(`FAIL  ${test.name} ${timing}`);
+                            log(`FAIL  ${test.name} ${timing}`);
                             if (runResult.message) {
-                                this.log(`      Error: ${runResult.message}`);
+                                log(`      Error: ${runResult.message}`);
                             }
                         }
                     }
@@ -139,16 +157,29 @@ Results: 2 passed, 1 failed (2.691s total)
                         timing: 0,
                     });
                     if (flags.output === 'summary') {
-                        this.log(`FAIL  ${test.name} (0.000s)`);
-                        this.log(`      Error: ${message}`);
+                        log(`FAIL  ${test.name} (0.000s)`);
+                        log(`      Error: ${message}`);
                     }
                 }
-            }
+                return { lines, results };
+            };
+            // Print in input order as each test settles, so concurrent output stays
+            // diffable against a sequential run.
+            const emitter = createOrderedEmitter((settled) => {
+                for (const line of settled.lines)
+                    this.log(line);
+            });
+            const perTest = await mapWithConcurrency(tests, flags.concurrency, async (test, index) => {
+                const settled = await runOne(test);
+                emitter.settle(index, settled);
+                return settled;
+            });
+            results.push(...perTest.flatMap((r) => r.results));
             // Step 3: Summary
             const passed = results.filter((r) => r.status === 'pass').length;
             const failed = results.filter((r) => r.status === 'fail').length;
             if (flags.output === 'json') {
-                this.log(JSON.stringify({ passed, failed, total_timing: totalTiming, results }, null, 2));
+                this.log(JSON.stringify({ failed, passed, results, total_timing: totalTiming }, null, 2));
             }
             else {
                 this.log(`\nResults: ${passed} passed, ${failed} failed (${totalTiming.toFixed(3)}s total)`);

package/dist/commands/workspace/list/index.js

@@ -1,5 +1,6 @@
 import { Flags } from '@oclif/core';
 import BaseCommand from '../../../base-command.js';
+import { buildPagingJson, formatPagingFooter, normalizeListResponse } from '../../../utils/paging.js';
 export default class WorkspaceList extends BaseCommand {
     static description = 'List all workspaces from the Xano Metadata API';
     static examples = [
@@ -71,24 +72,14 @@ Available workspaces:
                 const errorText = await response.text();
                 this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
             }
-            const data = (await response.json());
-            // Handle different response formats
-            let workspaces;
-            if (Array.isArray(data)) {
-                workspaces = data;
-            }
-            else if (data && typeof data === 'object' && 'workspaces' in data && Array.isArray(data.workspaces)) {
-                workspaces = data.workspaces;
-            }
-            else {
-                this.error('Unexpected API response format');
-            }
+            const list = normalizeListResponse(await response.json(), ['workspaces']);
+            const workspaces = list.items;
             if (flags.latest) {
                 workspaces.sort((a, b) => b.id - a.id);
             }
             // Output results
             if (flags.output === 'json') {
-                this.log(JSON.stringify(workspaces, null, 2));
+                this.log(JSON.stringify(buildPagingJson(list, { tier: 'none' }), null, 2));
             }
             else {
                 // summary format
@@ -107,6 +98,9 @@ Available workspaces:
                         }
                     }
                 }
+                const footer = formatPagingFooter({ items: workspaces }, { noun: 'workspace', tier: 'none' });
+                if (footer)
+                    this.log(footer);
             }
         }
         catch (error) {

package/dist/utils/concurrency.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Run `worker` over `items` with at most `limit` in flight at once.
+ *
+ * Results come back in **input order**, not completion order. That matters for
+ * test runners: a concurrent run must still produce output a human can diff
+ * against a sequential one, and a JSON results array whose order does not shift
+ * between runs.
+ *
+ * `limit` is clamped to at least 1, so a limit of 1 is exactly sequential
+ * execution and callers do not need a separate code path for it.
+ *
+ * The worker is expected to capture its own failures — one rejected worker
+ * rejects the whole call. Callers that want per-item error reporting (as the
+ * test runners do) should resolve a failure result instead of throwing.
+ */
+export declare function mapWithConcurrency<T, R>(items: T[], limit: number, worker: (item: T, index: number) => Promise<R>): Promise<R[]>;
+/**
+ * Emit results in input order as soon as each becomes available, without
+ * waiting for the whole batch.
+ *
+ * Progress lines are the reason this exists: with concurrency the third test may
+ * finish before the first, but printing them out of order makes the output hard
+ * to follow and non-deterministic between runs. This buffers out-of-order
+ * completions and flushes the moment the next expected index arrives, so the
+ * user sees an ordered stream that still starts before the run ends.
+ */
+export declare function createOrderedEmitter<R>(onReady: (result: R, index: number) => void): {
+    settle(index: number, result: R): void;
+};

package/dist/utils/concurrency.js

@@ -0,0 +1,54 @@
+/**
+ * Run `worker` over `items` with at most `limit` in flight at once.
+ *
+ * Results come back in **input order**, not completion order. That matters for
+ * test runners: a concurrent run must still produce output a human can diff
+ * against a sequential one, and a JSON results array whose order does not shift
+ * between runs.
+ *
+ * `limit` is clamped to at least 1, so a limit of 1 is exactly sequential
+ * execution and callers do not need a separate code path for it.
+ *
+ * The worker is expected to capture its own failures — one rejected worker
+ * rejects the whole call. Callers that want per-item error reporting (as the
+ * test runners do) should resolve a failure result instead of throwing.
+ */
+export async function mapWithConcurrency(items, limit, worker) {
+    const effectiveLimit = Math.max(1, Math.floor(limit));
+    const results = Array.from({ length: items.length });
+    let cursor = 0;
+    const runners = Array.from({ length: Math.min(effectiveLimit, items.length) }, async () => {
+        while (cursor < items.length) {
+            const index = cursor;
+            cursor++;
+            // eslint-disable-next-line no-await-in-loop
+            results[index] = await worker(items[index], index);
+        }
+    });
+    await Promise.all(runners);
+    return results;
+}
+/**
+ * Emit results in input order as soon as each becomes available, without
+ * waiting for the whole batch.
+ *
+ * Progress lines are the reason this exists: with concurrency the third test may
+ * finish before the first, but printing them out of order makes the output hard
+ * to follow and non-deterministic between runs. This buffers out-of-order
+ * completions and flushes the moment the next expected index arrives, so the
+ * user sees an ordered stream that still starts before the run ends.
+ */
+export function createOrderedEmitter(onReady) {
+    const pending = new Map();
+    let next = 0;
+    return {
+        settle(index, result) {
+            pending.set(index, result);
+            while (pending.has(next)) {
+                onReady(pending.get(next), next);
+                pending.delete(next);
+                next++;
+            }
+        },
+    };
+}

package/dist/utils/paging.d.ts

@@ -0,0 +1,141 @@
+/**
+ * How much paging information the backing Metadata API endpoint gives us.
+ *
+ * The Metadata API pages unevenly, and what the CLI can honestly tell the user
+ * depends entirely on what the response carries:
+ *
+ * - `envelope`            accepts page + per_page and returns
+ *                         {curPage, nextPage, prevPage, items[]}. `nextPage` is
+ *                         server-computed and null on the last page, so it is the
+ *                         one place a "there is more" hint is guaranteed correct.
+ * - `page-only-envelope`  accepts page only (per_page is hardcoded server-side)
+ *                         and returns an object carrying `itemsTotal`. A true
+ *                         total, so we can say where the user sits — but we offer
+ *                         no next-page affordance.
+ * - `none`                no server-side paging at all. The full set comes back,
+ *                         so the item count IS the total.
+ *
+ * There is deliberately no tier for endpoints that page but return a bare array
+ * with no metadata (tenants, releases, platforms, clusters, ephemerals, tenant
+ * backups). Those commands are left alone: the only has-more signal available
+ * would be "the page came back full", which is a guaranteed false positive when
+ * the result set is an exact multiple of the page size — sending the user to an
+ * empty page. Better to offer nothing than to offer a lie.
+ */
+export type PagingTier = 'envelope' | 'none' | 'page-only-envelope';
+export interface PagingFlagValues {
+    page?: number;
+    per_page?: number;
+}
+export interface NormalizedList<T> {
+    curPage?: number;
+    items: T[];
+    itemsTotal?: number;
+    nextPage?: number;
+    prevPage?: number;
+}
+export interface PagingFlagOptions {
+    /** Page size the endpoint hardcodes server-side; surfaced in the page flag description. */
+    fixedPerPage?: number;
+    /** Maximum per_page the endpoint accepts; surfaced in the per_page flag description. */
+    maxPerPage?: number;
+}
+declare function makePageFlag(description: string): import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+declare function makePerPageFlag(defaultValue: number, description: string): import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+type PageFlag = ReturnType<typeof makePageFlag>;
+type PerPageFlag = ReturnType<typeof makePerPageFlag>;
+/**
+ * Build the oclif flag definitions appropriate to an endpoint's paging tier.
+ * Spread the result into a command's `static flags`.
+ *
+ * A flag the server ignores is worse than no flag, so `per_page` is only
+ * produced for tiers whose endpoint actually accepts it. The overloads keep
+ * oclif's flag-type inference intact so `flags.page` stays typed at call sites.
+ */
+export declare function pagingFlags(tier: 'envelope', options?: PagingFlagOptions): {
+    page: PageFlag;
+    per_page: PerPageFlag;
+};
+export declare function pagingFlags(tier: 'page-only-envelope', options?: PagingFlagOptions): {
+    page: PageFlag;
+};
+export declare function pagingFlags(tier: 'none', options?: PagingFlagOptions): Record<string, never>;
+export declare function pagingFlags(tier: PagingTier, options?: PagingFlagOptions): Record<string, unknown>;
+/**
+ * Translate parsed paging flags into query-string entries, emitting only the
+ * params the endpoint actually declares.
+ */
+export declare function buildPagingParams(flags: PagingFlagValues | Record<string, unknown>, tier: PagingTier): Array<[string, string]>;
+/**
+ * Absorb the response shapes the Metadata API returns for list endpoints:
+ * a bare array, a paging envelope keyed on `items`, or an object keyed on the
+ * resource name (e.g. `{workspaces: [...]}`).
+ *
+ * `resourceKeys` names any resource-keyed fallbacks to check, in order.
+ */
+export declare function normalizeListResponse<T>(data: unknown, resourceKeys?: string[]): NormalizedList<T>;
+/** Page size used when the CLI pages an endpoint on the user's behalf. */
+export declare const INTERNAL_PAGE_SIZE = 100;
+/**
+ * Walk an envelope-tier endpoint page by page and collect every item.
+ *
+ * Termination is the server's own `nextPage`, never "the page came back full" —
+ * the same rule the footer follows. An empty page also stops the walk, which
+ * covers an endpoint that omits `nextPage` entirely rather than looping forever.
+ *
+ * `maxPages` is a runaway backstop, not a limit users are expected to hit; when
+ * it trips, `onTruncate` fires so the caller can say so out loud instead of
+ * silently processing a subset.
+ */
+export declare function collectAllPages<T>(fetchPage: (page: number) => Promise<NormalizedList<T>>, options?: {
+    maxPages?: number;
+    onTruncate?: (collected: number) => void;
+}): Promise<T[]>;
+export interface PagingJson<T> {
+    count: number;
+    items: T[];
+    next_page?: number;
+    page?: number;
+    per_page?: number;
+    prev_page?: number;
+    total?: number;
+}
+/**
+ * Build the `--output json` payload for a list command.
+ *
+ * Emits only fields the response actually proves, mirroring the footer's
+ * honesty rule: `total` appears only when the server sent `itemsTotal`,
+ * `next_page` only when the server computed it. `count` is always the number of
+ * items in this payload and is the one figure that is unconditionally true.
+ *
+ * Without this, a script driving `--output json` sees a bare array and its only
+ * available stop condition is `length < per_page` — precisely the page-fullness
+ * inference this module refuses to make in the footer.
+ */
+export declare function buildPagingJson<T>(list: NormalizedList<T>, options: {
+    page?: number;
+    perPage?: number;
+    tier: PagingTier;
+}): PagingJson<T>;
+export interface PagingFooterOptions {
+    /** Singular noun for the listed resource, used by the `none` tier. */
+    noun: string;
+    /** Plural form; defaults to `noun + 's'`. */
+    nounPlural?: string;
+    /** Page the user requested, used when the response omits `curPage`. */
+    page?: number;
+    /** Page size the user requested. Recorded for context; never used to infer a next page. */
+    perPage?: number;
+    tier: PagingTier;
+}
+/**
+ * Render the paging footer for a list command, reporting only facts the response
+ * actually proves. Returns null when there is nothing worth saying — an empty
+ * result set already prints its own "No X found" line.
+ *
+ * Deliberately asymmetric across tiers: `envelope` shows a next-page hint but no
+ * total, `page-only-envelope` shows a total but no next-page hint, and `none`
+ * shows a bare count. See PagingTier for why.
+ */
+export declare function formatPagingFooter<T>(list: NormalizedList<T>, options: PagingFooterOptions): null | string;
+export {};

package/dist/utils/paging.js

@@ -0,0 +1,194 @@
+/* eslint-disable camelcase */
+import { Flags } from '@oclif/core';
+function makePageFlag(description) {
+    return Flags.integer({ default: 1, description, required: false });
+}
+function makePerPageFlag(defaultValue, description) {
+    return Flags.integer({ default: defaultValue, description, required: false });
+}
+export function pagingFlags(tier, options = {}) {
+    if (tier === 'none') {
+        return {};
+    }
+    if (tier === 'page-only-envelope') {
+        const fixed = options.fixedPerPage;
+        return {
+            page: makePageFlag(fixed
+                ? `Page number for pagination (page size is fixed at ${fixed} by the API)`
+                : 'Page number for pagination'),
+        };
+    }
+    return {
+        page: makePageFlag('Page number for pagination'),
+        per_page: makePerPageFlag(50, options.maxPerPage
+            ? `Number of results per page (max ${options.maxPerPage})`
+            : 'Number of results per page'),
+    };
+}
+/**
+ * Translate parsed paging flags into query-string entries, emitting only the
+ * params the endpoint actually declares.
+ */
+export function buildPagingParams(flags, tier) {
+    if (tier === 'none') {
+        return [];
+    }
+    const { page, per_page: perPage } = flags;
+    const params = [];
+    if (page !== undefined) {
+        params.push(['page', String(page)]);
+    }
+    if (tier === 'envelope' && perPage !== undefined) {
+        params.push(['per_page', String(perPage)]);
+    }
+    return params;
+}
+/** Coerce a possibly-null numeric paging field to a number or undefined. */
+function optionalNumber(value) {
+    return typeof value === 'number' ? value : undefined;
+}
+/**
+ * Absorb the response shapes the Metadata API returns for list endpoints:
+ * a bare array, a paging envelope keyed on `items`, or an object keyed on the
+ * resource name (e.g. `{workspaces: [...]}`).
+ *
+ * `resourceKeys` names any resource-keyed fallbacks to check, in order.
+ */
+export function normalizeListResponse(data, resourceKeys = []) {
+    if (Array.isArray(data)) {
+        return { items: data };
+    }
+    if (data && typeof data === 'object') {
+        const record = data;
+        if (Array.isArray(record.items)) {
+            return {
+                curPage: optionalNumber(record.curPage),
+                items: record.items,
+                itemsTotal: optionalNumber(record.itemsTotal),
+                nextPage: optionalNumber(record.nextPage),
+                prevPage: optionalNumber(record.prevPage),
+            };
+        }
+        for (const key of resourceKeys) {
+            if (Array.isArray(record[key])) {
+                return {
+                    curPage: optionalNumber(record.curPage),
+                    items: record[key],
+                    itemsTotal: optionalNumber(record.itemsTotal),
+                    nextPage: optionalNumber(record.nextPage),
+                    prevPage: optionalNumber(record.prevPage),
+                };
+            }
+        }
+    }
+    const accepted = ['an array', 'an object with an items array', ...resourceKeys.map((k) => `an object with a ${k} array`)];
+    throw new Error(`Unexpected API response format. Expected ${accepted.join(', ')}.`);
+}
+/** Page size used when the CLI pages an endpoint on the user's behalf. */
+export const INTERNAL_PAGE_SIZE = 100;
+/**
+ * Walk an envelope-tier endpoint page by page and collect every item.
+ *
+ * Termination is the server's own `nextPage`, never "the page came back full" —
+ * the same rule the footer follows. An empty page also stops the walk, which
+ * covers an endpoint that omits `nextPage` entirely rather than looping forever.
+ *
+ * `maxPages` is a runaway backstop, not a limit users are expected to hit; when
+ * it trips, `onTruncate` fires so the caller can say so out loud instead of
+ * silently processing a subset.
+ */
+export async function collectAllPages(fetchPage, options = {}) {
+    const maxPages = options.maxPages ?? 100;
+    const items = [];
+    for (let page = 1; page <= maxPages; page++) {
+        // eslint-disable-next-line no-await-in-loop
+        const list = await fetchPage(page);
+        items.push(...list.items);
+        if (list.items.length === 0 || list.nextPage === undefined) {
+            return items;
+        }
+    }
+    options.onTruncate?.(items.length);
+    return items;
+}
+/**
+ * Build the `--output json` payload for a list command.
+ *
+ * Emits only fields the response actually proves, mirroring the footer's
+ * honesty rule: `total` appears only when the server sent `itemsTotal`,
+ * `next_page` only when the server computed it. `count` is always the number of
+ * items in this payload and is the one figure that is unconditionally true.
+ *
+ * Without this, a script driving `--output json` sees a bare array and its only
+ * available stop condition is `length < per_page` — precisely the page-fullness
+ * inference this module refuses to make in the footer.
+ */
+export function buildPagingJson(list, options) {
+    const payload = { count: list.items.length, items: list.items };
+    if (options.tier === 'none') {
+        return payload;
+    }
+    const hasPositionEvidence = list.curPage !== undefined ||
+        list.nextPage !== undefined ||
+        list.prevPage !== undefined ||
+        list.itemsTotal !== undefined;
+    // Same rule as the footer: with no metadata we cannot assert a position.
+    if (!hasPositionEvidence) {
+        return payload;
+    }
+    const page = list.curPage ?? options.page;
+    if (page !== undefined)
+        payload.page = page;
+    if (options.tier === 'envelope' && options.perPage !== undefined)
+        payload.per_page = options.perPage;
+    if (list.nextPage !== undefined)
+        payload.next_page = list.nextPage;
+    if (list.prevPage !== undefined)
+        payload.prev_page = list.prevPage;
+    if (list.itemsTotal !== undefined)
+        payload.total = list.itemsTotal;
+    return payload;
+}
+const SEPARATOR = ' · ';
+/**
+ * Render the paging footer for a list command, reporting only facts the response
+ * actually proves. Returns null when there is nothing worth saying — an empty
+ * result set already prints its own "No X found" line.
+ *
+ * Deliberately asymmetric across tiers: `envelope` shows a next-page hint but no
+ * total, `page-only-envelope` shows a total but no next-page hint, and `none`
+ * shows a bare count. See PagingTier for why.
+ */
+export function formatPagingFooter(list, options) {
+    const count = list.items.length;
+    const plural = options.nounPlural ?? `${options.noun}s`;
+    const countPhrase = `${count} ${count === 1 ? options.noun : plural}`;
+    // A paged tier whose response carried no metadata at all tells us nothing
+    // about position — the endpoint may have ignored `page` entirely. Reporting
+    // the requested page here would state the user's wish as a server fact, so
+    // fall back to the bare count.
+    const hasPositionEvidence = list.curPage !== undefined ||
+        list.nextPage !== undefined ||
+        list.prevPage !== undefined ||
+        list.itemsTotal !== undefined;
+    if (options.tier === 'none' || !hasPositionEvidence) {
+        return count === 0 ? null : countPhrase;
+    }
+    // An empty page past the end is worth reporting when we know the true total —
+    // otherwise `--page 99` on a populated workspace is indistinguishable from an
+    // empty one.
+    if (count === 0 && list.itemsTotal === undefined) {
+        return null;
+    }
+    const page = list.curPage ?? options.page ?? 1;
+    const parts = [`Page ${page}`, `${count} shown`];
+    if (options.tier === 'envelope' && list.nextPage !== undefined) {
+        // Server-computed. Null/absent on the last page, so following it can never
+        // land on an empty result. Page fullness is never consulted here.
+        parts.push(`next: --page ${list.nextPage}`);
+    }
+    if (options.tier === 'page-only-envelope' && list.itemsTotal !== undefined) {
+        parts.push(`${list.itemsTotal} total`);
+    }
+    return parts.join(SEPARATOR);
+}