@siteoshq/cli 2.5.1 → 2.6.0

package/dist/cli.js

@@ -1506,7 +1506,7 @@ var OverviewSchema = z4.object({
 });
 function createProjectApi(input) {
   const origin = resolveSiteOSAuthBaseUrl(input.env);
-  async function request(path29, schema, body, method) {
+  async function request(path30, schema, body, method) {
     const scope = body === void 0 ? "projects:workspace:read" : "projects:workspace:write";
     const grant = await input.grants.acquire({
       audience: "siteos-projects",
@@ -1520,7 +1520,7 @@ function createProjectApi(input) {
         message: "SiteOS API access is unavailable."
       });
     const response = await input.fetchImpl(
-      `${origin}/api/projects/v1/projects${path29}`,
+      `${origin}/api/projects/v1/projects${path30}`,
       {
         method: method ?? (body === void 0 ? "GET" : "POST"),
         headers: {
@@ -8418,11 +8418,301 @@ async function runServiceCommand(service, options) {
   }
 }
 
-// src/services/analytics-command.ts
+// src/services/analytics-google-csv.ts
+import { z as z14 } from "zod";
+var table = z14.object({
+  dimensions: z14.array(z14.string()),
+  metrics: z14.array(z14.object({ name: z14.string() })),
+  rows: z14.array(
+    z14.object({ dimensions: z14.array(z14.string()), metrics: z14.array(z14.string()) })
+  )
+});
+function googleReportCsv(value, fetchedAt) {
+  const report = z14.object({
+    request: z14.object({
+      kind: z14.string(),
+      propertyId: z14.string(),
+      streamId: z14.string(),
+      startDate: z14.string(),
+      endDate: z14.string(),
+      filters: z14.array(z14.unknown()),
+      minuteRange: z14.unknown().optional(),
+      comparison: z14.object({ startDate: z14.string(), endDate: z14.string() }).optional()
+    }).passthrough(),
+    timeZone: z14.string(),
+    limitations: z14.array(z14.string()),
+    quality: z14.unknown(),
+    table,
+    previous: table.optional()
+  }).parse(value);
+  const escape = (v) => `"${(/^[\s]*[=+\-@\t\r]/u.test(v) ? "'" : "") + v.replaceAll('"', '""')}"`;
+  const rows = [
+    ["Report", report.request.kind],
+    ["Definition", JSON.stringify(report.request)],
+    ["Property", report.request.propertyId],
+    ["Stream", report.request.streamId],
+    ["From", report.request.startDate],
+    ["To", report.request.endDate],
+    ["Timezone", report.timeZone],
+    ["Fetched at", fetchedAt ?? ""],
+    ["Filters", JSON.stringify(report.request.filters)],
+    ["Minute boundaries", JSON.stringify(report.request.minuteRange ?? null)],
+    ["Limitations", report.limitations.join(", ")],
+    ["Quality", JSON.stringify(report.quality)],
+    []
+  ];
+  const add = (t, label) => {
+    rows.push(
+      [label],
+      [...t.dimensions, ...t.metrics.map((m) => m.name)],
+      ...t.rows.map((r) => [...r.dimensions, ...r.metrics])
+    );
+  };
+  add(report.table, "Selected period");
+  if (report.previous) {
+    rows.push(
+      ["Comparison from", report.request.comparison?.startDate ?? ""],
+      ["Comparison to", report.request.comparison?.endDate ?? ""]
+    );
+    add(report.previous, "Comparison period");
+  }
+  return rows.map((r) => r.map(escape).join(",")).join("\r\n");
+}
+
+// src/services/analytics-google-command.ts
 import { readFile as readFile16, stat as stat2 } from "fs/promises";
 import path25 from "path";
 import { parseArgs as parseArgs4 } from "util";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
+var GOOGLE_ANALYTICS_HELP = `Read GA4 reports in the selected Project environment.
+
+Usage:
+  siteos analytics ga4 report [--period <today|yesterday|24h|7d|28d|month|last-month|custom>] [--from <date>] [--to <date>] [--compare <previous|year|none>] [--filters <json>] [--section <totals|trend|events|channels|sources|pages|countries|devices|quality>] [--offset <number>] [--limit <1..100>] [--refresh] [--environment <slug>] [--json]
+  siteos analytics ga4 realtime [--filters <json>] [--environment <slug>] [--json]
+  siteos analytics ga4 explore --file <selection.json> [--refresh] [--environment <slug>] [--json]
+  siteos analytics ga4 export --file <selection.json> [--environment <slug>]
+  siteos analytics ga4 saved list [--environment <slug>] [--json]
+  siteos analytics ga4 saved save --file <saved-report.json> [--environment <slug>] [--json]
+  siteos analytics ga4 saved remove <id> --revision <number> [--environment <slug>] [--json]
+
+A missing or stale report is queued in the shared cache; rerun to read completion.
+Exploration selections support campaigns, registered event dimensions, funnels and cohorts.
+Export writes CSV to stdout from a completed cached snapshot. It does not wait for Google.
+Saved report writes require an owner/admin and analytics:reports:write.
+No command connects Google, changes tracking or enables notifications.`;
+async function runAnalyticsGoogleCommand(options) {
+  const json = options.args.includes("--json");
+  if (options.args.length <= 1 || options.args.includes("--help"))
+    return { exitCode: 0, stdout: GOOGLE_ANALYTICS_HELP };
+  try {
+    const { values, positionals } = parseArgs4({
+      args: options.args.slice(1),
+      allowPositionals: true,
+      strict: true,
+      options: {
+        json: { type: "boolean" },
+        environment: { type: "string" },
+        period: { type: "string" },
+        from: { type: "string" },
+        to: { type: "string" },
+        compare: { type: "string" },
+        filters: { type: "string" },
+        section: { type: "string" },
+        offset: { type: "string" },
+        limit: { type: "string" },
+        file: { type: "string" },
+        revision: { type: "string" },
+        refresh: { type: "boolean" }
+      }
+    });
+    const action = positionals[0];
+    const sub = positionals[1];
+    const operations = {
+      report: {
+        args: 1,
+        flags: [
+          "period",
+          "from",
+          "to",
+          "compare",
+          "filters",
+          "refresh",
+          "section",
+          "offset",
+          "limit"
+        ]
+      },
+      realtime: { args: 1, flags: ["filters"] },
+      explore: { args: 1, flags: ["file", "refresh"] },
+      export: { args: 1, flags: ["file"] },
+      "saved list": { args: 2, flags: [] },
+      "saved save": { args: 2, flags: ["file"], write: true },
+      "saved remove": { args: 3, flags: ["revision"], write: true }
+    };
+    const operation = operations[action === "saved" ? `${action} ${sub}` : action ?? ""];
+    if (!operation || positionals.length !== operation.args || Object.keys(values).some(
+      (k) => !["json", "environment", ...operation.flags].includes(k)
+    ))
+      throw new Error(
+        "Invalid GA4 operation or flags. Run siteos analytics ga4 --help."
+      );
+    const context = await commonServiceContext(
+      options,
+      "analytics",
+      values.environment
+    );
+    if (!context) throw new Error("Select a SiteOS Project first.");
+    const runtime = commonProjectRuntime(options);
+    const scope = operation.write ? "analytics:reports:write" : "analytics:workspace:read";
+    const grant = await runtime.grants.acquire({
+      audience: "siteos-analytics",
+      scopes: [scope]
+    });
+    if (grant.grant.audience !== "siteos-analytics" || grant.grant.organizationId !== context.overview.project.organizationId || grant.grant.scopes.length !== 1 || grant.grant.scopes[0] !== scope)
+      throw new Error(
+        "The Analytics grant does not match this Project and operation."
+      );
+    if (!options.fetchImpl)
+      throw new Error("SiteOS API access is unavailable.");
+    const send = async (suffix, method = "GET", body) => {
+      const response = await options.fetchImpl(
+        `${runtime.api.origin}/api/analytics/v1/resources/${encodeURIComponent(context.resourceId)}/ga4${suffix}`,
+        {
+          method,
+          headers: {
+            Accept: "application/json",
+            Authorization: `Bearer ${grant.accessToken}`,
+            ...body ? { "Content-Type": "application/json" } : {}
+          },
+          ...body ? { body: JSON.stringify(body) } : {},
+          signal: AbortSignal.timeout(3e4)
+        }
+      );
+      const value = await response.json();
+      if (!response.ok) {
+        const error = z15.object({
+          error: z15.object({ code: z15.string(), message: z15.string().max(500) })
+        }).safeParse(value);
+        throw new SiteOSAuthApiError({
+          code: error.success ? error.data.error.code : "ANALYTICS_REQUEST_FAILED",
+          message: error.success ? error.data.error.message : "The GA4 request failed.",
+          status: response.status
+        });
+      }
+      return z15.object({
+        contractVersion: z15.literal(1),
+        resourceId: z15.literal(context.resourceId)
+      }).passthrough().parse(value);
+    };
+    const file = async () => {
+      if (!values.file)
+        throw new Error("Provide --file with a report definition.");
+      const name = path25.resolve(options.cwd ?? process.cwd(), values.file);
+      if ((await stat2(name)).size > 16384)
+        throw new Error("Definition exceeds 16 KiB.");
+      const text = await readFile16(name, "utf8");
+      if (Buffer.byteLength(text) > 16384)
+        throw new Error("Definition exceeds 16 KiB.");
+      return z15.record(z15.unknown()).parse(JSON.parse(text));
+    };
+    let result;
+    if (action === "saved") {
+      result = sub === "list" ? await send("/saved") : sub === "save" ? await send("/saved", "POST", await file()) : await send("/saved", "DELETE", {
+        id: z15.string().uuid().parse(positionals[2]),
+        revision: z15.number().int().positive().parse(Number(values.revision))
+      });
+    } else {
+      const base = await send("");
+      const binding = z15.object({ revision: z15.number().int().positive(), state: z15.string() }).parse(base.binding);
+      if (binding.state === "disconnected")
+        throw new Error("Connect GA4 in Analytics Setup first.");
+      if (action === "report") {
+        const params = new URLSearchParams({ period: values.period ?? "7d" });
+        for (const k of [
+          "from",
+          "to",
+          "compare",
+          "filters",
+          "section",
+          "offset",
+          "limit"
+        ])
+          if (values[k] && values[k] !== "none") params.set(k, values[k]);
+        if (!values.compare) params.set("compare", "previous");
+        result = await send(`?${params}`);
+        const cached = result.query;
+        if (result.range && ((values.section ? !result.report || result.stale : !cached || cached.state === "ready" && cached.stale) || values.refresh)) {
+          await send("/report", "POST", {
+            period: 7,
+            revision: binding.revision,
+            filters: values.filters ? JSON.parse(values.filters) : [],
+            range: Object.fromEntries(
+              [...params].filter(
+                ([k]) => ["period", "from", "to", "compare"].includes(k)
+              )
+            ),
+            refresh: values.refresh ?? false
+          });
+          result = await send(`?${params}`);
+        }
+      } else if (action === "realtime") {
+        const filters2 = values.filters ? JSON.parse(values.filters) : [];
+        const params = new URLSearchParams({
+          filters: JSON.stringify(filters2)
+        });
+        result = await send(`/realtime?${params}`);
+        const live = result.realtime;
+        if (!live?.report || live.stale) {
+          await send("/realtime", "POST", {
+            revision: binding.revision,
+            filters: filters2
+          });
+          result = await send(`/realtime?${params}`);
+        }
+      } else {
+        const selection = await file();
+        const suffix = `/explore?${new URLSearchParams({ selection: JSON.stringify(selection) })}`;
+        result = await send(suffix);
+        const query = result.query;
+        if (action === "export") {
+          if (!query?.report)
+            throw new Error(
+              "No cached report. Run ga4 explore first, then export after it completes."
+            );
+          const csv = googleReportCsv(query.report, query.fetchedAt ?? null);
+          return {
+            exitCode: 0,
+            stdout: csv
+          };
+        }
+        if (!query || query.state === "ready" && query.stale || values.refresh) {
+          await send("/explore", "POST", {
+            selection,
+            revision: binding.revision,
+            refresh: values.refresh ?? false
+          });
+          result = await send(suffix);
+        }
+      }
+    }
+    return { exitCode: 0, stdout: JSON.stringify(result, null, 2) };
+  } catch (cause) {
+    const error = {
+      code: cause instanceof SiteOSAuthApiError ? cause.code : "ANALYTICS_COMMAND_FAILED",
+      message: cause instanceof z15.ZodError ? "The input or server response does not match the GA4 contract." : cause instanceof Error ? cause.message : "GA4 request failed."
+    };
+    return {
+      exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
+      ...json ? { stdout: JSON.stringify({ error }) } : { stderr: error.message }
+    };
+  }
+}
+
+// src/services/analytics-command.ts
+import { readFile as readFile17, stat as stat3 } from "fs/promises";
+import path26 from "path";
+import { parseArgs as parseArgs5 } from "util";
+import { z as z16 } from "zod";
 var ANALYTICS_HELP = `Set up website Analytics in the selected Project environment.
 
 Usage:
@@ -8444,6 +8734,7 @@ Usage:
   siteos analytics funnels create --file <funnel.json> [--environment <slug>] [--json]
   siteos analytics funnels archive <id> [--environment <slug>] [--json]
   siteos analytics monitoring prepare [--environment <slug>] [--json]
+${GOOGLE_ANALYTICS_HELP.split("Usage:\n")[1].split("\n\n")[0]}
 
 Connect first: siteos project connect analytics. Cookie and Trace are optional.
 Use project environment use <slug> to select an environment; no resource fallback is allowed.
@@ -8453,27 +8744,27 @@ Settings require an owner/admin, the current revision and at least one change.
 Catalog files are bounded JSON using the documented event/campaign/goal/funnel contracts.
 Monitoring preparation creates a Trace draft only; publication remains a separate operation.
 Analytics is Unlimited during early access. No synthetic events are sent by these commands.`;
-var EventInput = z14.object({
-  name: z14.string().regex(/^[a-z][a-z0-9_]{0,63}$/u).refine((v) => v !== "pageview" && !v.startsWith("cookie_")),
-  label: z14.string().trim().min(1).max(80),
-  properties: z14.record(
-    z14.string().regex(/^[a-z][a-z0-9_]{0,39}$/u),
-    z14.array(
-      z14.string().min(1).max(80).regex(/^[a-zA-Z0-9 _./:-]+$/u)
+var EventInput = z16.object({
+  name: z16.string().regex(/^[a-z][a-z0-9_]{0,63}$/u).refine((v) => v !== "pageview" && !v.startsWith("cookie_")),
+  label: z16.string().trim().min(1).max(80),
+  properties: z16.record(
+    z16.string().regex(/^[a-z][a-z0-9_]{0,39}$/u),
+    z16.array(
+      z16.string().min(1).max(80).regex(/^[a-zA-Z0-9 _./:-]+$/u)
     ).min(1).max(20)
   ).refine((v) => Object.keys(v).length <= 8)
 }).strict();
-var Resource = z14.object({
-  id: z14.string(),
-  organizationId: z14.string(),
-  name: z14.string(),
-  slug: z14.string(),
-  origin: z14.string().url(),
-  publicKey: z14.string(),
-  revision: z14.number().int().positive(),
-  enabled: z14.boolean(),
-  cookieEvents: z14.boolean(),
-  minimalRealtime: z14.boolean()
+var Resource = z16.object({
+  id: z16.string(),
+  organizationId: z16.string(),
+  name: z16.string(),
+  slug: z16.string(),
+  origin: z16.string().url(),
+  publicKey: z16.string(),
+  revision: z16.number().int().positive(),
+  enabled: z16.boolean(),
+  cookieEvents: z16.boolean(),
+  minimalRealtime: z16.boolean()
 });
 var readKeys = [
   "days",
@@ -8518,10 +8809,14 @@ var pick = (value, keys) => Object.fromEntries(
 );
 async function runAnalyticsCommand(options) {
   if (!options.args.length || options.args.some((v) => ["--help", "-h"].includes(v)))
-    return { exitCode: 0, stdout: ANALYTICS_HELP };
+    return {
+      exitCode: 0,
+      stdout: ANALYTICS_HELP + "\n\n" + GOOGLE_ANALYTICS_HELP
+    };
+  if (options.args[0] === "ga4") return runAnalyticsGoogleCommand(options);
   const json = options.args.includes("--json");
   try {
-    const { positionals, values } = parseArgs4({
+    const { positionals, values } = parseArgs5({
       args: options.args,
       strict: true,
       allowPositionals: true,
@@ -8603,7 +8898,7 @@ async function runAnalyticsCommand(options) {
       throw new Error("Use --days 1, 7 or 28.");
     if (values.country && !/^(?:[A-Z]{2}|unknown)$/u.test(values.country))
       throw new Error("Use an uppercase ISO country code or unknown.");
-    if (values.campaign) z14.string().uuid().parse(values.campaign);
+    if (values.campaign) z16.string().uuid().parse(values.campaign);
     const setting = route === "settings set", creating = positionals[1] === "create", archive = positionals[1] === "archive";
     let body;
     if (setting) {
@@ -8627,10 +8922,10 @@ async function runAnalyticsCommand(options) {
     } else if (creating) {
       if (!values.file)
         throw new Error("Creation requires --file with a JSON definition.");
-      const filename = path25.resolve(options.cwd ?? process.cwd(), values.file);
-      if ((await stat2(filename)).size > 16384)
+      const filename = path26.resolve(options.cwd ?? process.cwd(), values.file);
+      if ((await stat3(filename)).size > 16384)
         throw new Error("The definition must not exceed 16 KiB.");
-      const text = await readFile16(filename, "utf8");
+      const text = await readFile17(filename, "utf8");
       if (Buffer.byteLength(text) > 16384)
         throw new Error("The definition must not exceed 16 KiB.");
       let definition;
@@ -8639,9 +8934,9 @@ async function runAnalyticsCommand(options) {
       } catch {
         throw new Error("The definition must contain valid JSON.");
       }
-      body = z14.record(z14.unknown()).parse(definition);
+      body = z16.record(z16.unknown()).parse(definition);
       if (action === "events") body = EventInput.parse(body);
-    } else if (archive) body = { id: z14.string().uuid().parse(positionals[2]) };
+    } else if (archive) body = { id: z16.string().uuid().parse(positionals[2]) };
     const context = await commonServiceContext(
       options,
       "analytics",
@@ -8688,8 +8983,8 @@ async function runAnalyticsCommand(options) {
     );
     const value = await response.json();
     if (!response.ok) {
-      const error = z14.object({
-        error: z14.object({ code: z14.string(), message: z14.string().max(500) })
+      const error = z16.object({
+        error: z16.object({ code: z16.string(), message: z16.string().max(500) })
       }).safeParse(value);
       throw new SiteOSAuthApiError({
         code: error.success ? error.data.error.code : "ANALYTICS_REQUEST_FAILED",
@@ -8697,9 +8992,9 @@ async function runAnalyticsCommand(options) {
         status: response.status
       });
     }
-    const record = z14.object({
-      contractVersion: z14.literal(1),
-      resourceId: z14.literal(context.resourceId)
+    const record = z16.object({
+      contractVersion: z16.literal(1),
+      resourceId: z16.literal(context.resourceId)
     }).passthrough().parse(value);
     let output;
     if (setting) {
@@ -8718,16 +9013,16 @@ async function runAnalyticsCommand(options) {
           throw new Error("The saved event does not match this definition.");
       } else
         output = {
-          id: z14.string().uuid().parse(record.id),
+          id: z16.string().uuid().parse(record.id),
           ...pick(
             record,
             action === "campaigns" ? ["label", "source", "medium", "campaign"] : action === "goals" ? ["label", "match"] : ["label", "steps"]
           )
         };
     } else if (archive)
-      output = { archived: z14.literal(true).parse(record.archived) };
+      output = { archived: z16.literal(true).parse(record.archived) };
     else if (route === "monitoring prepare")
-      output = { state: z14.literal("prepared").parse(record.state) };
+      output = { state: z16.literal("prepared").parse(record.state) };
     else if (action === "realtime") output = pick(record, liveKeys);
     else {
       const resource = Resource.parse(record.resource);
@@ -8739,8 +9034,8 @@ async function runAnalyticsCommand(options) {
         output = {
           resource,
           lastReceivedAt: record.lastReceivedAt,
-          consentSource: z14.object({
-            consentSource: z14.enum([
+          consentSource: z16.object({
+            consentSource: z16.enum([
               "cookie",
               "external",
               "waiting_for_cookie",
@@ -8752,11 +9047,11 @@ async function runAnalyticsCommand(options) {
       else if (action === "installation")
         output = {
           resource,
-          installation: z14.string().parse(record.installation),
+          installation: z16.string().parse(record.installation),
           configuration: record.configuration
         };
       else if (action === "events") {
-        const definitions = z14.array(EventInput).parse(record.definitions);
+        const definitions = z16.array(EventInput).parse(record.definitions);
         if (route === "events snippet") {
           const definition = definitions.find((d) => d.name === positionals[2]);
           if (!definition)
@@ -8770,13 +9065,13 @@ async function runAnalyticsCommand(options) {
           };
         } else output = { definitions, eventCounts: record.eventCounts };
       } else
-        output = action === "report" ? pick(record, readKeys) : { [action]: z14.array(z14.unknown()).parse(record[action]) };
+        output = action === "report" ? pick(record, readKeys) : { [action]: z16.array(z16.unknown()).parse(record[action]) };
     }
     return { exitCode: 0, stdout: JSON.stringify(output, null, 2) };
   } catch (cause) {
     const error = cause instanceof SiteOSAuthApiError ? { code: cause.code, message: cause.message } : {
       code: "ANALYTICS_COMMAND_FAILED",
-      message: cause instanceof z14.ZodError ? "The Analytics input or response does not match the supported contract." : cause instanceof Error ? cause.message : "The Analytics command failed."
+      message: cause instanceof z16.ZodError ? "The Analytics input or response does not match the supported contract." : cause instanceof Error ? cause.message : "The Analytics command failed."
     };
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
@@ -8786,13 +9081,13 @@ async function runAnalyticsCommand(options) {
 }
 
 // src/services/seo-repair-command.ts
-import { parseArgs as parseArgs5 } from "util";
-import { z as z16 } from "zod";
+import { parseArgs as parseArgs6 } from "util";
+import { z as z18 } from "zod";
 
 // src/services/seo-report-client.ts
 import { open, writeFile as writeFile8 } from "fs/promises";
-import path26 from "path";
-import { z as z15 } from "zod";
+import path27 from "path";
+import { z as z17 } from "zod";
 async function seoReportClient(options, environment) {
   const context = await commonServiceContext(options, "seo", environment);
   if (!context)
@@ -8827,8 +9122,8 @@ async function seoReportClient(options, environment) {
         }
       );
       if (!response.ok) {
-        const result = z15.object({
-          error: z15.object({ code: z15.string(), message: z15.string().max(500) })
+        const result = z17.object({
+          error: z17.object({ code: z17.string(), message: z17.string().max(500) })
         }).safeParse(await response.json());
         throw new SiteOSAuthApiError({
           code: result.success ? result.data.error.code : "SEO_REQUEST_FAILED",
@@ -8842,12 +9137,12 @@ async function seoReportClient(options, environment) {
     }
   };
 }
-var versionedReport = z15.object({ contractVersion: z15.literal(1) }).passthrough();
+var versionedReport = z17.object({ contractVersion: z17.literal(1) }).passthrough();
 async function readSeoInput(cwd, filename) {
-  const file = await open(path26.resolve(cwd ?? process.cwd(), filename), "r");
+  const file = await open(path27.resolve(cwd ?? process.cwd(), filename), "r");
   try {
-    const stat3 = await file.stat();
-    if (!stat3.isFile() || stat3.size > 32e3)
+    const stat4 = await file.stat();
+    if (!stat4.isFile() || stat4.size > 32e3)
       throw new Error("Use a JSON request file of at most 32,000 bytes.");
     const buffer = Buffer.alloc(32001);
     let bytes = 0;
@@ -8868,14 +9163,14 @@ async function readSeoInput(cwd, filename) {
   }
 }
 async function writeSeoReport(options, filename, content) {
-  const output = path26.resolve(options.cwd ?? process.cwd(), filename);
+  const output = path27.resolve(options.cwd ?? process.cwd(), filename);
   await writeFile8(output, content, { flag: "wx", mode: 384 });
   return output;
 }
 function seoReportFailure(cause, json, idempotencyKey) {
   const error = {
     code: cause instanceof SiteOSAuthApiError ? cause.code : "SEO_COMMAND_FAILED",
-    message: cause instanceof z15.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
+    message: cause instanceof z17.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
   };
   return {
     exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
@@ -8894,7 +9189,7 @@ function seoReportFailure(cause, json, idempotencyKey) {
 async function runSeoRepairCommand(options) {
   const json = options.args.includes("--json");
   try {
-    const { positionals, values } = parseArgs5({
+    const { positionals, values } = parseArgs6({
       args: options.args,
       allowPositionals: true,
       strict: true,
@@ -8939,32 +9234,32 @@ async function runSeoRepairCommand(options) {
     });
     const record = versionedReport.parse(await response.json());
     if (recheck) {
-      z16.object({
-        id: z16.string(),
-        resourceId: z16.literal(client.resourceId),
-        organizationId: z16.literal(client.organizationId),
-        state: z16.literal("queued")
+      z18.object({
+        id: z18.string(),
+        resourceId: z18.literal(client.resourceId),
+        organizationId: z18.literal(client.organizationId),
+        state: z18.literal("queued")
       }).parse(record.audit);
       return { exitCode: 0, stdout: JSON.stringify(record, null, 2) };
     }
-    const brief = z16.object({
-      schemaVersion: z16.literal(1),
-      context: z16.object({
-        auditId: z16.literal(values.audit),
-        resourceId: z16.literal(client.resourceId),
-        organizationId: z16.literal(client.organizationId),
-        selectedUrls: z16.array(z16.string()).min(1).max(20),
-        ruleId: z16.literal(values.rule ?? null)
+    const brief = z18.object({
+      schemaVersion: z18.literal(1),
+      context: z18.object({
+        auditId: z18.literal(values.audit),
+        resourceId: z18.literal(client.resourceId),
+        organizationId: z18.literal(client.organizationId),
+        selectedUrls: z18.array(z18.string()).min(1).max(20),
+        ruleId: z18.literal(values.rule ?? null)
       }),
-      evidence: z16.array(
-        z16.object({
-          url: z16.string(),
-          findings: z16.array(z16.unknown()).max(12)
+      evidence: z18.array(
+        z18.object({
+          url: z18.string(),
+          findings: z18.array(z18.unknown()).max(12)
         })
       ).min(1).max(20),
-      suggestedGroups: z16.array(z16.unknown()),
-      verificationCommand: z16.string().min(1),
-      text: z16.string().min(1)
+      suggestedGroups: z18.array(z18.unknown()),
+      verificationCommand: z18.string().min(1),
+      text: z18.string().min(1)
     }).parse(record);
     const canonical = (value) => {
       const url = new URL(value);
@@ -8985,15 +9280,15 @@ async function runSeoRepairCommand(options) {
 
 // src/services/seo-command.ts
 import { writeFile as writeFile10 } from "fs/promises";
-import path28 from "path";
-import { parseArgs as parseArgs9 } from "util";
-import { z as z20 } from "zod";
+import path29 from "path";
+import { parseArgs as parseArgs10 } from "util";
+import { z as z22 } from "zod";
 
 // src/services/seo-research-command.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { setTimeout as setTimeout2 } from "timers/promises";
-import { isDeepStrictEqual, parseArgs as parseArgs6 } from "util";
-import { z as z17 } from "zod";
+import { isDeepStrictEqual, parseArgs as parseArgs7 } from "util";
+import { z as z19 } from "zod";
 var RESEARCH_HELP = `
   siteos seo research summary [--environment <slug>] [--json]
   siteos seo research status --kind <kind> [--environment <slug>] [--json]
@@ -9040,11 +9335,11 @@ var kinds = [
 ];
 var sections = [...kinds, "ai-rankings"];
 var sectionOf = (request) => request.kind === "ai-visibility" && request.category ? "ai-rankings" : request.kind;
-var requestSchema = z17.object({
-  kind: z17.enum(["domain", ...kinds]).transform((kind) => kind === "domain" ? "competitors" : kind),
-  target: z17.string().min(1).max(253)
+var requestSchema = z19.object({
+  kind: z19.enum(["domain", ...kinds]).transform((kind) => kind === "domain" ? "competitors" : kind),
+  target: z19.string().min(1).max(253)
 }).passthrough();
-var runStates = z17.enum([
+var runStates = z19.enum([
   "queued",
   "running",
   "completed",
@@ -9060,7 +9355,7 @@ var csvCell = (value) => {
 async function runSeoResearchCommand(options) {
   let idempotencyKey;
   try {
-    const { values, positionals } = parseArgs6({
+    const { values, positionals } = parseArgs7({
       args: options.args.slice(1),
       strict: true,
       allowPositionals: true,
@@ -9142,26 +9437,26 @@ async function runSeoResearchCommand(options) {
         );
     }
     const client = await seoReportClient(options, values.environment);
-    const resourceSchema = z17.object({
-      id: z17.literal(client.resourceId),
-      organizationId: z17.literal(client.organizationId)
+    const resourceSchema = z19.object({
+      id: z19.literal(client.resourceId),
+      organizationId: z19.literal(client.organizationId)
     }).passthrough();
-    const runSchema = z17.object({
-      id: z17.string(),
-      resourceId: z17.literal(client.resourceId),
-      organizationId: z17.literal(client.organizationId),
-      websiteUrl: z17.string(),
+    const runSchema = z19.object({
+      id: z19.string(),
+      resourceId: z19.literal(client.resourceId),
+      organizationId: z19.literal(client.organizationId),
+      websiteUrl: z19.string(),
       request: requestSchema,
       state: runStates,
-      createdAt: z17.string(),
-      finishedAt: z17.string().nullable(),
-      parts: z17.array(
-        z17.object({
-          key: z17.string(),
-          state: z17.enum(["completed", "failed"]),
-          error: z17.string().nullable(),
-          dataset: z17.record(z17.unknown()).nullable(),
-          observedAt: z17.string()
+      createdAt: z19.string(),
+      finishedAt: z19.string().nullable(),
+      parts: z19.array(
+        z19.object({
+          key: z19.string(),
+          state: z19.enum(["completed", "failed"]),
+          error: z19.string().nullable(),
+          dataset: z19.record(z19.unknown()).nullable(),
+          observedAt: z19.string()
         }).passthrough()
       )
     }).passthrough();
@@ -9175,36 +9470,36 @@ async function runSeoResearchCommand(options) {
     const query = `?kind=${encodeURIComponent(values.kind ?? "rankings")}`;
     let record;
     if (action.startsWith("serp ")) {
-      const snapshotSchema = z17.object({
-        id: z17.string(),
-        organizationId: z17.literal(client.organizationId),
-        resourceId: z17.literal(client.resourceId),
-        sourceRunId: z17.literal(id),
+      const snapshotSchema = z19.object({
+        id: z19.string(),
+        organizationId: z19.literal(client.organizationId),
+        resourceId: z19.literal(client.resourceId),
+        sourceRunId: z19.literal(id),
         request: requestSchema,
-        keywordKey: z17.literal(
+        keywordKey: z19.literal(
           values.keyword.normalize("NFKC").trim().toLowerCase().replace(/\s+/gu, " ")
         ),
-        state: z17.enum([
+        state: z19.enum([
           "queued",
           "running",
           "completed",
           "failed",
           "cancelled"
         ]),
-        dataset: z17.object({
-          type: z17.literal("serp"),
-          keyword: z17.string(),
-          country: z17.string(),
-          language: z17.string(),
-          device: z17.enum(["desktop", "mobile"]),
-          observedAt: z17.string(),
-          rows: z17.array(
-            z17.object({
-              position: z17.number(),
-              title: z17.string(),
-              url: z17.string(),
-              domain: z17.string(),
-              description: z17.string()
+        dataset: z19.object({
+          type: z19.literal("serp"),
+          keyword: z19.string(),
+          country: z19.string(),
+          language: z19.string(),
+          device: z19.enum(["desktop", "mobile"]),
+          observedAt: z19.string(),
+          rows: z19.array(
+            z19.object({
+              position: z19.number(),
+              title: z19.string(),
+              url: z19.string(),
+              domain: z19.string(),
+              description: z19.string()
             })
           )
         }).nullable()
@@ -9314,9 +9609,9 @@ async function runSeoResearchCommand(options) {
           name: values.name.trim(),
           ...values.id ? { id: values.id } : {}
         });
-        const saved = z17.object({
-          id: z17.string(),
-          name: z17.literal(values.name.trim()),
+        const saved = z19.object({
+          id: z19.string(),
+          name: z19.literal(values.name.trim()),
           request: requestSchema
         }).parse(record.saved);
         if (values.id && saved.id !== values.id || !isDeepStrictEqual(saved.request, plan.request))
@@ -9330,23 +9625,23 @@ async function runSeoResearchCommand(options) {
         action === "cancel" ? "run" : "write",
         {}
       );
-      z17.literal(true).parse(
+      z19.literal(true).parse(
         record[action === "cancel" ? "cancelled" : "removed"]
       );
     } else if (action === "summary") {
       record = await get("/summary");
       resourceSchema.parse(record.resource);
-      z17.array(z17.object({ kind: z17.enum(sections), summary: z17.unknown() })).parse(
+      z19.array(z19.object({ kind: z19.enum(sections), summary: z19.unknown() })).parse(
         record.checks
       );
     } else if (["status", "history", "saved list"].includes(action)) {
       const view = await get(query);
       resourceSchema.parse(view.resource);
-      const runs = z17.array(runSchema).parse(view.runs);
-      const saved = z17.array(
-        z17.object({
-          id: z17.string(),
-          name: z17.string(),
+      const runs = z19.array(runSchema).parse(view.runs);
+      const saved = z19.array(
+        z19.object({
+          id: z19.string(),
+          name: z19.string(),
           request: requestSchema
         }).passthrough()
       ).parse(view.saved);
@@ -9481,8 +9776,8 @@ async function runSeoResearchCommand(options) {
 }
 
 // src/services/seo-gsc-command.ts
-import { parseArgs as parseArgs7 } from "util";
-import { z as z18 } from "zod";
+import { parseArgs as parseArgs8 } from "util";
+import { z as z20 } from "zod";
 var GSC_HELP = `
   siteos seo gsc status [--environment <slug>] [--json]
   siteos seo gsc report [--dataset <pages|queries>] [--query <text>] [--filter <all|issues|declining>] [--sort <clicks|change|impressions>] [--page <number>] [--url <page-url>] [--environment <slug>] [--json]
@@ -9500,7 +9795,7 @@ Bind/disconnect require a current revision and separate settings authority. Disc
 `;
 async function runSeoGscCommand(options) {
   try {
-    const { values, positionals } = parseArgs7({
+    const { values, positionals } = parseArgs8({
       args: options.args.slice(1),
       strict: true,
       allowPositionals: true,
@@ -9582,13 +9877,13 @@ async function runSeoGscCommand(options) {
       `seo:search:${action === "sync" ? "sync" : writing ? "write" : "read"}`,
       body
     );
-    const runSchema = z18.object({
-      id: z18.string(),
-      resourceId: z18.literal(client.resourceId),
-      organizationId: z18.literal(client.organizationId),
-      websiteUrl: z18.string(),
-      siteUrl: z18.string(),
-      state: z18.enum([
+    const runSchema = z20.object({
+      id: z20.string(),
+      resourceId: z20.literal(client.resourceId),
+      organizationId: z20.literal(client.organizationId),
+      websiteUrl: z20.string(),
+      siteUrl: z20.string(),
+      state: z20.enum([
         "queued",
         "running",
         "completed",
@@ -9596,32 +9891,32 @@ async function runSeoGscCommand(options) {
         "failed",
         "cancelled"
       ]),
-      dates: z18.unknown()
+      dates: z20.unknown()
     }).passthrough();
-    const bindingSchema = z18.object({
-      resourceId: z18.literal(client.resourceId),
-      organizationId: z18.literal(client.organizationId),
-      websiteUrl: z18.string(),
-      siteUrl: z18.string(),
-      revision: z18.number().int().positive()
+    const bindingSchema = z20.object({
+      resourceId: z20.literal(client.resourceId),
+      organizationId: z20.literal(client.organizationId),
+      websiteUrl: z20.string(),
+      siteUrl: z20.string(),
+      revision: z20.number().int().positive()
     }).passthrough();
-    const metrics = z18.object({
-      clicks: z18.number(),
-      impressions: z18.number(),
-      ctr: z18.number(),
-      position: z18.number()
+    const metrics = z20.object({
+      clicks: z20.number(),
+      impressions: z20.number(),
+      ctr: z20.number(),
+      position: z20.number()
     }).passthrough().nullable();
     const validateView = (data) => {
       const record2 = versionedReport.parse(data);
-      z18.literal(client.resourceId).parse(record2.resourceId);
+      z20.literal(client.resourceId).parse(record2.resourceId);
       bindingSchema.nullable().parse(record2.binding);
       runSchema.nullable().parse(record2.latest);
       runSchema.nullable().parse(record2.report);
-      z18.array(
-        z18.object({ key: z18.string(), current: metrics, previous: metrics }).passthrough()
+      z20.array(
+        z20.object({ key: z20.string(), current: metrics, previous: metrics }).passthrough()
       ).parse(record2.rows);
-      z18.number().int().nonnegative().parse(record2.total);
-      z18.literal(values.dataset ?? "pages").parse(record2.dataset);
+      z20.number().int().nonnegative().parse(record2.total);
+      z20.literal(values.dataset ?? "pages").parse(record2.dataset);
       return record2;
     };
     if (action === "export") {
@@ -9637,9 +9932,9 @@ async function runSeoGscCommand(options) {
       const text = await response.text();
       if (values.format === "json") {
         const report = validateView(JSON.parse(text));
-        z18.literal(reportId).parse(runSchema.parse(report.report).id);
-        z18.array(z18.unknown()).length(rows).parse(report.rows);
-        z18.literal(truncated === "true").parse(report.truncated);
+        z20.literal(reportId).parse(runSchema.parse(report.report).id);
+        z20.array(z20.unknown()).length(rows).parse(report.rows);
+        z20.literal(truncated === "true").parse(report.truncated);
       }
       const output = await writeSeoReport(options, values.output, text);
       return {
@@ -9660,7 +9955,7 @@ async function runSeoGscCommand(options) {
       };
     }
     const record = versionedReport.parse(await response.json());
-    if (action === "disconnect") z18.literal(true).parse(record.unbound);
+    if (action === "disconnect") z20.literal(true).parse(record.unbound);
     else if (writing) {
       runSchema.parse(record.run);
       if (action === "bind") {
@@ -9680,10 +9975,10 @@ async function runSeoGscCommand(options) {
 // src/services/seo-performance-command.ts
 import { randomUUID as randomUUID7 } from "crypto";
 import { writeFile as writeFile9 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 import { setTimeout as setTimeout3 } from "timers/promises";
-import { parseArgs as parseArgs8 } from "util";
-import { z as z19 } from "zod";
+import { parseArgs as parseArgs9 } from "util";
+import { z as z21 } from "zod";
 var PERFORMANCE_HELP = `
   siteos seo performance run --audit <id> --url <url> [--url <url>...] [--device <mobile|desktop>] [--idempotency-key <key>] [--environment <slug>] [--json]
   siteos seo performance list [--device <mobile|desktop>] [--environment <slug>] [--json]
@@ -9700,7 +9995,7 @@ Reuse the returned idempotency key after an uncertain run response. Wait default
 async function runSeoPerformanceCommand(options) {
   let idempotencyKey;
   try {
-    const { values, positionals } = parseArgs8({
+    const { values, positionals } = parseArgs9({
       args: options.args.slice(1),
       strict: true,
       allowPositionals: true,
@@ -9771,12 +10066,12 @@ async function runSeoPerformanceCommand(options) {
     const runtime = commonProjectRuntime(options);
     const writing = ["run", "cancel"].includes(action);
     const scope = writing ? "seo:audits:write" : "seo:workspace:read";
-    const batchSchema = z19.object({
-      id: z19.string(),
-      resourceId: z19.literal(context.resourceId),
-      organizationId: z19.literal(context.overview.project.organizationId),
-      sourceAuditId: z19.string(),
-      state: z19.enum([
+    const batchSchema = z21.object({
+      id: z21.string(),
+      resourceId: z21.literal(context.resourceId),
+      organizationId: z21.literal(context.overview.project.organizationId),
+      sourceAuditId: z21.string(),
+      state: z21.enum([
         "queued",
         "running",
         "completed",
@@ -9784,8 +10079,8 @@ async function runSeoPerformanceCommand(options) {
         "failed",
         "cancelled"
       ]),
-      device: z19.enum(["mobile", "desktop"]),
-      urls: z19.array(z19.string()).min(1).max(10)
+      device: z21.enum(["mobile", "desktop"]),
+      urls: z21.array(z21.string()).min(1).max(10)
     }).passthrough();
     const query = new URLSearchParams();
     if (values.device) query.set("device", values.device);
@@ -9833,17 +10128,17 @@ async function runSeoPerformanceCommand(options) {
           );
         const text = await response.text();
         if (values.format === "json") {
-          const parsed = z19.object({
-            contractVersion: z19.literal(1),
+          const parsed = z21.object({
+            contractVersion: z21.literal(1),
             batch: batchSchema,
-            pages: z19.array(z19.unknown())
+            pages: z21.array(z21.unknown())
           }).parse(JSON.parse(text));
           if (parsed.batch.id !== id)
             throw new Error(
               "The export response does not match the selected check."
             );
         }
-        const output = path27.resolve(
+        const output = path28.resolve(
           options.cwd ?? process.cwd(),
           values.output
         );
@@ -9859,8 +10154,8 @@ async function runSeoPerformanceCommand(options) {
       }
       const data = await response.json();
       if (!response.ok) {
-        const error = z19.object({
-          error: z19.object({ code: z19.string(), message: z19.string().max(500) })
+        const error = z21.object({
+          error: z21.object({ code: z21.string(), message: z21.string().max(500) })
         }).safeParse(data);
         throw new SiteOSAuthApiError({
           code: error.success ? error.data.error.code : "SEO_REQUEST_FAILED",
@@ -9868,8 +10163,8 @@ async function runSeoPerformanceCommand(options) {
           status: response.status
         });
       }
-      const record = z19.object({ contractVersion: z19.literal(1) }).passthrough().parse(data);
-      if (action === "cancel") z19.literal(true).parse(record.cancelled);
+      const record = z21.object({ contractVersion: z21.literal(1) }).passthrough().parse(data);
+      if (action === "cancel") z21.literal(true).parse(record.cancelled);
       else if (action === "run") {
         const accepted = batchSchema.parse(record.batch);
         const normalize = (url) => {
@@ -9882,8 +10177,8 @@ async function runSeoPerformanceCommand(options) {
             "The queued check does not match the requested source, device and URLs."
           );
       } else {
-        z19.literal(context.resourceId).parse(record.resourceId);
-        z19.array(batchSchema).parse(record.batches);
+        z21.literal(context.resourceId).parse(record.resourceId);
+        z21.array(batchSchema).parse(record.batches);
         const selected = batchSchema.nullable().parse(record.batch);
         if (id && selected?.id !== id)
           throw new Error(
@@ -9910,7 +10205,7 @@ async function runSeoPerformanceCommand(options) {
   } catch (cause) {
     const error = {
       code: cause instanceof SiteOSAuthApiError ? cause.code : "SEO_COMMAND_FAILED",
-      message: cause instanceof z19.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The performance command failed."
+      message: cause instanceof z21.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The performance command failed."
     };
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
@@ -9982,7 +10277,7 @@ async function runSeoCommand(options) {
     return runSeoRepairCommand(options);
   const json = options.args.includes("--json");
   try {
-    const { positionals, values } = parseArgs9({
+    const { positionals, values } = parseArgs10({
       args: options.args,
       strict: true,
       allowPositionals: true,
@@ -10188,17 +10483,17 @@ async function runSeoCommand(options) {
         );
       const text = await response.text();
       if (values.format === "json")
-        z20.object({
-          contractVersion: z20.literal(1),
-          audit: z20.object({
-            id: z20.literal(values.audit),
-            resourceId: z20.literal(context.resourceId)
+        z22.object({
+          contractVersion: z22.literal(1),
+          audit: z22.object({
+            id: z22.literal(values.audit),
+            resourceId: z22.literal(context.resourceId)
           }),
-          kind: z20.literal(values.kind),
-          totalRows: z20.literal(rows),
-          rows: z20.array(z20.unknown()).length(rows)
+          kind: z22.literal(values.kind),
+          totalRows: z22.literal(rows),
+          rows: z22.array(z22.unknown()).length(rows)
         }).parse(JSON.parse(text));
-      const output = path28.resolve(options.cwd ?? process.cwd(), values.output);
+      const output = path29.resolve(options.cwd ?? process.cwd(), values.output);
       await writeFile10(output, text, { flag: "wx", mode: 384 });
       return {
         exitCode: 0,
@@ -10217,8 +10512,8 @@ async function runSeoCommand(options) {
     }
     const data = await response.json();
     if (!response.ok) {
-      const result = z20.object({
-        error: z20.object({ code: z20.string(), message: z20.string().max(500) })
+      const result = z22.object({
+        error: z22.object({ code: z22.string(), message: z22.string().max(500) })
       }).safeParse(data);
       throw new SiteOSAuthApiError({
         code: result.success ? result.data.error.code : "SEO_REQUEST_FAILED",
@@ -10226,34 +10521,34 @@ async function runSeoCommand(options) {
         status: response.status
       });
     }
-    const record = z20.object({ contractVersion: z20.literal(1) }).passthrough().parse(data);
+    const record = z22.object({ contractVersion: z22.literal(1) }).passthrough().parse(data);
     if (automation) {
-      z20.literal(context.resourceId).parse(record.resourceId);
-      const schedule = z20.object({
-        enabled: z20.boolean(),
-        weekday: z20.number().int().min(1).max(7),
-        time: z20.string(),
-        timeZone: z20.string(),
-        revision: z20.number().int().min(0),
-        nextRunAt: z20.string().nullable()
+      z22.literal(context.resourceId).parse(record.resourceId);
+      const schedule = z22.object({
+        enabled: z22.boolean(),
+        weekday: z22.number().int().min(1).max(7),
+        time: z22.string(),
+        timeZone: z22.string(),
+        revision: z22.number().int().min(0),
+        nextRunAt: z22.string().nullable()
       });
-      const notificationRoute = z20.object({
-        enabled: z20.boolean(),
-        minimumSeverity: z20.enum(["error", "warning"]),
-        includeFailures: z20.boolean(),
-        revision: z20.number().int().min(0),
-        destinationId: z20.string().nullable()
+      const notificationRoute = z22.object({
+        enabled: z22.boolean(),
+        minimumSeverity: z22.enum(["error", "warning"]),
+        includeFailures: z22.boolean(),
+        revision: z22.number().int().min(0),
+        destinationId: z22.string().nullable()
       });
       if (retryNotification) {
-        z20.literal(true).parse(record.retryQueued);
-        z20.literal(positionals[2]).parse(record.notificationId);
+        z22.literal(true).parse(record.retryQueued);
+        z22.literal(positionals[2]).parse(record.notificationId);
       } else if (route === "notifications destinations")
-        z20.object({
-          candidates: z20.array(
-            z20.object({
-              candidateId: z20.string(),
-              label: z20.string(),
-              availability: z20.literal("available")
+        z22.object({
+          candidates: z22.array(
+            z22.object({
+              candidateId: z22.string(),
+              label: z22.string(),
+              availability: z22.literal("available")
             })
           )
         }).parse(record);
@@ -10266,46 +10561,46 @@ async function runSeoCommand(options) {
         notificationRoute.parse(record.route);
       }
     } else if (!writing) {
-      const validated = z20.object({
-        resource: z20.object({
-          id: z20.literal(context.resourceId),
-          organizationId: z20.literal(context.overview.project.organizationId)
+      const validated = z22.object({
+        resource: z22.object({
+          id: z22.literal(context.resourceId),
+          organizationId: z22.literal(context.overview.project.organizationId)
         }),
-        audits: z20.array(z20.object({ id: z20.string() }).passthrough()),
-        audit: z20.object({
-          id: z20.string(),
-          resourceId: z20.literal(context.resourceId)
+        audits: z22.array(z22.object({ id: z22.string() }).passthrough()),
+        audit: z22.object({
+          id: z22.string(),
+          resourceId: z22.literal(context.resourceId)
         }).passthrough().nullable(),
-        pages: z20.array(z20.unknown()),
-        issues: z20.array(z20.unknown()),
-        changes: z20.array(z20.unknown()),
-        totalChanges: z20.number(),
-        dispositions: z20.array(z20.unknown())
+        pages: z22.array(z22.unknown()),
+        issues: z22.array(z22.unknown()),
+        changes: z22.array(z22.unknown()),
+        totalChanges: z22.number(),
+        dispositions: z22.array(z22.unknown())
       }).passthrough().parse(record);
       const selected = query.get("audit");
       if (selected && validated.audit?.id !== selected)
         throw new Error("The SEO response does not match the requested audit.");
     } else if (record.audit)
-      z20.object({
-        id: z20.string(),
-        resourceId: z20.literal(context.resourceId),
-        organizationId: z20.literal(context.overview.project.organizationId),
-        state: z20.literal("queued")
+      z22.object({
+        id: z22.string(),
+        resourceId: z22.literal(context.resourceId),
+        organizationId: z22.literal(context.overview.project.organizationId),
+        state: z22.literal("queued")
       }).parse(record.audit);
-    else if (route === "audit cancel") z20.literal(true).parse(record.cancelled);
+    else if (route === "audit cancel") z22.literal(true).parse(record.cancelled);
     else if (action === "issue")
-      z20.object({
-        url: z20.literal(values.url),
-        ruleId: z20.literal(values.rule),
-        ignored: z20.literal(positionals[1] === "ignore"),
-        revision: z20.literal(Number(values.revision) + 1)
+      z22.object({
+        url: z22.literal(values.url),
+        ruleId: z22.literal(values.rule),
+        ignored: z22.literal(positionals[1] === "ignore"),
+        revision: z22.literal(Number(values.revision) + 1)
       }).parse(record.disposition);
     else throw new Error("The SEO service returned an invalid response.");
     return { exitCode: 0, stdout: JSON.stringify(record, null, 2) };
   } catch (cause) {
     const error = {
       code: cause instanceof SiteOSAuthApiError ? cause.code : "SEO_COMMAND_FAILED",
-      message: cause instanceof z20.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
+      message: cause instanceof z22.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
     };
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,