gipity 1.0.420 → 1.0.424

package/dist/commands/add.js

@@ -5,7 +5,7 @@ import { Command } from 'commander';
 import { post } from '../api.js';
 import { requireConfig } from '../config.js';
 import { sync } from '../sync.js';
-import { success, muted, bold, warning } from '../colors.js';
+import { success, muted, bold, warning, error as clrError } from '../colors.js';
 import { run } from '../helpers/index.js';
 import { createProgressReporter, withSpinner } from '../progress.js';
 const STARTERS = [
@@ -164,9 +164,14 @@ export const addCommand = new Command('add')
         }
         return;
     }
-    // No name = show the full help (usage + options + catalog), same as --help.
+    // No name is a usage error, not a help request: error + help on STDERR and
+    // a nonzero exit. (It used to outputHelp() to stdout and exit 0, which an
+    // agent piping through `tail` reads as a successful add that printed
+    // help-shaped output.)
     if (!name) {
-        command.outputHelp();
+        console.error(clrError('Missing template or kit name. Usage: gipity add <name>  (see the catalog below, or `gipity add --list`)'));
+        command.outputHelp({ error: true });
+        process.exitCode = 1;
         return;
     }
     const config = requireConfig();

package/dist/commands/claude.js

@@ -20,7 +20,25 @@ import { printBanner } from '../banner.js';
 import { scanForAdoption, isLikelyEmpty, canAdoptCwd, formatCwdLabel, formatBytes, adoptCurrentDir, ADOPT_THRESHOLDS, } from '../adopt-cwd.js';
 import { isClaudeInstalled, ensureClaudeInstalled, CLAUDE_PACKAGE } from '../claude-setup.js';
 const __clDir = dirname(fileURLToPath(import.meta.url));
-const __clPkg = JSON.parse(readFileSync(resolve(__clDir, '../../package.json'), 'utf-8'));
+// Walk up to the nearest gipity package.json instead of a hardcoded '../..':
+// the per-module tsc layout puts this file at dist/commands/, the bundled CLI
+// at dist/, so a fixed depth breaks one of the two layouts.
+function readOwnPkg(fromDir) {
+    for (let d = fromDir;; d = dirname(d)) {
+        const p = join(d, 'package.json');
+        if (existsSync(p)) {
+            try {
+                const pkg = JSON.parse(readFileSync(p, 'utf-8'));
+                if (pkg.name === 'gipity')
+                    return pkg;
+            }
+            catch { /* keep walking */ }
+        }
+        if (dirname(d) === d)
+            return {};
+    }
+}
+const __clPkg = readOwnPkg(__clDir);
 /** Report a sync run to the user. Beyond the applied-changes line, this SURFACES
  *  sync.errors - a download that came back incomplete (truncated bulk tar, a file
  *  that couldn't be refetched) lands here, so we never print "ready" over a
@@ -292,7 +310,7 @@ export const claudeCommand = new Command('claude')
             process.exit(1);
         }
         if (!nonInteractive) {
-            printBanner({ version: __clPkg.version, email: auth?.email, cwd: process.cwd() });
+            printBanner({ version: __clPkg.version ?? 'unknown', email: auth?.email, cwd: process.cwd() });
         }
         // A GIPITY_TOKEN env token authenticates every request on its own, so the
         // saved session's expiry is irrelevant when one is set — never re-login or

package/dist/commands/deploy.js

@@ -5,6 +5,7 @@ import { formatSize } from '../utils.js';
 import { success, error as clrError, warning, muted, bold, brand } from '../colors.js';
 import { run, syncBeforeAction } from '../helpers/index.js';
 import { withSpinner } from '../progress.js';
+import { inspectPage } from './page-inspect.js';
 // ── Status icons ───────────────────────────────────────────────────────
 function statusIcon(status) {
     if (status === 'ok')
@@ -26,6 +27,7 @@ export const deployCommand = new Command('deploy')
     .option('--optimize', 'Force Vite build optimization on (default for prod; use this to optimize a dev deploy too)')
     .option('--no-optimize', 'Skip build optimization and upload files as-is - the escape hatch for plain-HTML apps whose <script src> tags are not type="module"')
     .option('--json', 'Output as JSON')
+    .option('--inspect [path]', 'After a successful deploy, run `page inspect` on the deployed URL (or URL + path) in the same command - one build-loop step instead of two. With --json, emits two JSON lines: deploy, then inspect.')
     .action((target, opts) => run('Deploy', async () => {
     if (target !== 'dev' && target !== 'prod') {
         console.error(clrError('Target must be "dev" or "prod"'));
@@ -44,8 +46,32 @@ export const deployCommand = new Command('deploy')
         ? await doDeploy()
         : await withSpinner(`Deploying to ${target}…`, doDeploy, { done: null });
     const d = res.data;
+    // Deploy + verify in one command: after a successful deploy, run the
+    // same inspect pipeline `page inspect` uses against the live URL. An
+    // inspect failure is reported but never turns a successful deploy into
+    // a nonzero exit - the deploy DID land.
+    const inspectAfter = async () => {
+        if (!opts.inspect)
+            return;
+        if (!d.url) {
+            console.error(warning('--inspect skipped: this deploy produced no URL (e.g. --only database)'));
+            return;
+        }
+        const url = typeof opts.inspect === 'string' ? new URL(opts.inspect, d.url).toString() : d.url;
+        if (!opts.json)
+            console.log('');
+        try {
+            await inspectPage(url, { json: opts.json });
+        }
+        catch (err) {
+            console.error(warning(`Inspect failed (deploy itself succeeded): ${err?.message ?? err}`));
+        }
+    };
     if (opts.json) {
         console.log(JSON.stringify(d));
+        const failedJson = d.phases?.some(p => p.status === 'failed');
+        if (!failedJson)
+            await inspectAfter();
         return;
     }
     // Format output
@@ -54,7 +80,8 @@ export const deployCommand = new Command('deploy')
     console.log(muted('─'.repeat(40)));
     if (d.phases && d.phases.length > 0) {
         for (const phase of d.phases) {
-            console.log(`${statusIcon(phase.status)} ${bold(phase.name)}: ${phase.summary}`);
+            const ms = phase.elapsedMs != null ? muted(` (${phase.elapsedMs}ms)`) : '';
+            console.log(`${statusIcon(phase.status)} ${bold(phase.name)}: ${phase.summary}${ms}`);
         }
     }
     else {
@@ -80,11 +107,11 @@ export const deployCommand = new Command('deploy')
     const failedPhases = d.phases?.filter(p => p.status === 'failed') ?? [];
     if (failedPhases.length > 0) {
         // The database phase can fail on the account-wide database cap, whose
-        // server message ("Maximum of N databases reached. Drop one first.")
-        // names no command. The droppable databases live in OTHER projects, so
-        // the default project-scoped `gipity db list` shows nothing — point the
-        // caller straight at the account-wide list + drop path so they don't
-        // dead-end (or reach for raw DB access) to free a slot.
+        // server message ("Maximum of N databases reached (you have N). Drop one
+        // first.") names no command. The droppable databases live in OTHER
+        // projects, so the default project-scoped `gipity db list` shows nothing
+        // — point the caller straight at the account-wide list + drop path so
+        // they don't dead-end (or reach for raw DB access) to free a slot.
         if (failedPhases.some(p => /databases? reached|database (cap|limit)/i.test(p.summary))) {
             console.log('');
             console.log(muted('Free a slot under the account database cap:'));
@@ -101,6 +128,7 @@ export const deployCommand = new Command('deploy')
         // has to reconstruct the URL convention or guess a subdomain.
         if (d.url)
             console.log(`${muted('Live:')} ${brand(d.url)}`);
+        await inspectAfter();
     }
 }));
 //# sourceMappingURL=deploy.js.map

package/dist/commands/page-eval.js

@@ -142,8 +142,8 @@ const JS_DECOY_FLAGS = ['--js', '--javascript', '--script', '--code', '--expr',
 export const pageEvalCommand = new Command('eval')
     .description('Evaluate JS in a real browser on a page (DOM, computed styles, element rects; inline expr or --file script)')
     .argument('<url>', 'URL to load')
-    .argument('[expr]', 'JavaScript to evaluate in page context (inline expression or statement body with return/await; result is JSON-serialized). Omit when using --file.')
-    .option('--file <path>', 'Read the script body from a file instead of the inline <expr> arg (mutually exclusive). Runs as an async function body, so top-level return/await work.')
+    .argument('[expr]', 'JavaScript to evaluate in page context (inline expression or statement body with return/await; result is JSON-serialized). Omit when using --file. Time budget: the body has ~20s to finish after page load - keep driver scripts within it.')
+    .option('--file <path>', 'Read the script body from a file instead of the inline <expr> arg (mutually exclusive). Runs as an async function body, so top-level return/await work. Same ~20s post-load budget as <expr>.')
     .option('--fixture <path>', 'Host a local file and expose it to the eval as `fixtureUrl` (and under `fixtures` by basename) to fetch in-page. For verifying a render/parse path against a real binary (an MP3, an image) - no size limit, auto-deleted after the run. Repeat for several files (single-value so it never swallows the inline <expr>).', (val, prev) => [...prev, val], [])
     .option('--wait <ms>', 'Sleep this many ms after DOMContentLoaded before evaluating (lets late async work settle; max 30000)', '500')
     .option('--wait-for <selector>', 'Wait until this CSS selector appears before evaluating (deterministic; replaces --wait)')
@@ -167,6 +167,16 @@ export const pageEvalCommand = new Command('eval')
     if (exprArg === undefined && !opts.file) {
         pageEvalCommand.error('error: Provide an inline <expr> arg or --file <path>');
     }
+    // Catch a swapped <url>/<expr> locally: the server's bare "Invalid URL"
+    // names neither the bad argument nor the expected order, so it reads like
+    // the page failed to evaluate rather than like a mis-invocation.
+    if (!/^https?:\/\//i.test(url)) {
+        const flatUrl = url.replace(/\s+/g, ' ').trim();
+        const shownUrl = flatUrl.length > 60 ? `${flatUrl.slice(0, 57)}...` : flatUrl;
+        pageEvalCommand.error(exprArg !== undefined && /^https?:\/\//i.test(exprArg)
+            ? `error: arguments are swapped — the URL is the FIRST positional: gipity page eval "${exprArg}" '<expr>'`
+            : `error: <url> must be an absolute http(s) URL (got: "${shownUrl}") — usage: gipity page eval <url> [expr]`);
+    }
     let expr = exprArg;
     if (opts.file) {
         try {

package/dist/commands/page-inspect.js

@@ -1,8 +1,9 @@
 import { Command, Option } from 'commander';
 import { post } from '../api.js';
 import { formatSize } from '../utils.js';
-import { brand, bold, error as clrError, warning, muted, info } from '../colors.js';
+import { brand, bold, error as clrError, warning, muted, info, success } from '../colors.js';
 import { run } from '../helpers/index.js';
+import { getAuth } from '../auth.js';
 import { capWaitMs } from './page-eval.js';
 import { TOUCH_DEVICES as INSPECT_DEVICES, resolveTouchDevice } from './page-screenshot.js';
 /** A console line is an error-level entry (page error or console.error). */
@@ -37,6 +38,7 @@ export const pageInspectCommand = new Command('inspect')
     .option('--wait-for <selector>', 'Wait until this CSS selector appears before capturing (deterministic; replaces --wait)')
     .option('--wait-timeout <ms>', 'Max ms to wait for --wait-for before giving up', '5000')
     .option('--json', 'Output as JSON')
+    .option('--no-reprobe', 'Skip the automatic second probe that filters one-time transient console errors - roughly halves inspect time on a page with any console error, at the cost of possibly reporting a cold-load transient as real')
     .option('--no-truncate', 'Show full URLs instead of truncating long ones with middle-ellipsis')
     .option('--all', 'Include render-blocking, large resources, oversized images, overflow culprits, and LCP detail')
     .option('--fake-media', 'Grant a synthetic microphone + camera and auto-accept the getUserMedia prompt, so voice/camera apps run headlessly (audio is a built-in tone, not real speech)')
@@ -51,206 +53,219 @@ export const pageInspectCommand = new Command('inspect')
         console.error(`  gipity page screenshot ${url}${typeof opts.screenshot === 'string' ? ` -o ${opts.screenshot}` : ''}`);
         process.exit(1);
     }
-    return run('Page inspect', async () => {
-        const waitMs = capWaitMs(opts.wait, url);
-        const parsedTimeout = parseInt(opts.waitTimeout, 10);
-        const waitForTimeoutMs = Number.isFinite(parsedTimeout) && parsedTimeout >= 0 ? parsedTimeout : 5000;
-        const truncate = opts.truncate !== false;
-        const showAll = opts.all === true;
-        const inspectBody = {
-            url, waitMs,
-            waitForSelector: opts.waitFor || undefined,
-            waitForTimeoutMs: opts.waitFor ? waitForTimeoutMs : undefined,
-            fakeMedia: opts.fakeMedia || undefined,
-            device: opts.device ? resolveTouchDevice(opts.device) : undefined,
-            auth: opts.auth || undefined,
-        };
-        const res = await post(`/tools/browser/inspect`, inspectBody);
-        const b = res.data;
-        // ── Move resource-load failures out of the console, where they're noise ──
-        // A sub-resource that returns an HTTP 4xx/5xx is reported twice: once in
-        // `failedResources` (CDP network layer — carries the full URL, method, and
-        // status) and once as a generic, URL-less console echo ("Failed to load
-        // resource: the server responded with a status of 404 ()"). The echo names
-        // nothing, so it can't be triaged on its own and only duplicates — worse —
-        // what `failedResources` already says with a URL. Drop one echo per failed
-        // resource we actually have, so every attributed failure (a real app 404 AND
-        // the platform's own injected-SDK telemetry-beacon 404, which 404s on
-        // essentially every deployed page) is surfaced exactly once, under Failed
-        // resources, with its URL — never as a bare, unattributable console line.
-        // Count BEFORE stripping the platform log endpoints below, so their echoes go
-        // too. Any SURPLUS echo (a failure the network drain missed, leaving
-        // failedResources short) is KEPT — a real problem is never hidden just because
-        // we couldn't name it.
-        const isPlatformLog = (entry) => {
-            const urlPart = entry.replace(/\s*\([^)]*\)\s*$/, '');
-            try {
-                const u = new URL(urlPart);
-                return /(^|\.)gipity\.ai$/.test(u.hostname) && /\/log\/(traffic|error)$/.test(u.pathname);
-            }
-            catch {
-                return false;
-            }
-        };
-        let resourceEchoesToDrop = (b.failedResources || []).length;
-        if (resourceEchoesToDrop > 0) {
-            const isHttpStatusResourceError = (l) => /^error:\s*Failed to load resource: the server responded with a status of \d{3}/i.test(l);
-            b.console = (b.console || []).filter((l) => {
-                if (resourceEchoesToDrop > 0 && isHttpStatusResourceError(l)) {
-                    resourceEchoesToDrop--;
-                    return false;
-                }
-                return true;
-            });
+    return run('Page inspect', () => inspectPage(url, opts));
+});
+/** Run the full inspect pipeline (probe, transient-error re-probe, noise
+ *  filtering) against a URL and print the report. Shared by `page inspect`
+ *  and `deploy --inspect`, so a build agent can deploy + verify in ONE
+ *  command instead of two round trips through the model. */
+export async function inspectPage(url, opts = {}) {
+    const waitMs = capWaitMs(opts.wait ?? '500', url);
+    const parsedTimeout = parseInt(opts.waitTimeout ?? '5000', 10);
+    const waitForTimeoutMs = Number.isFinite(parsedTimeout) && parsedTimeout >= 0 ? parsedTimeout : 5000;
+    const truncate = opts.truncate !== false;
+    const showAll = opts.all === true;
+    const inspectBody = {
+        url, waitMs,
+        waitForSelector: opts.waitFor || undefined,
+        waitForTimeoutMs: opts.waitFor ? waitForTimeoutMs : undefined,
+        fakeMedia: opts.fakeMedia || undefined,
+        device: opts.device ? resolveTouchDevice(opts.device) : undefined,
+        auth: opts.auth || undefined,
+    };
+    const res = await post(`/tools/browser/inspect`, inspectBody);
+    const b = res.data;
+    // ── Move resource-load failures out of the console, where they're noise ──
+    // A sub-resource that returns an HTTP 4xx/5xx is reported twice: once in
+    // `failedResources` (CDP network layer — carries the full URL, method, and
+    // status) and once as a generic, URL-less console echo ("Failed to load
+    // resource: the server responded with a status of 404 ()"). The echo names
+    // nothing, so it can't be triaged on its own and only duplicates — worse —
+    // what `failedResources` already says with a URL. Drop one echo per failed
+    // resource we actually have, so every attributed failure (a real app 404 AND
+    // the platform's own injected-SDK telemetry-beacon 404, which 404s on
+    // essentially every deployed page) is surfaced exactly once, under Failed
+    // resources, with its URL — never as a bare, unattributable console line.
+    // Count BEFORE stripping the platform log endpoints below, so their echoes go
+    // too. Any SURPLUS echo (a failure the network drain missed, leaving
+    // failedResources short) is KEPT — a real problem is never hidden just because
+    // we couldn't name it.
+    const isPlatformLog = (entry) => {
+        const urlPart = entry.replace(/\s*\([^)]*\)\s*$/, '');
+        try {
+            const u = new URL(urlPart);
+            return /(^|\.)gipity\.ai$/.test(u.hostname) && /\/log\/(traffic|error)$/.test(u.pathname);
         }
-        // The injected analytics SDK POSTs to `/log/{traffic,error}` on the Gipity
-        // host; a failure there is platform infrastructure, not the app's, so strip it
-        // from the failed-resource list entirely (its console echo is already gone,
-        // dropped above with every other attributed failure).
-        b.failedResources = (b.failedResources || []).filter((r) => !isPlatformLog(r));
-        // Pull message-less cross-origin "Script error." lines out first. They carry
-        // no source/stack, so they're never actionable as app-code defects, and on a
-        // Gipity-deployed page the platform's own injected SDK is itself a
-        // cross-origin script — so these are reported separately (not as app console
-        // errors, and not folded into the re-probe count) instead of misleading the
-        // agent into chasing its own code.
-        const crossOriginErrors = (b.console || []).filter(isMessagelessCrossOrigin);
-        b.console = (b.console || []).filter((l) => !isMessagelessCrossOrigin(l));
-        // Self-verify the remaining console errors before flagging them. A
-        // freshly-deployed page's first hit can throw a one-time, non-reproducible
-        // error from an asset still propagating — and reporting it as a real defect
-        // sends agents chasing a phantom. So when the first probe reports error-level
-        // console lines, re-probe once (the sticky session is now warm) and keep only
-        // the errors that recur; errors seen on a single probe are surfaced
-        // separately as transient noise.
-        let transientErrors = [];
-        if ((b.console || []).some(isErrorLine)) {
-            try {
-                const verify = await post(`/tools/browser/inspect`, inspectBody);
-                const recurring = new Set((verify.data.console || []).filter(isErrorLine));
-                transientErrors = (b.console || []).filter((l) => isErrorLine(l) && !recurring.has(l));
-                b.console = (b.console || []).filter((l) => !isErrorLine(l) || recurring.has(l));
-            }
-            catch {
-                // Re-probe failed (timeout / browser error) — report the first probe's
-                // console as-is rather than hiding anything.
-            }
+        catch {
+            return false;
         }
-        if (opts.json) {
-            console.log(JSON.stringify({
-                ...b,
-                ...(transientErrors.length ? { transientConsole: transientErrors } : {}),
-                ...(crossOriginErrors.length ? { crossOriginConsole: crossOriginErrors } : {}),
-            }));
-            return;
+    };
+    let resourceEchoesToDrop = (b.failedResources || []).length;
+    if (resourceEchoesToDrop > 0) {
+        const isHttpStatusResourceError = (l) => /^error:\s*Failed to load resource: the server responded with a status of \d{3}/i.test(l);
+        b.console = (b.console || []).filter((l) => {
+            if (resourceEchoesToDrop > 0 && isHttpStatusResourceError(l)) {
+                resourceEchoesToDrop--;
+                return false;
+            }
+            return true;
+        });
+    }
+    // The injected analytics SDK POSTs to `/log/{traffic,error}` on the Gipity
+    // host; a failure there is platform infrastructure, not the app's, so strip it
+    // from the failed-resource list entirely (its console echo is already gone,
+    // dropped above with every other attributed failure).
+    b.failedResources = (b.failedResources || []).filter((r) => !isPlatformLog(r));
+    // Pull message-less cross-origin "Script error." lines out first. They carry
+    // no source/stack, so they're never actionable as app-code defects, and on a
+    // Gipity-deployed page the platform's own injected SDK is itself a
+    // cross-origin script — so these are reported separately (not as app console
+    // errors, and not folded into the re-probe count) instead of misleading the
+    // agent into chasing its own code.
+    const crossOriginErrors = (b.console || []).filter(isMessagelessCrossOrigin);
+    b.console = (b.console || []).filter((l) => !isMessagelessCrossOrigin(l));
+    // Self-verify the remaining console errors before flagging them. A
+    // freshly-deployed page's first hit can throw a one-time, non-reproducible
+    // error from an asset still propagating — and reporting it as a real defect
+    // sends agents chasing a phantom. So when the first probe reports error-level
+    // console lines, re-probe once (the sticky session is now warm) and keep only
+    // the errors that recur; errors seen on a single probe are surfaced
+    // separately as transient noise.
+    let transientErrors = [];
+    if (opts.reprobe !== false && (b.console || []).some(isErrorLine)) {
+        try {
+            const verify = await post(`/tools/browser/inspect`, inspectBody);
+            const recurring = new Set((verify.data.console || []).filter(isErrorLine));
+            transientErrors = (b.console || []).filter((l) => isErrorLine(l) && !recurring.has(l));
+            b.console = (b.console || []).filter((l) => !isErrorLine(l) || recurring.has(l));
         }
-        const timing = b.timing || { ttfb: 0, domReady: 0, load: 0 };
-        // ── Page Info ──
-        console.log(`${brand('Inspecting')} ${bold(b.url || url)}`);
-        if (b.navigationIncomplete) {
-            console.log(`${warning('⚠ Navigation incomplete:')} ${b.note || 'page did not reach full load'}`);
+        catch {
+            // Re-probe failed (timeout / browser error) — report the first probe's
+            // console as-is rather than hiding anything.
         }
-        console.log(`${muted('Title:')} ${b.title || '(none)'}`);
-        console.log(`${muted('Elements:')} ${b.elementCount || 0}`);
-        console.log(`${muted('Page weight:')} ${info(formatSize(b.totalBytes || 0))}`);
-        // ── Timing ──
-        console.log(`\n${bold('Timing:')}`);
-        console.log(`${muted('TTFB:')} ${timing.ttfb}ms`);
-        console.log(`${muted('DOM ready:')} ${timing.domReady}ms`);
-        console.log(`${muted('Load:')} ${timing.load}ms`);
-        if (showAll && b.lcp) {
-            console.log(`LCP: ${b.lcp.time}ms (${b.lcp.element}${b.lcp.url ? ' ' + shortUrl(b.lcp.url, truncate) : ''})`);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({
+            ...b,
+            ...(transientErrors.length ? { transientConsole: transientErrors } : {}),
+            ...(crossOriginErrors.length ? { crossOriginConsole: crossOriginErrors } : {}),
+        }));
+        return;
+    }
+    const timing = b.timing || { ttfb: 0, domReady: 0, load: 0 };
+    // ── Page Info ──
+    console.log(`${brand('Inspecting')} ${bold(b.url || url)}`);
+    if (b.navigationIncomplete) {
+        console.log(`${warning('⚠ Navigation incomplete:')} ${b.note || 'page did not reach full load'}`);
+    }
+    // Auth state: without this line an agent can't distinguish "signed-in render"
+    // from "--auth silently no-op'd and I'm looking at the anonymous page".
+    if (b.auth?.requested) {
+        const who = getAuth()?.email;
+        console.log(b.auth.established
+            ? `${muted('Auth:')} ${success('session established')}${who ? muted(` as ${who}`) : ''} ${muted('(what the page renders with it is app-defined)')}`
+            : `${warning('Auth: session NOT established')}${b.auth.detail ? ` — ${b.auth.detail}` : ''} ${muted('(this is the anonymous view)')}`);
+    }
+    console.log(`${muted('Title:')} ${b.title || '(none)'}`);
+    console.log(`${muted('Elements:')} ${b.elementCount || 0}`);
+    console.log(`${muted('Page weight:')} ${info(formatSize(b.totalBytes || 0))}`);
+    // ── Timing ──
+    console.log(`\n${bold('Timing:')}`);
+    console.log(`${muted('TTFB:')} ${timing.ttfb}ms`);
+    console.log(`${muted('DOM ready:')} ${timing.domReady}ms`);
+    console.log(`${muted('Load:')} ${timing.load}ms`);
+    if (showAll && b.lcp) {
+        console.log(`LCP: ${b.lcp.time}ms (${b.lcp.element}${b.lcp.url ? ' ' + shortUrl(b.lcp.url, truncate) : ''})`);
+    }
+    // ── Console ──
+    if (b.console?.length > 0) {
+        console.log(`\n${bold('Console')} ${muted(`(${b.console.length})`)}:`);
+        for (const line of b.console) {
+            console.log(`${warning(line)}`);
         }
-        // ── Console ──
-        if (b.console?.length > 0) {
-            console.log(`\n${bold('Console')} ${muted(`(${b.console.length})`)}:`);
-            for (const line of b.console) {
-                console.log(`${warning(line)}`);
-            }
+    }
+    else {
+        console.log(`\n${bold('Console:')} ${muted('(clean)')}`);
+    }
+    // ── Transient console errors (seen on first probe, gone on re-probe) ──
+    if (transientErrors.length > 0) {
+        console.log(`\n${bold('Transient console errors')} ${muted(`(${transientErrors.length}, not reproduced on re-probe)`)}:`);
+        for (const line of transientErrors) {
+            console.log(muted(line));
         }
-        else {
-            console.log(`\n${bold('Console:')} ${muted('(clean)')}`);
+        console.log(muted('One-time cold-load artifact (first hit of freshly-deployed assets) — not reproducible, not in your app code. Ignore unless it recurs.'));
+    }
+    // ── Cross-origin console errors (message-less; source hidden by the browser) ──
+    if (crossOriginErrors.length > 0) {
+        console.log(`\n${bold('Cross-origin console errors')} ${muted(`(${crossOriginErrors.length}, source hidden by the browser)`)}:`);
+        console.log(muted("Message-less — the throwing <script> lacks CORS, so the browser hides its source and there's no own-code stack to chase. Gipity's injected SDK is itself cross-origin, so if your app loads no third-party CDN scripts these are platform noise — ignore them. If your app DOES load a third-party <script>, add crossorigin=\"anonymous\" to that tag to surface the real error."));
+    }
+    // ── Failed Resources ──
+    // Browsers auto-request /favicon.ico at the site root for every page, so a
+    // 404 there isn't a resource the page actually links — it's noise on any
+    // app served under a subpath. Split that implicit request out of the failure
+    // list into a harmless note rather than flagging it as an error.
+    const isImplicitFavicon = (entry) => {
+        const urlPart = entry.replace(/\s*\([^)]*\)\s*$/, '');
+        try {
+            return new URL(urlPart).pathname === '/favicon.ico';
         }
-        // ── Transient console errors (seen on first probe, gone on re-probe) ──
-        if (transientErrors.length > 0) {
-            console.log(`\n${bold('Transient console errors')} ${muted(`(${transientErrors.length}, not reproduced on re-probe)`)}:`);
-            for (const line of transientErrors) {
-                console.log(muted(line));
-            }
-            console.log(muted('One-time cold-load artifact (first hit of freshly-deployed assets) — not reproducible, not in your app code. Ignore unless it recurs.'));
+        catch {
+            return false;
         }
-        // ── Cross-origin console errors (message-less; source hidden by the browser) ──
-        if (crossOriginErrors.length > 0) {
-            console.log(`\n${bold('Cross-origin console errors')} ${muted(`(${crossOriginErrors.length}, source hidden by the browser)`)}:`);
-            console.log(muted("Message-less — the throwing <script> lacks CORS, so the browser hides its source and there's no own-code stack to chase. Gipity's injected SDK is itself cross-origin, so if your app loads no third-party CDN scripts these are platform noise — ignore them. If your app DOES load a third-party <script>, add crossorigin=\"anonymous\" to that tag to surface the real error."));
+    };
+    const failed = (b.failedResources || []).filter((r) => !isImplicitFavicon(r));
+    const rootFaviconMissing = (b.failedResources || []).some(isImplicitFavicon);
+    if (failed.length > 0) {
+        console.log(`\n${clrError(`Failed resources (${failed.length}):`)}`);
+        for (const r of failed) {
+            console.log(`${clrError(r)}`);
         }
-        // ── Failed Resources ──
-        // Browsers auto-request /favicon.ico at the site root for every page, so a
-        // 404 there isn't a resource the page actually links — it's noise on any
-        // app served under a subpath. Split that implicit request out of the failure
-        // list into a harmless note rather than flagging it as an error.
-        const isImplicitFavicon = (entry) => {
-            const urlPart = entry.replace(/\s*\([^)]*\)\s*$/, '');
-            try {
-                return new URL(urlPart).pathname === '/favicon.ico';
-            }
-            catch {
-                return false;
+    }
+    if (rootFaviconMissing) {
+        console.log(`\n${muted('No root /favicon.ico (browsers request this automatically; harmless for app pages served under a subpath)')}`);
+    }
+    // ── Layout (horizontal overflow) ──
+    if (b.overflow) {
+        if (b.overflow.overflowX) {
+            console.log(`\n${clrError(`Horizontal overflow: +${b.overflow.amount}px`)} ${muted(`(content ${b.overflow.scrollWidth}px vs viewport ${b.overflow.clientWidth}px)`)}`);
+            if (showAll && b.overflow.culprits.length > 0) {
+                console.log(`${muted('Overflowing elements:')}`);
+                for (const c of b.overflow.culprits) {
+                    const sel = c.cls ? `${c.tag}.${c.cls.split(/\s+/)[0]}` : c.tag;
+                    console.log(`${sel} ${muted(`(right ${c.right}px, width ${c.width}px)`)}`);
+                }
             }
-        };
-        const failed = (b.failedResources || []).filter((r) => !isImplicitFavicon(r));
-        const rootFaviconMissing = (b.failedResources || []).some(isImplicitFavicon);
-        if (failed.length > 0) {
-            console.log(`\n${clrError(`Failed resources (${failed.length}):`)}`);
-            for (const r of failed) {
-                console.log(`${clrError(r)}`);
+            else if (b.overflow.culprits.length > 0) {
+                console.log(`${muted(`${b.overflow.culprits.length} overflowing element(s) - use --all to list`)}`);
             }
         }
-        if (rootFaviconMissing) {
-            console.log(`\n${muted('No root /favicon.ico (browsers request this automatically; harmless for app pages served under a subpath)')}`);
+        else {
+            console.log(`\n${bold('Layout:')} ${muted('no horizontal overflow')}`);
         }
-        // ── Layout (horizontal overflow) ──
-        if (b.overflow) {
-            if (b.overflow.overflowX) {
-                console.log(`\n${clrError(`Horizontal overflow: +${b.overflow.amount}px`)} ${muted(`(content ${b.overflow.scrollWidth}px vs viewport ${b.overflow.clientWidth}px)`)}`);
-                if (showAll && b.overflow.culprits.length > 0) {
-                    console.log(`${muted('Overflowing elements:')}`);
-                    for (const c of b.overflow.culprits) {
-                        const sel = c.cls ? `${c.tag}.${c.cls.split(/\s+/)[0]}` : c.tag;
-                        console.log(`${sel} ${muted(`(right ${c.right}px, width ${c.width}px)`)}`);
-                    }
-                }
-                else if (b.overflow.culprits.length > 0) {
-                    console.log(`${muted(`${b.overflow.culprits.length} overflowing element(s) - use --all to list`)}`);
-                }
-            }
-            else {
-                console.log(`\n${bold('Layout:')} ${muted('no horizontal overflow')}`);
+    }
+    if (showAll) {
+        // ── Render Blocking ──
+        if (b.renderBlocking?.length > 0) {
+            console.log(`\n${warning(`Render-blocking (${b.renderBlocking.length}):`)}`);
+            for (const r of b.renderBlocking) {
+                console.log(`${shortUrl(r, truncate)}`);
             }
         }
-        if (showAll) {
-            // ── Render Blocking ──
-            if (b.renderBlocking?.length > 0) {
-                console.log(`\n${warning(`Render-blocking (${b.renderBlocking.length}):`)}`);
-                for (const r of b.renderBlocking) {
-                    console.log(`${shortUrl(r, truncate)}`);
-                }
-            }
-            // ── Large Resources ──
-            if (b.largeResources?.length > 0) {
-                console.log(`\n${warning(`Large resources >100KB (${b.largeResources.length}):`)}`);
-                for (const r of b.largeResources) {
-                    console.log(`${info(formatSize(r.size).padEnd(10))} ${muted(r.type.padEnd(8))} ${shortUrl(r.url, truncate)}`);
-                }
+        // ── Large Resources ──
+        if (b.largeResources?.length > 0) {
+            console.log(`\n${warning(`Large resources >100KB (${b.largeResources.length}):`)}`);
+            for (const r of b.largeResources) {
+                console.log(`${info(formatSize(r.size).padEnd(10))} ${muted(r.type.padEnd(8))} ${shortUrl(r.url, truncate)}`);
             }
-            // ── Oversized Images ──
-            if (b.oversizedImages?.length > 0) {
-                console.log(`\n${warning(`Oversized images (${b.oversizedImages.length}):`)}`);
-                for (const img of b.oversizedImages) {
-                    console.log(`${img.natural} served, ${img.displayed} displayed - ${shortUrl(img.src, truncate)}`);
-                }
+        }
+        // ── Oversized Images ──
+        if (b.oversizedImages?.length > 0) {
+            console.log(`\n${warning(`Oversized images (${b.oversizedImages.length}):`)}`);
+            for (const img of b.oversizedImages) {
+                console.log(`${img.natural} served, ${img.displayed} displayed - ${shortUrl(img.src, truncate)}`);
             }
         }
-    });
-});
+    }
+}
 //# sourceMappingURL=page-inspect.js.map