@siteoshq/cli 2.6.1 → 2.7.0

package/dist/cli.js

@@ -17,7 +17,7 @@ __export(cookie_verification_exports, {
   verificationTarget: () => verificationTarget,
   verifyCookieWebsite: () => verifyCookieWebsite
 });
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 function verificationTarget(websiteUrl, candidate) {
   const website = new URL(websiteUrl);
   const target = new URL(candidate ?? websiteUrl, website);
@@ -322,10 +322,10 @@ async function verifyCookieWebsite(input) {
       detail: "The request limit was reached; this run is incomplete."
     });
   const config = envelope;
-  const status = issues.length ? "failed" : assessment.unknownOrigins.length || assessment.unknownStorage.length || config?.config.integrations.googleConsentMode === "advanced" ? "needs-review" : "passed";
+  const status2 = issues.length ? "failed" : assessment.unknownOrigins.length || assessment.unknownStorage.length || config?.config.integrations.googleConsentMode === "advanced" ? "needs-review" : "passed";
   return {
     schemaVersion: 1,
-    status,
+    status: status2,
     startedAt,
     completedAt: (/* @__PURE__ */ new Date()).toISOString(),
     expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString(),
@@ -367,73 +367,73 @@ var Names, Service, Envelope, State, VerificationInstallation;
 var init_cookie_verification = __esm({
   "src/services/cookie-verification.ts"() {
     "use strict";
-    Names = z12.object({
-      exact: z12.array(z12.string()),
-      prefixes: z12.array(z12.string())
+    Names = z13.object({
+      exact: z13.array(z13.string()),
+      prefixes: z13.array(z13.string())
     });
-    Service = z12.object({
-      key: z12.string(),
-      purposeKey: z12.string(),
-      lifecycle: z12.object({
-        scriptOrigins: z12.array(z12.string()),
-        iframeOrigins: z12.array(z12.string()),
-        pixelOrigins: z12.array(z12.string()),
+    Service = z13.object({
+      key: z13.string(),
+      purposeKey: z13.string(),
+      lifecycle: z13.object({
+        scriptOrigins: z13.array(z13.string()),
+        iframeOrigins: z13.array(z13.string()),
+        pixelOrigins: z13.array(z13.string()),
         firstPartyCookies: Names,
         localStorage: Names
       }).optional()
     });
-    Envelope = z12.object({
-      publicKey: z12.string(),
-      revision: z12.number(),
-      ruleKey: z12.string(),
-      profileKey: z12.string(),
-      trustedSignals: z12.object({
-        region: z12.object({
-          countryCode: z12.string().nullable(),
-          subdivisionCode: z12.string().nullable()
+    Envelope = z13.object({
+      publicKey: z13.string(),
+      revision: z13.number(),
+      ruleKey: z13.string(),
+      profileKey: z13.string(),
+      trustedSignals: z13.object({
+        region: z13.object({
+          countryCode: z13.string().nullable(),
+          subdivisionCode: z13.string().nullable()
         }).optional()
       }).optional(),
-      config: z12.object({
-        services: z12.array(Service),
-        categories: z12.array(z12.object({ key: z12.string(), required: z12.boolean() })),
-        integrations: z12.object({ googleConsentMode: z12.string() })
+      config: z13.object({
+        services: z13.array(Service),
+        categories: z13.array(z13.object({ key: z13.string(), required: z13.boolean() })),
+        integrations: z13.object({ googleConsentMode: z13.string() })
       })
     });
-    State = z12.object({
-      runtimeVersion: z12.string(),
-      preview: z12.boolean(),
-      resolved: z12.object({
-        publicKey: z12.string(),
-        revision: z12.number(),
-        ruleKey: z12.string(),
-        profileKey: z12.string()
+    State = z13.object({
+      runtimeVersion: z13.string(),
+      preview: z13.boolean(),
+      resolved: z13.object({
+        publicKey: z13.string(),
+        revision: z13.number(),
+        ruleKey: z13.string(),
+        profileKey: z13.string()
       }).nullable(),
-      consent: z12.object({
-        categories: z12.array(z12.string()),
-        decision: z12.string(),
-        globalPrivacyControl: z12.boolean(),
-        privacyChoices: z12.object({
-          saleOrShareOptOut: z12.boolean(),
-          targetedAdvertisingOptOut: z12.boolean()
+      consent: z13.object({
+        categories: z13.array(z13.string()),
+        decision: z13.string(),
+        globalPrivacyControl: z13.boolean(),
+        privacyChoices: z13.object({
+          saleOrShareOptOut: z13.boolean(),
+          targetedAdvertisingOptOut: z13.boolean()
         })
       }),
-      services: z12.array(
-        z12.object({
-          key: z12.string(),
-          allowed: z12.boolean(),
-          footprintPresent: z12.boolean()
+      services: z13.array(
+        z13.object({
+          key: z13.string(),
+          allowed: z13.boolean(),
+          footprintPresent: z13.boolean()
         })
       )
     });
-    VerificationInstallation = z12.object({
-      publicKey: z12.string(),
-      currentPublishedRevision: z12.number().int().positive(),
-      delivery: z12.object({
-        runtimeUrl: z12.string().url(),
-        configUrl: z12.string().url(),
-        analyticsUrl: z12.string().url().nullable(),
-        receiptsUrl: z12.string().url(),
-        handshakeUrl: z12.string().url()
+    VerificationInstallation = z13.object({
+      publicKey: z13.string(),
+      currentPublishedRevision: z13.number().int().positive(),
+      delivery: z13.object({
+        runtimeUrl: z13.string().url(),
+        configUrl: z13.string().url(),
+        analyticsUrl: z13.string().url().nullable(),
+        receiptsUrl: z13.string().url(),
+        handshakeUrl: z13.string().url()
       })
     });
   }
@@ -1506,7 +1506,7 @@ var OverviewSchema = z4.object({
 });
 function createProjectApi(input) {
   const origin = resolveSiteOSAuthBaseUrl(input.env);
-  async function request(path30, schema, body, method) {
+  async function request(path31, 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${path30}`,
+      `${origin}/api/projects/v1/projects${path31}`,
       {
         method: method ?? (body === void 0 ? "GET" : "POST"),
         headers: {
@@ -1552,26 +1552,26 @@ function createProjectApi(input) {
   }
   return {
     origin,
-    async update(id, details) {
+    async update(id2, details) {
       const { value, organizationId } = await request(
-        `/${encodeURIComponent(id)}`,
+        `/${encodeURIComponent(id2)}`,
         z4.object({ project: ProjectSchema }),
         details,
         "PATCH"
       );
       checkOrganization(value.project, organizationId);
-      if (value.project.id !== id) throw invalidResponse();
+      if (value.project.id !== id2) throw invalidResponse();
       return value.project;
     },
-    async updateEnvironment(id, environmentId, details) {
+    async updateEnvironment(id2, environmentId, details) {
       const { value, organizationId } = await request(
-        `/${encodeURIComponent(id)}/environments/${encodeURIComponent(environmentId)}`,
+        `/${encodeURIComponent(id2)}/environments/${encodeURIComponent(environmentId)}`,
         z4.object({ project: ProjectSchema }),
         details,
         "PATCH"
       );
       checkOrganization(value.project, organizationId);
-      if (value.project.id !== id) throw invalidResponse();
+      if (value.project.id !== id2) throw invalidResponse();
       return value.project;
     },
     async list() {
@@ -1584,14 +1584,14 @@ function createProjectApi(input) {
       );
       return value.projects;
     },
-    async get(id, environmentSlug) {
+    async get(id2, environmentSlug) {
       const { value, organizationId } = await request(
-        `/${encodeURIComponent(id)}${environmentSlug ? `?env=${encodeURIComponent(environmentSlug)}` : ""}`,
+        `/${encodeURIComponent(id2)}${environmentSlug ? `?env=${encodeURIComponent(environmentSlug)}` : ""}`,
         OverviewSchema
       );
       checkOrganization(value.project, organizationId);
-      if (value.project.id !== id || value.services.some(
-        (service) => service.attachment && (service.attachment.projectId !== id || service.attachment.service !== service.service)
+      if (value.project.id !== id2 || value.services.some(
+        (service) => service.attachment && (service.attachment.projectId !== id2 || service.attachment.service !== service.service)
       ))
         throw invalidResponse();
       return value;
@@ -1605,33 +1605,33 @@ function createProjectApi(input) {
       checkOrganization(value.project, organizationId);
       return value.project;
     },
-    async connect(id, service, resourceId, environmentSlug) {
+    async connect(id2, service, resourceId, environmentSlug) {
       await request(
-        `/${encodeURIComponent(id)}/services/${service}${environmentSlug ? `?env=${encodeURIComponent(environmentSlug)}` : ""}`,
+        `/${encodeURIComponent(id2)}/services/${service}${environmentSlug ? `?env=${encodeURIComponent(environmentSlug)}` : ""}`,
         z4.object({
           attachment: z4.object({
             resourceId: z4.string(),
-            projectId: z4.literal(id),
+            projectId: z4.literal(id2),
             service: z4.literal(service)
           })
         }),
         resourceId ? { resourceId } : { create: true }
       );
-      return this.get(id, environmentSlug);
+      return this.get(id2, environmentSlug);
     },
-    async createEnvironment(id, details) {
+    async createEnvironment(id2, details) {
       const { value, organizationId } = await request(
-        `/${encodeURIComponent(id)}/environments`,
+        `/${encodeURIComponent(id2)}/environments`,
         z4.object({ project: ProjectSchema }),
         details
       );
       checkOrganization(value.project, organizationId);
-      if (value.project.id !== id) throw invalidResponse();
+      if (value.project.id !== id2) throw invalidResponse();
       return value.project;
     },
-    async availableEnvironments(id, service) {
+    async availableEnvironments(id2, service) {
       return (await request(
-        `/${encodeURIComponent(id)}/services/${service}/environments`,
+        `/${encodeURIComponent(id2)}/services/${service}/environments`,
         z4.object({
           environments: z4.array(
             z4.object({ id: z4.string(), name: z4.string(), slug: z4.string() })
@@ -1639,18 +1639,18 @@ function createProjectApi(input) {
         })
       )).value.environments;
     },
-    async connectEnvironment(id, service, environmentId, resourceId) {
+    async connectEnvironment(id2, service, environmentId, resourceId) {
       await request(
-        `/${encodeURIComponent(id)}/services/${service}/environments/${encodeURIComponent(environmentId)}`,
+        `/${encodeURIComponent(id2)}/services/${service}/environments/${encodeURIComponent(environmentId)}`,
         z4.object({
           attachment: z4.object({
-            projectId: z4.literal(id),
+            projectId: z4.literal(id2),
             service: z4.literal(service)
           })
         }),
         resourceId ? { resourceId } : { create: true }
       );
-      return this.get(id);
+      return this.get(id2);
     }
   };
 }
@@ -2575,14 +2575,14 @@ function generateOpaqueValue() {
 function sha256Base64Url(value) {
   return createHash4("sha256").update(value, "utf-8").digest("base64url");
 }
-function sessionResult(session, json, status) {
+function sessionResult(session, json, status2) {
   if (json) {
     return { exitCode: 0, stdout: JSON.stringify(session, null, 2) };
   }
-  if (status === "expired") {
+  if (status2 === "expired") {
     return { exitCode: 0, stdout: "SiteOS CLI session is expired." };
   }
-  if (status === "revoked") {
+  if (status2 === "revoked") {
     return { exitCode: 0, stdout: "SiteOS CLI session is revoked." };
   }
   return {
@@ -2692,126 +2692,571 @@ function isCliExitCode(value) {
   return Object.values(CLI_EXIT_CODE).some((exitCode) => exitCode === value);
 }
 
+// src/forms-workspace-command.ts
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import path9 from "path";
+import { parseArgs } from "util";
+import { z as z7 } from "zod";
+var id = z7.string().min(1).max(255);
+var revision = z7.number().int().positive();
+var status = z7.enum(["new", "read", "archived", "spam"]);
+var purpose = z7.enum(["regular", "test"]);
+var filters = z7.object({
+  q: z7.string().max(200).optional(),
+  formId: id.optional(),
+  status: z7.enum(["allowed", "blocked", "all"]).optional(),
+  source: z7.enum(["regular", "test", "spam", "all"]).optional(),
+  from: z7.string().datetime().optional(),
+  to: z7.string().datetime().optional(),
+  offset: z7.coerce.number().int().min(0).max(1e5).optional()
+}).strict().refine((v) => !v.from || !v.to || v.from < v.to);
+var changes = z7.object({
+  changes: z7.array(
+    z7.object({
+      id,
+      formId: id,
+      expectedStatus: status,
+      expectedPurpose: purpose,
+      status: status.optional(),
+      purpose: purpose.optional()
+    }).strict().refine(
+      (v) => v.status !== void 0 !== (v.purpose !== void 0)
+    )
+  ).min(1).max(100)
+}).strict().refine((v) => new Set(v.changes.map((c) => c.id)).size === v.changes.length);
+var inputs = {
+  edit: z7.object({
+    expectedRevision: revision,
+    email: z7.string().email().max(254),
+    name: z7.string().max(255),
+    notes: z7.string().max(4e3)
+  }).strict(),
+  block: z7.object({
+    expectedRevision: revision,
+    blocked: z7.boolean(),
+    reason: z7.string().max(500).optional()
+  }).strict(),
+  merge: z7.object({
+    expectedRevision: revision,
+    targetId: id,
+    targetRevision: revision
+  }).strict(),
+  "mapping-set": z7.object({
+    formId: id,
+    expectedRevision: revision.min(0),
+    emailField: id.nullable(),
+    nameField: id.nullable()
+  }).strict(),
+  "protection-set": z7.object({ enabled: z7.boolean(), expectedRevision: revision.min(0) }).strict(),
+  export: z7.object({
+    filters,
+    ids: z7.array(id).min(1).max(5e3).optional(),
+    format: z7.enum(["csv", "xlsx"]),
+    columns: z7.array(
+      z7.enum([
+        "email",
+        "name",
+        "forms",
+        "submissions",
+        "firstSubmittedAt",
+        "lastSubmittedAt",
+        "status",
+        "notes"
+      ])
+    ).min(1).max(8).refine((v) => new Set(v).size === v.length)
+  }).strict(),
+  bulk: changes
+};
+var contact = z7.object({
+  id,
+  email: z7.string(),
+  name: z7.string(),
+  revision,
+  blocked: z7.boolean()
+}).passthrough();
+var contactFilters = [
+  "query",
+  "form",
+  "status",
+  "source",
+  "from",
+  "to",
+  "offset"
+];
+var submissionFilters = [
+  "form",
+  "query",
+  "status",
+  "purpose",
+  "from",
+  "to",
+  "version"
+];
+var routes = {
+  "contacts list": {
+    flags: contactFilters,
+    method: "GET",
+    suffix: "",
+    scope: "read"
+  },
+  "contacts read": {
+    flags: ["contact", "offset"],
+    method: "GET",
+    suffix: "",
+    scope: "read"
+  },
+  "contacts edit": {
+    flags: ["contact", "input"],
+    method: "PATCH",
+    suffix: "",
+    scope: "write"
+  },
+  "contacts block": {
+    flags: ["contact", "input"],
+    method: "POST",
+    suffix: "/block",
+    scope: "write"
+  },
+  "contacts merge": {
+    flags: ["contact", "input"],
+    method: "POST",
+    suffix: "/merge",
+    scope: "write"
+  },
+  "contacts import": {
+    flags: [],
+    method: "POST",
+    suffix: "/index",
+    scope: "write"
+  },
+  "contacts mappings": {
+    flags: [],
+    method: "GET",
+    suffix: "/mappings",
+    scope: "read"
+  },
+  "contacts mapping-set": {
+    flags: ["input"],
+    method: "PATCH",
+    suffix: "/mappings",
+    scope: "write"
+  },
+  "contacts protection": {
+    flags: [],
+    method: "GET",
+    suffix: "/protection",
+    scope: "read"
+  },
+  "contacts protection-set": {
+    flags: ["input"],
+    method: "PATCH",
+    suffix: "/protection",
+    scope: "write"
+  },
+  "contacts export": {
+    flags: ["input", "output"],
+    method: "POST",
+    suffix: "/export",
+    scope: "export"
+  },
+  "submissions bulk": {
+    flags: ["input"],
+    method: "POST",
+    suffix: "/bulk",
+    scope: "workspace:write"
+  },
+  "submissions export": {
+    flags: [...submissionFilters, "output"],
+    method: "GET",
+    suffix: "/export",
+    scope: "workspace:write"
+  }
+};
+var FORMS_WORKSPACE_HELP = `  siteos forms contacts list [--query <text>] [--form <id>] [--status <allowed|blocked|all>] [--source <regular|test|spam|all>] [--from <ISO>] [--to <ISO>] [--offset <number>] [--environment <slug>] [--json]
+  siteos forms contacts read --contact <id> [--offset <number>] [--environment <slug>] [--json]
+  siteos forms contacts edit --contact <id> --input <json-file> [--environment <slug>] [--json]
+  siteos forms contacts block --contact <id> --input <json-file> [--environment <slug>] [--json]
+  siteos forms contacts merge --contact <id> --input <json-file> [--environment <slug>] [--json]
+  siteos forms contacts import [--environment <slug>] [--json]
+  siteos forms contacts mappings [--environment <slug>] [--json]
+  siteos forms contacts mapping-set --input <json-file> [--environment <slug>] [--json]
+  siteos forms contacts protection [--environment <slug>] [--json]
+  siteos forms contacts protection-set --input <json-file> [--environment <slug>] [--json]
+  siteos forms contacts export --input <json-file> --output <new-file> [--environment <slug>] [--json]
+  siteos forms submissions bulk --input <json-file> [--environment <slug>] [--json]
+  siteos forms submissions export --output <new-file> [--form <id>] [--query <text>] [--status <new|read|archived|spam|inbox>] [--purpose <regular|test|all>] [--from <ISO>] [--to <ISO>] [--version <id>] [--environment <slug>] [--json]
+
+Contacts reads, writes and exports use separate grants. Writes require owner/admin.
+Import indexes one bounded batch of earlier submissions; inspect remaining before repeating.
+Block input: {"expectedRevision":1,"blocked":true,"reason":"Unwanted submissions"}; false unblocks.
+Protection input: {"expectedRevision":0,"enabled":true}. Enabling blocks disposable domains.
+Edit/merge/mapping input uses current revisions; reread conflicts before changing the request.
+Export input: {"filters":{"status":"all","source":"regular"},"format":"csv","columns":["email","name"]}.
+Bulk input: {"changes":[{"id":"submission-id","formId":"form-id","expectedStatus":"new","expectedPurpose":"regular","status":"archived"}]}.
+Each bulk item changes either status or purpose (regular/test). Results may contain conflicts.
+Export uses all matching records (up to 5000), never overwrites files, and does not grant marketing consent.`;
+async function runFormsWorkspaceCommand(options) {
+  const json = options.args.includes("--json");
+  try {
+    const route = routes[options.args.slice(0, 2).join(" ")];
+    if (!route)
+      throw new Error(
+        "Unknown Forms workspace command. Run siteos forms --help."
+      );
+    const { positionals, values } = parseArgs({
+      args: options.args.slice(2),
+      strict: true,
+      allowPositionals: true,
+      options: {
+        ...Object.fromEntries(
+          ["environment", ...route.flags].map((key) => [
+            key,
+            { type: "string" }
+          ])
+        ),
+        json: { type: "boolean" }
+      }
+    });
+    if (positionals.length) throw new Error("Unexpected positional arguments.");
+    const flags = values;
+    const value = (key) => typeof flags[key] === "string" ? flags[key] : void 0;
+    const action = options.args[1];
+    const contacts = options.args[0] === "contacts";
+    const selectedId = route.flags.includes("contact") ? id.parse(value("contact")) : void 0;
+    const query = new URLSearchParams();
+    if (contacts && action === "list") {
+      const f = filters.parse({
+        ...Object.fromEntries(
+          contactFilters.filter((key) => value(key) !== void 0).map((key) => [
+            key === "query" ? "q" : key === "form" ? "formId" : key,
+            value(key)
+          ])
+        )
+      });
+      for (const [key, v] of Object.entries(f)) query.set(key, String(v));
+    } else if (contacts && action === "read")
+      query.set(
+        "offset",
+        String(
+          z7.coerce.number().int().min(0).max(1e5).parse(value("offset") ?? 0)
+        )
+      );
+    else if (!contacts && action === "export") {
+      for (const key of submissionFilters)
+        if (value(key) !== void 0)
+          query.set(
+            key === "form" ? "formId" : key === "version" ? "versionId" : key,
+            value(key)
+          );
+      if (query.get("purpose") === "all") query.delete("purpose");
+      z7.object({
+        formId: id.optional(),
+        query: z7.string().max(200).optional(),
+        status: z7.enum(["new", "read", "archived", "spam", "inbox"]).optional(),
+        purpose: purpose.optional(),
+        from: z7.string().datetime({ offset: true }).optional(),
+        to: z7.string().datetime({ offset: true }).optional(),
+        versionId: id.optional()
+      }).strict().refine(
+        (v) => !v.from || !v.to || Date.parse(v.from) < Date.parse(v.to)
+      ).parse(Object.fromEntries(query));
+    }
+    let body;
+    if (route.flags.includes("input")) {
+      const file = value("input");
+      if (!file)
+        throw new Error("Provide --input with the reviewed JSON request.");
+      const raw = await readFile4(
+        path9.resolve(options.cwd ?? process.cwd(), file),
+        "utf8"
+      );
+      if (Buffer.byteLength(raw) > 1024 * 1024)
+        throw new Error("Input exceeds 1 MiB.");
+      body = inputs[action].parse(JSON.parse(raw));
+    }
+    const output = route.flags.includes("output") ? value("output") : void 0;
+    if (route.flags.includes("output") && !output)
+      throw new Error("Provide --output with a new file path.");
+    const context = await commonServiceContext(
+      options,
+      "forms",
+      value("environment")
+    );
+    if (!context?.environmentBinding)
+      throw new Error(
+        "Select a Project and connect Forms in the intended environment."
+      );
+    const scope = contacts ? `forms:contacts:${route.scope}` : "forms:workspace:write";
+    const grant = await commonProjectRuntime(options).grants.acquire({
+      audience: "siteos-forms",
+      scopes: [scope]
+    });
+    if (grant.grant.organizationId !== context.overview.project.organizationId || grant.grant.audience !== "siteos-forms" || !grant.grant.scopes.includes(scope))
+      throw new Error(
+        "The Forms grant does not match the selected Organization or required scope."
+      );
+    if (!options.fetchImpl)
+      throw new Error("SiteOS API access is unavailable.");
+    const url = new URL(
+      `/api/v1/forms/environments/${encodeURIComponent(context.environmentBinding.resourceId)}/${contacts ? "contacts" : "submissions"}${selectedId ? `/${encodeURIComponent(selectedId)}` : ""}${route.suffix}`,
+      context.api.origin
+    );
+    url.search = query.toString();
+    const response = await options.fetchImpl(url.href, {
+      method: route.method,
+      headers: {
+        Authorization: `Bearer ${grant.accessToken}`,
+        ...body === void 0 ? {} : { "Content-Type": "application/json" }
+      },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) },
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const data2 = await response.json().catch(() => null);
+      throw new Error(
+        `${data2?.error?.code ?? response.status}: ${data2?.error?.message ?? "Forms request failed. Reread current data before retrying a mutation."}`
+      );
+    }
+    if (output) {
+      if (!(response instanceof Response))
+        throw new Error("Export requires a streaming HTTP response.");
+      const contentType = response.headers.get("Content-Type") ?? "";
+      const expectedType = contacts && body.format === "xlsx" ? "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" : "text/csv";
+      if (!contentType.startsWith(expectedType))
+        throw new Error("Unexpected export format.");
+      const reader = response.body?.getReader();
+      if (!reader) throw new Error("Missing export body.");
+      const chunks = [];
+      let size = 0;
+      try {
+        for (; ; ) {
+          const chunk = await reader.read();
+          if (chunk.done) break;
+          size += chunk.value.byteLength;
+          if (size > 25 * 1024 * 1024)
+            throw new Error("Export exceeds 25 MiB.");
+          chunks.push(chunk.value);
+        }
+      } finally {
+        await reader.cancel();
+      }
+      const file = path9.resolve(options.cwd ?? process.cwd(), output);
+      await writeFile4(file, Buffer.concat(chunks), { flag: "wx", mode: 384 });
+      return {
+        exitCode: 0,
+        stdout: JSON.stringify({
+          output: file,
+          bytes: size,
+          environment: context.environment.slug
+        })
+      };
+    }
+    const rawData = await response.json();
+    const data = z7.record(z7.unknown()).parse(
+      action === "mappings" ? {
+        mappings: z7.array(
+          z7.object({
+            formId: id,
+            revision: revision.min(0),
+            emailField: z7.string().nullable(),
+            nameField: z7.string().nullable()
+          })
+        ).parse(rawData)
+      } : rawData
+    );
+    if (contacts && action === "list")
+      z7.object({
+        contacts: z7.array(contact),
+        total: z7.number().int().nonnegative(),
+        nextOffset: z7.number().nullable()
+      }).parse(data);
+    if (contacts && action === "read")
+      z7.object({
+        contact,
+        history: z7.array(z7.unknown()),
+        nextOffset: z7.number().nullable()
+      }).parse(data);
+    if (["edit", "block", "mapping-set", "protection-set"].includes(action))
+      z7.object({ success: z7.literal(true) }).parse(data);
+    if (action === "merge") z7.object({ id }).parse(data);
+    if (action === "import")
+      z7.object({
+        processed: z7.number().int().nonnegative(),
+        linked: z7.number().int().nonnegative(),
+        skipped: z7.number().int().nonnegative(),
+        remaining: z7.number().int().nonnegative()
+      }).parse(data);
+    if (action === "protection")
+      z7.object({
+        enabled: z7.boolean(),
+        revision: revision.min(0),
+        domainCount: z7.number().int().nonnegative()
+      }).parse(data);
+    if (action === "read")
+      z7.literal(selectedId).parse(data.contact.id);
+    if (action === "bulk") {
+      const result = z7.object({
+        results: z7.array(
+          z7.object({
+            id,
+            formId: id,
+            outcome: z7.enum(["updated", "conflict", "not_found"])
+          })
+        )
+      }).parse(data);
+      const expected = body.changes;
+      if (result.results.length !== expected.length || new Set(result.results.map((r) => r.id)).size !== expected.length || result.results.some(
+        (r) => !expected.some((c) => c.id === r.id && c.formId === r.formId)
+      ))
+        throw new Error(
+          "Bulk response does not match the requested submissions. Reread before retrying."
+        );
+      return {
+        exitCode: result.results.every((r) => r.outcome === "updated") ? 0 : 1,
+        stdout: JSON.stringify(data, null, 2)
+      };
+    }
+    return { exitCode: 0, stdout: JSON.stringify(data, null, 2) };
+  } catch (cause) {
+    const message = cause instanceof z7.ZodError ? "Invalid Forms input. Check the documented fields, filters and revisions." : cause instanceof Error ? cause.message : "Forms request failed.";
+    return {
+      exitCode: 2,
+      ...json ? { stdout: JSON.stringify({ error: { message } }) } : { stderr: message }
+    };
+  }
+}
+
 // src/forms-command.ts
-import { readFile as readFile5 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile6 } from "fs/promises";
+import path11 from "path";
 import { Ajv } from "ajv";
 import addFormats from "ajv-formats";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/siteos-forms-api.ts
-import { z as z7 } from "zod";
-var opaqueIdentifierSchema = z7.string().trim().min(1).max(255);
-var formsEnvironmentSchema = z7.object({
-  createdAt: z7.string().datetime({ offset: true }),
+import { z as z8 } from "zod";
+var opaqueIdentifierSchema = z8.string().trim().min(1).max(255);
+var formsEnvironmentSchema = z8.object({
+  createdAt: z8.string().datetime({ offset: true }),
   id: opaqueIdentifierSchema,
-  name: z7.string().trim().min(1).max(255),
+  name: z8.string().trim().min(1).max(255),
   projectId: opaqueIdentifierSchema,
-  slug: z7.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  updatedAt: z7.string().datetime({ offset: true })
+  slug: z8.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  updatedAt: z8.string().datetime({ offset: true })
 }).strict();
-var formsEnvironmentListSchema = z7.object({ environments: z7.array(formsEnvironmentSchema) }).strict();
-var formDefinitionSyncResponseSchema = z7.object({
+var formsEnvironmentListSchema = z8.object({ environments: z8.array(formsEnvironmentSchema) }).strict();
+var formDefinitionSyncResponseSchema = z8.object({
   activeVersionId: opaqueIdentifierSchema,
-  createdForm: z7.boolean(),
-  createdVersion: z7.boolean(),
+  createdForm: z8.boolean(),
+  createdVersion: z8.boolean(),
   formId: opaqueIdentifierSchema,
   formKey: opaqueIdentifierSchema,
-  success: z7.literal(true),
-  version: z7.number().int().positive()
+  success: z8.literal(true),
+  version: z8.number().int().positive()
 }).strict();
-var definitionSchema = z7.object({
+var definitionSchema = z8.object({
   id: opaqueIdentifierSchema,
   environmentId: opaqueIdentifierSchema,
   formKey: opaqueIdentifierSchema,
-  name: z7.string(),
-  sourcePagePath: z7.string().nullable(),
-  activeVersion: z7.number().int().positive(),
+  name: z8.string(),
+  sourcePagePath: z8.string().nullable(),
+  activeVersion: z8.number().int().positive(),
   activeVersionId: opaqueIdentifierSchema,
-  status: z7.enum(["active", "inactive"]),
-  submissionCount: z7.number().int().nonnegative(),
-  lastSubmittedAt: z7.string().datetime({ offset: true }).nullable(),
-  createdAt: z7.string().datetime({ offset: true }),
-  updatedAt: z7.string().datetime({ offset: true })
+  status: z8.enum(["active", "inactive"]),
+  submissionCount: z8.number().int().nonnegative(),
+  unreadCount: z8.number().int().nonnegative().optional(),
+  lastSubmittedAt: z8.string().datetime({ offset: true }).nullable(),
+  createdAt: z8.string().datetime({ offset: true }),
+  updatedAt: z8.string().datetime({ offset: true })
 });
-var definitionListSchema = z7.object({
-  definitions: z7.array(definitionSchema)
+var definitionListSchema = z8.object({
+  definitions: z8.array(definitionSchema)
 });
-var definitionContextSchema = z7.object({
+var definitionContextSchema = z8.object({
   definition: definitionSchema,
-  revision: z7.number().int().positive(),
-  canManage: z7.boolean(),
-  project: z7.object({ id: opaqueIdentifierSchema, name: z7.string() }),
-  environment: z7.object({
+  revision: z8.number().int().positive(),
+  canManage: z8.boolean(),
+  project: z8.object({ id: opaqueIdentifierSchema, name: z8.string() }),
+  environment: z8.object({
     id: opaqueIdentifierSchema,
-    name: z7.string(),
-    slug: z7.string()
+    name: z8.string(),
+    slug: z8.string()
   })
 });
-var definitionChangeResponseSchema = z7.object({
-  deleted: z7.boolean(),
+var definitionChangeResponseSchema = z8.object({
+  deleted: z8.boolean(),
   formId: opaqueIdentifierSchema
 });
-var formSubmissionResponseSchema = z7.object({
+var formSubmissionResponseSchema = z8.object({
   formId: opaqueIdentifierSchema,
-  receivedAt: z7.string().datetime({ offset: true }),
+  receivedAt: z8.string().datetime({ offset: true }),
   submissionId: opaqueIdentifierSchema,
-  success: z7.literal(true)
+  success: z8.literal(true)
 }).strict();
-var formsSubmissionStatusSchema = z7.enum([
+var formsSubmissionStatusSchema = z8.enum([
   "new",
   "read",
   "archived",
   "spam"
 ]);
-var submissionSummarySchema = z7.object({
+var submissionSummarySchema = z8.object({
   id: opaqueIdentifierSchema,
   formId: opaqueIdentifierSchema,
-  normalized: z7.record(
-    z7.union([z7.string(), z7.number(), z7.boolean(), z7.null()])
+  normalized: z8.record(
+    z8.union([z8.string(), z8.number(), z8.boolean(), z8.null()])
   ),
   status: formsSubmissionStatusSchema,
-  submittedAt: z7.string().datetime({ offset: true })
+  purpose: z8.enum(["regular", "test"]).optional(),
+  formName: z8.string().optional(),
+  formKey: z8.string().optional(),
+  submittedAt: z8.string().datetime({ offset: true })
 });
 var submissionDetailSchema = submissionSummarySchema.extend({
-  payload: z7.record(z7.unknown()),
-  fields: z7.array(
-    z7.object({
-      key: z7.string(),
-      label: z7.string().optional(),
-      kind: z7.string().optional(),
-      displayRole: z7.enum(["primary", "secondary"]).optional(),
-      multiple: z7.boolean().optional(),
-      options: z7.array(z7.object({ value: z7.string(), label: z7.string() })).optional()
+  sourceUrl: z8.string().nullable().optional(),
+  payload: z8.record(z8.unknown()),
+  fields: z8.array(
+    z8.object({
+      key: z8.string(),
+      label: z8.string().optional(),
+      kind: z8.string().optional(),
+      displayRole: z8.enum(["primary", "secondary"]).optional(),
+      multiple: z8.boolean().optional(),
+      options: z8.array(z8.object({ value: z8.string(), label: z8.string() })).optional()
     })
   ),
-  version: z7.number().int().positive(),
+  version: z8.number().int().positive(),
   versionId: opaqueIdentifierSchema
 });
-var submissionPageSchema = z7.object({
-  submissions: z7.array(submissionSummarySchema),
-  total: z7.number().int().nonnegative(),
-  nextCursor: z7.string().nullable()
+var submissionPageSchema = z8.object({
+  submissions: z8.array(submissionSummarySchema),
+  total: z8.number().int().nonnegative(),
+  nextCursor: z8.string().nullable(),
+  counts: z8.object({
+    inbox: z8.number().int().nonnegative(),
+    archived: z8.number().int().nonnegative(),
+    spam: z8.number().int().nonnegative(),
+    all: z8.number().int().nonnegative()
+  }).optional()
 });
-var submissionDetailResponseSchema = z7.object({
+var submissionDetailResponseSchema = z8.object({
   submission: submissionDetailSchema
 });
-var formsCredentialMetadataSchema = z7.object({
-  createdAt: z7.string().datetime({ offset: true }),
-  id: z7.string().trim().min(1).max(255),
-  lastUsedAt: z7.string().datetime({ offset: true }).nullable(),
-  name: z7.string().trim().min(1).max(255),
-  projectEnvironmentId: z7.string().trim().min(1).max(255),
-  revokedAt: z7.string().datetime({ offset: true }).nullable(),
-  status: z7.enum(["active", "revoked"])
+var formsCredentialMetadataSchema = z8.object({
+  createdAt: z8.string().datetime({ offset: true }),
+  id: z8.string().trim().min(1).max(255),
+  lastUsedAt: z8.string().datetime({ offset: true }).nullable(),
+  name: z8.string().trim().min(1).max(255),
+  projectEnvironmentId: z8.string().trim().min(1).max(255),
+  revokedAt: z8.string().datetime({ offset: true }).nullable(),
+  status: z8.enum(["active", "revoked"])
 }).strict();
-var formsCredentialListSchema = z7.object({
-  tokens: z7.array(formsCredentialMetadataSchema)
+var formsCredentialListSchema = z8.object({
+  tokens: z8.array(formsCredentialMetadataSchema)
 }).strict();
 var formsCredentialExchangeSchema = formsCredentialMetadataSchema.extend({
-  token: z7.string().regex(/^pfs_[A-Za-z0-9_-]{22}$/)
+  token: z8.string().regex(/^pfs_[A-Za-z0-9_-]{22}$/)
 });
-var formsErrorCodeSchema = z7.enum([
+var formsErrorCodeSchema = z8.enum([
   "AUTHENTICATION_REQUIRED",
   "FORBIDDEN",
   "CONFLICT",
@@ -2859,10 +3304,10 @@ var safeFormsErrorMessages = {
   SERVICE_UNAVAILABLE: "The Forms service is unavailable.",
   INTERNAL_ERROR: "The Forms request could not be completed."
 };
-var apiErrorResponseSchema = z7.object({
-  error: z7.object({
+var apiErrorResponseSchema = z8.object({
+  error: z8.object({
     code: formsErrorCodeSchema,
-    message: z7.string().trim().min(1).max(240)
+    message: z8.string().trim().min(1).max(240)
   }).strict()
 }).strict();
 var SiteOSFormsApiError = class extends Error {
@@ -2875,15 +3320,15 @@ var SiteOSFormsApiError = class extends Error {
     this.status = options.status;
   }
 };
-var deploymentResponseSchema = z7.object({
+var deploymentResponseSchema = z8.object({
   environmentId: opaqueIdentifierSchema,
-  forms: z7.array(
-    z7.object({
+  forms: z8.array(
+    z8.object({
       formKey: opaqueIdentifierSchema,
       formId: opaqueIdentifierSchema,
-      contractVersion: z7.string().regex(/^sha256:[a-f0-9]{64}$/),
+      contractVersion: z8.string().regex(/^sha256:[a-f0-9]{64}$/),
       versionId: opaqueIdentifierSchema,
-      version: z7.number().int().positive()
+      version: z8.number().int().positive()
     })
   )
 });
@@ -2932,7 +3377,7 @@ function createSiteOSFormsApiClient(options) {
       fetchImpl: options.fetchImpl,
       headers: managementHeaders(input),
       method: "GET",
-      path: `${inboxPath(input)}?${input.filters}`,
+      path: `${input.formId ? inboxPath({ ...input, formId: input.formId }) : `/api/v1/forms/environments/${encodeURIComponent(input.environmentId)}/submissions`}?${input.filters}`,
       responseSchema: submissionPageSchema
     }),
     readSubmission: (input) => requestJson2({
@@ -2960,7 +3405,7 @@ function createSiteOSFormsApiClient(options) {
       method: "POST",
       path: keyCollection(input),
       responseSchema: options.deploymentKeys ? formsCredentialExchangeSchema.extend({
-        token: z7.string().regex(/^pfd_[A-Za-z0-9_-]{43}$/)
+        token: z8.string().regex(/^pfd_[A-Za-z0-9_-]{43}$/)
       }) : formsCredentialExchangeSchema
     }),
     listEnvironments: (input) => requestJson2({
@@ -2995,7 +3440,7 @@ function createSiteOSFormsApiClient(options) {
       method: "POST",
       path: credentialRotatePath(input),
       responseSchema: options.deploymentKeys ? formsCredentialExchangeSchema.extend({
-        token: z7.string().regex(/^pfd_[A-Za-z0-9_-]{43}$/)
+        token: z8.string().regex(/^pfd_[A-Za-z0-9_-]{43}$/)
       }) : formsCredentialExchangeSchema
     }),
     submitForm: (input) => requestJson2({
@@ -3118,12 +3563,12 @@ import { randomUUID as randomUUID3 } from "crypto";
 import {
   chmod as chmod3,
   lstat as lstat4,
-  readFile as readFile4,
+  readFile as readFile5,
   rename as rename4,
   rm as rm3,
-  writeFile as writeFile4
+  writeFile as writeFile5
 } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 var SITEOS_FORMS_SUBMISSION_CREDENTIAL_ENV = "SITEOS_FORMS_SUBMISSION_CREDENTIAL";
 var SITEOS_FORMS_DEPLOYMENT_KEY_ENV = "SITEOS_FORMS_DEPLOYMENT_KEY";
 var SiteOSFormsCredentialStorageError = class extends Error {
@@ -3139,8 +3584,8 @@ var SiteOSFormsCredentialStorageError = class extends Error {
 async function prepareSiteOSFormsCredentialInstallation(options) {
   const variable = options.deployment ? SITEOS_FORMS_DEPLOYMENT_KEY_ENV : SITEOS_FORMS_SUBMISSION_CREDENTIAL_ENV;
   const credentialPattern = options.deployment ? /^pfd_[A-Za-z0-9_-]{43}$/ : /^pfs_[A-Za-z0-9_-]{22}$/;
-  const projectRoot = path9.resolve(options.projectRoot);
-  const dotenvPath = path9.join(projectRoot, ".env");
+  const projectRoot = path10.resolve(options.projectRoot);
+  const dotenvPath = path10.join(projectRoot, ".env");
   try {
     await assertSafeProjectRoot(projectRoot);
     if (!await isDotenvIgnored(projectRoot)) {
@@ -3202,7 +3647,7 @@ async function readSafeDotenv(dotenvPath) {
       "FORMS_CREDENTIAL_STORAGE_INVALID"
     );
   }
-  const content = dotenvStats ? await readFile4(dotenvPath, "utf8") : "";
+  const content = dotenvStats ? await readFile5(dotenvPath, "utf8") : "";
   if ([
     SITEOS_FORMS_SUBMISSION_CREDENTIAL_ENV,
     SITEOS_FORMS_DEPLOYMENT_KEY_ENV
@@ -3214,12 +3659,12 @@ async function readSafeDotenv(dotenvPath) {
   return content;
 }
 async function writeCredentialAtomically(options) {
-  const temporaryPath = path9.join(
+  const temporaryPath = path10.join(
     options.projectRoot,
     `.siteos-forms-credential.${process.pid}.${randomUUID3()}.tmp`
   );
   try {
-    await writeFile4(temporaryPath, options.content, {
+    await writeFile5(temporaryPath, options.content, {
       encoding: "utf8",
       flag: "wx",
       mode: 384
@@ -3276,25 +3721,25 @@ var ENVIRONMENT_FLAG = "--environment";
 var INSTALL_FLAG = "--install";
 var NAME_FLAG = "--name";
 var CREDENTIAL_FLAG = "--credential";
-var normalizedFieldOptionSchema = z8.object({
-  label: z8.string().trim().min(1).max(255),
-  value: z8.string().trim().min(1).max(255)
+var normalizedFieldOptionSchema = z9.object({
+  label: z9.string().trim().min(1).max(255),
+  value: z9.string().trim().min(1).max(255)
 });
-var normalizedFieldSchema = z8.object({
-  key: z8.string().trim().min(1).max(255),
-  kind: z8.string().trim().min(1).max(64).optional(),
-  label: z8.string().trim().min(1).max(255).optional(),
-  displayRole: z8.enum(["primary", "secondary"]).optional(),
-  multiple: z8.boolean().optional(),
-  options: z8.array(normalizedFieldOptionSchema).max(500).optional()
+var normalizedFieldSchema = z9.object({
+  key: z9.string().trim().min(1).max(255),
+  kind: z9.string().trim().min(1).max(64).optional(),
+  label: z9.string().trim().min(1).max(255).optional(),
+  displayRole: z9.enum(["primary", "secondary"]).optional(),
+  multiple: z9.boolean().optional(),
+  options: z9.array(normalizedFieldOptionSchema).max(500).optional()
 }).strict();
-var definitionSyncInputSchema = z8.object({
-  formKey: z8.string().trim().min(1).max(255),
-  name: z8.string().trim().min(1).max(255),
-  normalizedFieldsJson: z8.array(normalizedFieldSchema).min(1).max(500),
-  schemaJson: z8.record(z8.unknown()),
-  sourceExportId: z8.string().trim().min(1).max(255).optional(),
-  sourcePagePath: z8.string().trim().min(1).max(2048).optional()
+var definitionSyncInputSchema = z9.object({
+  formKey: z9.string().trim().min(1).max(255),
+  name: z9.string().trim().min(1).max(255),
+  normalizedFieldsJson: z9.array(normalizedFieldSchema).min(1).max(500),
+  schemaJson: z9.record(z9.unknown()),
+  sourceExportId: z9.string().trim().min(1).max(255).optional(),
+  sourcePagePath: z9.string().trim().min(1).max(2048).optional()
 }).strict().superRefine((definition, context) => {
   const ajv = new Ajv({
     allErrors: true,
@@ -3306,7 +3751,7 @@ var definitionSyncInputSchema = z8.object({
     ajv.compile(definition.schemaJson);
   } catch {
     context.addIssue({
-      code: z8.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       message: "schemaJson must be an executable JSON Schema supported by SiteOS Forms.",
       path: ["schemaJson"]
     });
@@ -3315,7 +3760,7 @@ var definitionSyncInputSchema = z8.object({
   const duplicateKeys = fields.map((field) => field.key).filter((key, index, keys) => keys.indexOf(key) !== index);
   for (const key of new Set(duplicateKeys)) {
     context.addIssue({
-      code: z8.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       message: `Field key "${key}" is registered more than once.`,
       path: ["normalizedFieldsJson"]
     });
@@ -3325,7 +3770,7 @@ var definitionSyncInputSchema = z8.object({
   );
   if (primaryFields.length !== 1) {
     context.addIssue({
-      code: z8.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       message: "Exactly one managed field must use the primary display role.",
       path: ["normalizedFieldsJson"]
     });
@@ -3333,7 +3778,7 @@ var definitionSyncInputSchema = z8.object({
   const schemaProperties = definition.schemaJson.properties;
   if (!isRecord(schemaProperties)) {
     context.addIssue({
-      code: z8.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       message: "schemaJson.properties must define the managed form fields.",
       path: ["schemaJson", "properties"]
     });
@@ -3343,7 +3788,7 @@ var definitionSyncInputSchema = z8.object({
   for (const key of Object.keys(schemaProperties)) {
     if (!metadataKeys.has(key)) {
       context.addIssue({
-        code: z8.ZodIssueCode.custom,
+        code: z9.ZodIssueCode.custom,
         message: `Schema field "${key}" is missing managed field metadata.`,
         path: ["normalizedFieldsJson"]
       });
@@ -3352,7 +3797,7 @@ var definitionSyncInputSchema = z8.object({
   for (const [index, field] of fields.entries()) {
     if (!Object.prototype.hasOwnProperty.call(schemaProperties, field.key)) {
       context.addIssue({
-        code: z8.ZodIssueCode.custom,
+        code: z9.ZodIssueCode.custom,
         message: `Managed field "${field.key}" is missing from schemaJson.properties.`,
         path: ["normalizedFieldsJson", index, "key"]
       });
@@ -3362,26 +3807,26 @@ var definitionSyncInputSchema = z8.object({
   const requiredFields = definition.schemaJson.required;
   if (primaryField && (!Array.isArray(requiredFields) || !requiredFields.includes(primaryField.key))) {
     context.addIssue({
-      code: z8.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       message: `Primary display field "${primaryField.key}" must be required by schemaJson.`,
       path: ["schemaJson", "required"]
     });
   }
 });
-var definitionManifestSchema = z8.object({
-  version: z8.literal(1),
-  forms: z8.array(z8.string().trim().min(1)).min(1)
+var definitionManifestSchema = z9.object({
+  version: z9.literal(1),
+  forms: z9.array(z9.string().trim().min(1)).min(1)
 });
-var submitInputSchema = z8.object({
-  formKey: z8.string().trim().min(1),
-  idempotencyKey: z8.string().trim().min(1),
-  ipAddress: z8.string().trim().min(1).optional(),
-  payload: z8.record(z8.unknown()),
-  sourceUrl: z8.string().trim().min(1).optional(),
-  userAgent: z8.string().trim().min(1).optional()
+var submitInputSchema = z9.object({
+  formKey: z9.string().trim().min(1),
+  idempotencyKey: z9.string().trim().min(1),
+  ipAddress: z9.string().trim().min(1).optional(),
+  payload: z9.record(z9.unknown()),
+  sourceUrl: z9.string().trim().min(1).optional(),
+  userAgent: z9.string().trim().min(1).optional()
 }).passthrough();
-var environmentNameSchema = z8.string().transform((value) => value.trim()).refine((value) => value.length >= 1 && value.length <= 255);
-var projectSlugSchema = z8.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+var environmentNameSchema = z9.string().transform((value) => value.trim()).refine((value) => value.length >= 1 && value.length <= 255);
+var projectSlugSchema = z9.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
 var FORMS_HELP = `Usage:
   siteos forms definition sync --environment <slug> --input <path> [--json]
   siteos forms definition sync --environment <slug> --manifest <path> [--json]
@@ -3396,7 +3841,7 @@ var FORMS_HELP = `Usage:
   siteos forms credential issue --environment <slug> --install [--name <name>] [--json]
   siteos forms credential rotate --environment <slug> --install [--name <name>] [--json]
   siteos forms credential revoke --environment <slug> --credential <credential-id> [--json]
-  siteos forms submissions list --environment <slug> --form <form-id> [--query <text>] [--status <status>] [--from <ISO>] [--to <ISO>] [--limit <1-100>] [--cursor <cursor>] [--json]
+  siteos forms submissions list --environment <slug> [--form <form-id>] [--query <text>] [--status <new|read|archived|spam|inbox|all>] [--purpose <regular|test|all>] [--version <id>] [--from <ISO>] [--to <ISO>] [--limit <1-100>] [--cursor <cursor>] [--json]
   siteos forms submissions read --environment <slug> --form <form-id> --submission <id> [--json]
   siteos forms submissions status --environment <slug> --form <form-id> --submission <id> --status <new|read|archived|spam> --expected-status <status> [--json]
   siteos forms deploy --manifest <path> [--json]
@@ -3404,6 +3849,7 @@ var FORMS_HELP = `Usage:
   siteos forms deployment-key list --environment <slug> [--json]
   siteos forms deployment-key revoke --environment <slug> --credential <id> [--json]
   siteos forms submit --input <path> [--json]
+${FORMS_WORKSPACE_HELP}
 
 Manage SiteOS Forms Environments, definitions, credentials, and submission smoke tests.`;
 async function runFormsCommand(options) {
@@ -3428,6 +3874,8 @@ async function runFormsCommand(options) {
     );
   if (args2[0] === "deploy")
     return runDeployment({ ...options, args: args2.slice(1) });
+  if (args2[0] === "contacts" || args2[0] === "submissions" && ["bulk", "export"].includes(args2[1] ?? ""))
+    return runFormsWorkspaceCommand({ ...options, args: args2 });
   if (args2[0] !== "submit") {
     try {
       args2 = await commonEnvironmentArguments(options, "forms", args2);
@@ -3478,7 +3926,16 @@ async function runSubmissionsCommand(options) {
       "--environment",
       "--form",
       "--json",
-      ...action === "list" ? ["--query", "--status", "--from", "--to", "--limit", "--cursor"] : [
+      ...action === "list" ? [
+        "--query",
+        "--status",
+        "--purpose",
+        "--version",
+        "--from",
+        "--to",
+        "--limit",
+        "--cursor"
+      ] : [
         "--submission",
         ...action === "status" ? ["--status", "--expected-status"] : []
       ]
@@ -3493,22 +3950,34 @@ async function runSubmissionsCommand(options) {
   const environmentSlug = value("environment");
   const formId = value("form");
   const submissionId = value("submission");
-  if (!environmentSlug || !isValidEnvironmentSlug(environmentSlug) || !formId || formId.length > 255)
+  if (!environmentSlug || !isValidEnvironmentSlug(environmentSlug) || action !== "list" && !formId || (formId?.length ?? 0) > 255)
     return usageError2("Provide a valid --environment and --form.");
   if (action !== "list" && (!submissionId || submissionId.length > 255))
     return usageError2("Provide --submission.");
-  const status = formsSubmissionStatusSchema.safeParse(value("status"));
+  const status2 = formsSubmissionStatusSchema.safeParse(value("status"));
   const expected = formsSubmissionStatusSchema.safeParse(
     value("expected-status")
   );
-  if (value("status") && !status.success || action === "status" && (!status.success || !expected.success))
+  if (value("status") && !status2.success && !(action === "list" && ["inbox", "all"].includes(value("status"))) || action === "status" && (!status2.success || !expected.success))
     return usageError2(
       "Use new, read, archived or spam for --status and --expected-status."
     );
-  const filters2 = new URLSearchParams();
-  for (const key of ["query", "status", "from", "to", "limit", "cursor"]) {
+  const filters3 = new URLSearchParams();
+  if (value("purpose") && !["regular", "test", "all"].includes(value("purpose")))
+    return usageError2("Use regular, test or all for --purpose.");
+  if (value("version")) filters3.set("versionId", value("version"));
+  for (const key of [
+    "query",
+    "status",
+    "purpose",
+    "from",
+    "to",
+    "limit",
+    "cursor"
+  ]) {
     const item = value(key);
-    if (item) filters2.set(key, item);
+    if (item && !(["status", "purpose"].includes(key) && item === "all"))
+      filters3.set(key, item);
   }
   const limit = Number(value("limit") ?? 50);
   if (!Number.isInteger(limit) || limit < 1 || limit > 100)
@@ -3516,7 +3985,7 @@ async function runSubmissionsCommand(options) {
   if ((value("query")?.length ?? 0) > 200 || (value("cursor")?.length ?? 0) > 2048)
     return usageError2("The query or cursor is too long.");
   for (const key of ["from", "to"])
-    if (value(key) && !z8.string().datetime({ offset: true }).safeParse(value(key)).success)
+    if (value(key) && !z9.string().datetime({ offset: true }).safeParse(value(key)).success)
       return usageError2(
         `--${key} must be an ISO timestamp including a timezone.`
       );
@@ -3545,13 +4014,15 @@ async function runSubmissionsCommand(options) {
       environmentId: environment.id,
       formId
     };
-    const response = action === "list" ? await context.client.listSubmissions({ ...input, filters: filters2 }) : action === "read" ? await context.client.readSubmission({
+    const response = action === "list" ? await context.client.listSubmissions({ ...input, filters: filters3 }) : action === "read" ? await context.client.readSubmission({
       ...input,
+      formId,
       submissionId
     }) : await context.client.updateSubmissionStatus({
       ...input,
+      formId,
       submissionId,
-      status: status.data,
+      status: status2.data,
       expectedStatus: expected.data
     });
     return { exitCode: 0, stdout: stringifySafeJson(response) };
@@ -3781,14 +4252,14 @@ async function runDefinitionLifecycle(options) {
   const formId = value("form");
   if (!environmentSlug || !isValidEnvironmentSlug(environmentSlug) || action !== "list" && (!formId || formId.length > 255))
     return usageError2("Provide a valid --environment and --form.");
-  const status = value("status") ?? "active";
-  if (!["active", "inactive", "all"].includes(status))
+  const status2 = value("status") ?? "active";
+  if (!["active", "inactive", "all"].includes(status2))
     return usageError2("Use active, inactive or all for --status.");
   const apply = parsed.flags.get("--apply") === true;
-  const revision = Number(value("expected-revision"));
+  const revision2 = Number(value("expected-revision"));
   const count = Number(value("expected-submissions"));
   const confirmKey = value("confirm");
-  if ((action === "archive" || action === "restore" || apply) && (!Number.isSafeInteger(revision) || revision < 1))
+  if ((action === "archive" || action === "restore" || apply) && (!Number.isSafeInteger(revision2) || revision2 < 1))
     return usageError2(
       "Read the form first, then provide its --expected-revision."
     );
@@ -3831,7 +4302,7 @@ async function runDefinitionLifecycle(options) {
         stdout: stringifySafeJson(
           await context.client.listDefinitions({
             ...input,
-            status
+            status: status2
           })
         )
       };
@@ -3864,11 +4335,11 @@ async function runDefinitionLifecycle(options) {
       change: action === "delete" ? {
         action,
         confirmKey,
-        expectedRevision: revision,
+        expectedRevision: revision2,
         expectedSubmissionCount: count
       } : {
         action,
-        expectedRevision: revision
+        expectedRevision: revision2
       }
     });
     return {
@@ -4223,7 +4694,7 @@ async function loadFormDefinitions(options) {
       ok: true
     };
   }
-  const manifestPath = path10.resolve(
+  const manifestPath = path11.resolve(
     options.cwd ?? process.cwd(),
     options.source.path
   );
@@ -4233,10 +4704,10 @@ async function loadFormDefinitions(options) {
     schema: definitionManifestSchema
   });
   if (!manifest.ok) return manifest;
-  const manifestDirectory = path10.dirname(manifestPath);
+  const manifestDirectory = path11.dirname(manifestPath);
   const definitions = [];
   for (const definitionPath of manifest.value.forms) {
-    if (path10.isAbsolute(definitionPath)) {
+    if (path11.isAbsolute(definitionPath)) {
       return {
         error: usageError2(
           `Manifest definition paths must be relative: ${definitionPath}`
@@ -4244,9 +4715,9 @@ async function loadFormDefinitions(options) {
         ok: false
       };
     }
-    const resolvedPath = path10.resolve(manifestDirectory, definitionPath);
-    const relativePath = path10.relative(manifestDirectory, resolvedPath);
-    if (relativePath.startsWith(`..${path10.sep}`) || relativePath === "..") {
+    const resolvedPath = path11.resolve(manifestDirectory, definitionPath);
+    const relativePath = path11.relative(manifestDirectory, resolvedPath);
+    if (relativePath.startsWith(`..${path11.sep}`) || relativePath === "..") {
       return {
         error: usageError2(
           `Manifest definition paths must stay inside the manifest directory: ${definitionPath}`
@@ -4309,11 +4780,11 @@ function parseInputFlags(args2, options) {
   };
 }
 async function readInputFile(options) {
-  const resolvedInputPath = path10.resolve(
+  const resolvedInputPath = path11.resolve(
     options.cwd ?? process.cwd(),
     options.inputPath
   );
-  const rawInput = await readFile5(resolvedInputPath, "utf-8").catch(
+  const rawInput = await readFile6(resolvedInputPath, "utf-8").catch(
     (error) => {
       const message = error instanceof Error ? error.message : String(error);
       return {
@@ -4612,11 +5083,11 @@ async function runDeployment(options) {
 
 // src/package-metadata.ts
 import { readFileSync } from "fs";
-import path11 from "path";
+import path12 from "path";
 import { fileURLToPath } from "url";
 function readPackageMetadata() {
-  const packageJsonPath = path11.resolve(
-    path11.dirname(fileURLToPath(import.meta.url)),
+  const packageJsonPath = path12.resolve(
+    path12.dirname(fileURLToPath(import.meta.url)),
     "..",
     "package.json"
   );
@@ -4630,8 +5101,8 @@ function readPackageMetadata() {
 }
 
 // src/pulse-command.ts
-import path22 from "path";
-import { parseArgs } from "util";
+import path23 from "path";
+import { parseArgs as parseArgs2 } from "util";
 
 // src/core/errors.ts
 function commandError2(input) {
@@ -4642,29 +5113,29 @@ function commandError2(input) {
 }
 
 // src/pulse/api-client.ts
-import { readFile as readFile6 } from "fs/promises";
-import { z as z9 } from "zod";
-var projectSchema = z9.object({
-  baseUrl: z9.string().url().nullable(),
-  checkCount: z9.number().int().min(0),
-  id: z9.string().trim().min(1).max(120),
-  name: z9.string().trim().min(1).max(120),
-  slug: z9.string().trim().min(1).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)
+import { readFile as readFile7 } from "fs/promises";
+import { z as z10 } from "zod";
+var projectSchema = z10.object({
+  baseUrl: z10.string().url().nullable(),
+  checkCount: z10.number().int().min(0),
+  id: z10.string().trim().min(1).max(120),
+  name: z10.string().trim().min(1).max(120),
+  slug: z10.string().trim().min(1).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)
 }).strict();
-var projectResponseSchema = z9.object({ project: projectSchema }).strict();
-var deploymentResponseSchema2 = z9.object({
-  checks: z9.array(
-    z9.object({
-      checkId: z9.string().min(1),
-      created: z9.boolean(),
-      deploymentId: z9.string().min(1),
-      slug: z9.string().min(1),
-      version: z9.number().int().positive()
+var projectResponseSchema = z10.object({ project: projectSchema }).strict();
+var deploymentResponseSchema2 = z10.object({
+  checks: z10.array(
+    z10.object({
+      checkId: z10.string().min(1),
+      created: z10.boolean(),
+      deploymentId: z10.string().min(1),
+      slug: z10.string().min(1),
+      version: z10.number().int().positive()
     }).strict()
   ),
-  checksum: z9.string().min(1),
-  dashboardUrl: z9.string().url().nullable().optional(),
-  projectId: z9.string().min(1)
+  checksum: z10.string().min(1),
+  dashboardUrl: z10.string().url().nullable().optional(),
+  projectId: z10.string().min(1)
 }).strict();
 function createPulseApiClient(input) {
   const fetchImpl = input.fetchImpl ?? fetch;
@@ -4724,7 +5195,7 @@ function createPulseApiClient(input) {
       );
       form.set(
         "bundle",
-        new Blob([await readFile6(options.manifest.archivePath)], {
+        new Blob([await readFile7(options.manifest.archivePath)], {
           type: "application/gzip"
         }),
         "checks-bundle.tgz"
@@ -4739,11 +5210,11 @@ function createPulseApiClient(input) {
     }
   };
 }
-function pulseApiError(body, status) {
+function pulseApiError(body, status2) {
   const payload = body;
   const candidate = payload?.error;
-  const code = candidate && typeof candidate === "object" && typeof candidate.code === "string" ? candidate.code : status === 401 ? "UNAUTHORIZED" : status === 403 ? "FORBIDDEN" : status === 404 ? "NOT_FOUND" : status === 409 ? "CONFLICT" : "API_REJECTED";
-  const message = typeof candidate === "string" ? candidate : candidate && typeof candidate === "object" && typeof candidate.message === "string" ? candidate.message : `SiteOS Pulse returned ${status}.`;
+  const code = candidate && typeof candidate === "object" && typeof candidate.code === "string" ? candidate.code : status2 === 401 ? "UNAUTHORIZED" : status2 === 403 ? "FORBIDDEN" : status2 === 404 ? "NOT_FOUND" : status2 === 409 ? "CONFLICT" : "API_REJECTED";
+  const message = typeof candidate === "string" ? candidate : candidate && typeof candidate === "object" && typeof candidate.message === "string" ? candidate.message : `SiteOS Pulse returned ${status2}.`;
   return new CliError(code, message);
 }
 
@@ -4752,18 +5223,18 @@ import { createHash as createHash6, randomUUID as randomUUID4 } from "crypto";
 import {
   access,
   mkdir as mkdir3,
-  readFile as readFile8,
+  readFile as readFile9,
   rename as rename5,
   rm as rm4,
-  writeFile as writeFile5
+  writeFile as writeFile6
 } from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 import * as tar from "tar";
 
 // src/pulse/project-files.ts
 import { createHash as createHash5 } from "crypto";
-import { lstat as lstat5, readFile as readFile7 } from "fs/promises";
-import path12 from "path";
+import { lstat as lstat5, readFile as readFile8 } from "fs/promises";
+import path13 from "path";
 import fg from "fast-glob";
 var MAX_BUNDLE_FILES = 5e3;
 var MAX_BUNDLE_BYTES = 50 * 1024 * 1024;
@@ -4786,7 +5257,7 @@ function isSensitive(relativePath) {
   return SENSITIVE_FILES.some((pattern) => pattern.test(segments.at(-1) ?? ""));
 }
 async function hashFile(filePath) {
-  return createHash5("sha256").update(await readFile7(filePath)).digest("hex");
+  return createHash5("sha256").update(await readFile8(filePath)).digest("hex");
 }
 async function discoverProjectFiles(projectRoot, config) {
   const errors = [];
@@ -4859,9 +5330,9 @@ async function discoverProjectFiles(projectRoot, config) {
       errors.push(`Sensitive path cannot be included: ${relativePath}`);
       continue;
     }
-    const absolutePath = path12.resolve(projectRoot, relativePath);
-    const relativeToRoot = path12.relative(projectRoot, absolutePath);
-    if (relativeToRoot.startsWith("..") || path12.isAbsolute(relativeToRoot)) {
+    const absolutePath = path13.resolve(projectRoot, relativePath);
+    const relativeToRoot = path13.relative(projectRoot, absolutePath);
+    if (relativeToRoot.startsWith("..") || path13.isAbsolute(relativeToRoot)) {
       errors.push(`Included path escapes the project root: ${relativePath}`);
       continue;
     }
@@ -4881,8 +5352,8 @@ async function discoverProjectFiles(projectRoot, config) {
   if (totalBytes > MAX_BUNDLE_BYTES)
     errors.push("The bundle exceeds the 50 MiB size limit.");
   try {
-    const packageSource = await readFile7(
-      path12.join(projectRoot, "package.json"),
+    const packageSource = await readFile8(
+      path13.join(projectRoot, "package.json"),
       "utf8"
     );
     const packageJson = JSON.parse(packageSource);
@@ -4904,10 +5375,10 @@ async function discoverProjectFiles(projectRoot, config) {
 
 // src/pulse/bundle.ts
 async function hashArchive(archivePath) {
-  return createHash6("sha256").update(await readFile8(archivePath)).digest("hex");
+  return createHash6("sha256").update(await readFile9(archivePath)).digest("hex");
 }
 async function createDeploymentBundle(input) {
-  const projectRoot = path13.resolve(input.projectRoot);
+  const projectRoot = path14.resolve(input.projectRoot);
   const config = await loadChecksConfig(projectRoot);
   const configFile = await findChecksConfigFile(projectRoot) ?? CONFIG_FILE;
   const report = await discoverProjectFiles(projectRoot, config);
@@ -4920,9 +5391,9 @@ async function createDeploymentBundle(input) {
       }
     );
   }
-  const outputDirectory = input.output ? path13.dirname(path13.resolve(projectRoot, input.output)) : path13.join(projectRoot, ".siteos", "pulse", "deployments");
+  const outputDirectory = input.output ? path14.dirname(path14.resolve(projectRoot, input.output)) : path14.join(projectRoot, ".siteos", "pulse", "deployments");
   await mkdir3(outputDirectory, { recursive: true });
-  const temporaryPath = path13.join(
+  const temporaryPath = path14.join(
     outputDirectory,
     `.siteos-pulse-${randomUUID4()}.tgz`
   );
@@ -4941,7 +5412,7 @@ async function createDeploymentBundle(input) {
     archiveFiles
   );
   const checksum2 = await hashArchive(temporaryPath);
-  const archivePath = input.output ? path13.resolve(projectRoot, input.output) : path13.join(outputDirectory, `siteos-pulse-${checksum2.slice(0, 16)}.tgz`);
+  const archivePath = input.output ? path14.resolve(projectRoot, input.output) : path14.join(outputDirectory, `siteos-pulse-${checksum2.slice(0, 16)}.tgz`);
   try {
     await access(archivePath);
     if (input.output) {
@@ -4971,7 +5442,7 @@ async function createDeploymentBundle(input) {
     files: report.files,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile5(
+  await writeFile6(
     `${archivePath}.json`,
     `${JSON.stringify(manifest, null, 2)}
 `,
@@ -4981,13 +5452,13 @@ async function createDeploymentBundle(input) {
 }
 
 // src/pulse/init.ts
-import { mkdir as mkdir4, readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
-import path14 from "path";
+import { mkdir as mkdir4, readFile as readFile10, writeFile as writeFile7 } from "fs/promises";
+import path15 from "path";
 var SITEOS_PLAYWRIGHT_CONFIG = "siteos.playwright.config.ts";
 var PULSE_CACHE_DIRECTORY = ".siteos/pulse/";
 async function exists(filePath) {
   try {
-    await readFile9(filePath);
+    await readFile10(filePath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -5022,7 +5493,7 @@ export default defineConfig({
 `;
 }
 async function createPulsePlaywrightConfig(input) {
-  const configPath = path14.join(input.projectRoot, SITEOS_PLAYWRIGHT_CONFIG);
+  const configPath = path15.join(input.projectRoot, SITEOS_PLAYWRIGHT_CONFIG);
   if (await exists(configPath)) {
     throw new CliError(
       "PULSE_PLAYWRIGHT_CONFIG_EXISTS",
@@ -5032,34 +5503,34 @@ async function createPulsePlaywrightConfig(input) {
       }
     );
   }
-  await writeFile6(configPath, pulsePlaywrightConfigSource(input), {
+  await writeFile7(configPath, pulsePlaywrightConfigSource(input), {
     encoding: "utf8",
     flag: "wx"
   });
 }
 async function detectPackageName(projectRoot) {
   try {
-    const contents = await readFile9(
-      path14.join(projectRoot, "package.json"),
+    const contents = await readFile10(
+      path15.join(projectRoot, "package.json"),
       "utf8"
     );
     const parsed = JSON.parse(contents);
-    return typeof parsed.name === "string" ? parsed.name : path14.basename(projectRoot);
+    return typeof parsed.name === "string" ? parsed.name : path15.basename(projectRoot);
   } catch {
-    return path14.basename(projectRoot);
+    return path15.basename(projectRoot);
   }
 }
 async function ensureGitignore(projectRoot) {
-  const gitignorePath = path14.join(projectRoot, ".gitignore");
+  const gitignorePath = path15.join(projectRoot, ".gitignore");
   let contents = "";
   try {
-    contents = await readFile9(gitignorePath, "utf8");
+    contents = await readFile10(gitignorePath, "utf8");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
   if (contents.split(/\r?\n/).includes(PULSE_CACHE_DIRECTORY)) return false;
   const prefix = contents.length > 0 && !contents.endsWith("\n") ? "\n" : "";
-  await writeFile6(
+  await writeFile7(
     gitignorePath,
     `${contents}${prefix}${PULSE_CACHE_DIRECTORY}
 `,
@@ -5068,21 +5539,21 @@ async function ensureGitignore(projectRoot) {
   return true;
 }
 async function initializeProject(input) {
-  const projectRoot = path14.resolve(input.projectRoot);
+  const projectRoot = path15.resolve(input.projectRoot);
   const existingConfig = await findChecksConfigFile(projectRoot);
   if (existingConfig) {
     throw new CliError("CONFIG_EXISTS", `${existingConfig} already exists.`, {
       hint: "Edit the existing file or run `siteos pulse validate`."
     });
   }
-  const configPath = path14.join(projectRoot, CONFIG_FILE);
+  const configPath = path15.join(projectRoot, CONFIG_FILE);
   const created = [];
   const updated = [];
   const testsDir = input.testsDir ?? "tests/siteos";
   const packageName2 = await detectPackageName(projectRoot);
   const projectName = projectDisplayName(input.project ?? packageName2);
   const checkSlug = projectSlug(input.suite ?? "homepage");
-  const exampleTest = path14.posix.join(
+  const exampleTest = path15.posix.join(
     testsDir.replaceAll("\\", "/"),
     `${checkSlug}.spec.ts`
   );
@@ -5119,11 +5590,11 @@ async function initializeProject(input) {
     baseUrl: input.baseUrl
   });
   created.push(SITEOS_PLAYWRIGHT_CONFIG);
-  const testDirectory = path14.join(projectRoot, testsDir);
+  const testDirectory = path15.join(projectRoot, testsDir);
   await mkdir4(testDirectory, { recursive: true });
-  if (!await exists(path14.join(projectRoot, exampleTest))) {
-    await writeFile6(
-      path14.join(projectRoot, exampleTest),
+  if (!await exists(path15.join(projectRoot, exampleTest))) {
+    await writeFile7(
+      path15.join(projectRoot, exampleTest),
       `import { expect, test } from "@playwright/test";
 
 test(${JSON.stringify(`${projectDisplayName(input.suite ?? "homepage")} is reachable`)}, async ({ page }) => {
@@ -5135,7 +5606,7 @@ test(${JSON.stringify(`${projectDisplayName(input.suite ?? "homepage")} is reach
     );
     created.push(exampleTest);
   }
-  await writeFile6(configPath, `${JSON.stringify(config, null, 2)}
+  await writeFile7(configPath, `${JSON.stringify(config, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx"
@@ -5149,14 +5620,14 @@ test(${JSON.stringify(`${projectDisplayName(input.suite ?? "homepage")} is reach
 import fg4 from "fast-glob";
 
 // src/pulse/interactive/discovery.ts
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 import { createRequire } from "module";
-import path16 from "path";
+import path17 from "path";
 import fg2 from "fast-glob";
 
 // src/pulse/interactive/playwright-config.ts
-import { readFile as readFile10 } from "fs/promises";
-import path15 from "path";
+import { readFile as readFile11 } from "fs/promises";
+import path16 from "path";
 
 // src/pulse/interactive/discovery.ts
 var PLAYWRIGHT_SPEC_PATTERN = "**/*.{spec,test}.{js,cjs,mjs,ts,cts,mts,jsx,tsx}";
@@ -5201,11 +5672,11 @@ async function discoverPlaywrightSelectorMatches(projectRoot, selectors, testsDi
 }
 
 // src/pulse/sync-plan.ts
-import path17 from "path";
+import path18 from "path";
 import fg3 from "fast-glob";
 var PLAYWRIGHT_SPEC_FILE = /\.(?:spec|test)\.(?:[cm]?[jt]sx?)$/;
 function defaultNameFromSpec(specPath) {
-  const basename = path17.posix.basename(specPath).replace(/\.(?:spec|test)\.[^.]+$/, "");
+  const basename = path18.posix.basename(specPath).replace(/\.(?:spec|test)\.[^.]+$/, "");
   return basename.split(/[^A-Za-z0-9]+/).filter(Boolean).map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1)}`).join(" ") || "Smoke";
 }
 function normalizedPaths(paths) {
@@ -5263,8 +5734,8 @@ function buildSyncPlan(input) {
 
 // src/pulse/test-imports.ts
 import { builtinModules } from "module";
-import { readFile as readFile12 } from "fs/promises";
-import path18 from "path";
+import { readFile as readFile13 } from "fs/promises";
+import path19 from "path";
 import { build } from "esbuild";
 var ALLOWED_PACKAGES = /* @__PURE__ */ new Set(["@playwright/test"]);
 var BUILTINS = /* @__PURE__ */ new Set([
@@ -5278,9 +5749,9 @@ function packageName(importPath) {
   return importPath.split("/")[0] ?? importPath;
 }
 function normalizedRelativePath(projectRoot, inputPath) {
-  const absolute = path18.isAbsolute(inputPath) ? inputPath : path18.resolve(projectRoot, inputPath);
-  const relative = path18.relative(projectRoot, absolute).replaceAll("\\", "/");
-  if (!relative || relative.startsWith("../") || path18.isAbsolute(relative)) {
+  const absolute = path19.isAbsolute(inputPath) ? inputPath : path19.resolve(projectRoot, inputPath);
+  const relative = path19.relative(projectRoot, absolute).replaceAll("\\", "/");
+  if (!relative || relative.startsWith("../") || path19.isAbsolute(relative)) {
     throw new CliError(
       "IMPORT_OUTSIDE_PROJECT",
       `A selected test imports outside the project: ${inputPath}`
@@ -5289,7 +5760,7 @@ function normalizedRelativePath(projectRoot, inputPath) {
   return relative;
 }
 async function analyzeTestImports(input) {
-  const projectRoot = path18.resolve(input.projectRoot);
+  const projectRoot = path19.resolve(input.projectRoot);
   const entryFiles = [
     ...new Set(
       input.entryFiles.map((file) => normalizedRelativePath(projectRoot, file))
@@ -5319,7 +5790,7 @@ async function analyzeTestImports(input) {
       }
     );
   }
-  const inputs = Object.keys(result.metafile?.inputs ?? {}).map(
+  const inputs2 = Object.keys(result.metafile?.inputs ?? {}).map(
     (file) => normalizedRelativePath(projectRoot, file)
   );
   const entrySet = new Set(entryFiles);
@@ -5347,8 +5818,8 @@ async function analyzeTestImports(input) {
   const environmentVariables = /* @__PURE__ */ new Set();
   const compatibilityIssues = /* @__PURE__ */ new Set();
   await Promise.all(
-    inputs.map(async (file) => {
-      const source = await readFile12(path18.join(projectRoot, file), "utf8").catch(
+    inputs2.map(async (file) => {
+      const source = await readFile13(path19.join(projectRoot, file), "utf8").catch(
         () => ""
       );
       for (const match of source.matchAll(ENVIRONMENT_PATTERN)) {
@@ -5365,7 +5836,7 @@ async function analyzeTestImports(input) {
     })
   );
   return {
-    supportingFiles: inputs.filter((file) => !entrySet.has(file)).sort(),
+    supportingFiles: inputs2.filter((file) => !entrySet.has(file)).sort(),
     externalPackages: [...externalPackages].sort(),
     externalImporters: Object.fromEntries(
       [...externalImporters.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([dependency, importers]) => [dependency, [...importers].sort()])
@@ -5791,12 +6262,12 @@ async function runSyncCli(input) {
 // src/pulse/playwright.ts
 import { spawn as spawn3 } from "child_process";
 import { createRequire as createRequire2 } from "module";
-import path20 from "path";
+import path21 from "path";
 
 // src/pulse/package-manager.ts
 import { spawn as spawn2 } from "child_process";
-import { access as access2, readFile as readFile13 } from "fs/promises";
-import path19 from "path";
+import { access as access2, readFile as readFile14 } from "fs/promises";
+import path20 from "path";
 var LOCKFILES = [
   { packageManager: "pnpm", filenames: ["pnpm-lock.yaml"] },
   { packageManager: "yarn", filenames: ["yarn.lock"] },
@@ -5818,7 +6289,7 @@ async function fileExists2(filePath) {
 async function declaredPackageManager(projectRoot) {
   let contents;
   try {
-    contents = await readFile13(path19.join(projectRoot, "package.json"), "utf8");
+    contents = await readFile14(path20.join(projectRoot, "package.json"), "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -5855,7 +6326,7 @@ async function declaredPackageManager(projectRoot) {
   );
 }
 async function detectPackageManager(projectRoot) {
-  const root = path19.resolve(projectRoot);
+  const root = path20.resolve(projectRoot);
   const declared = await declaredPackageManager(root);
   if (declared) return declared;
   const matches = (await Promise.all(
@@ -5864,7 +6335,7 @@ async function detectPackageManager(projectRoot) {
       filenames: (await Promise.all(
         filenames2.map(async (filename) => ({
           filename,
-          exists: await fileExists2(path19.join(root, filename))
+          exists: await fileExists2(path20.join(root, filename))
         }))
       )).filter((entry) => entry.exists).map((entry) => entry.filename)
     }))
@@ -5925,12 +6396,12 @@ function isMissingBrowserDiagnostic(output) {
 function resolvePlaywrightCli(projectRoot) {
   try {
     const requireFromProject = createRequire2(
-      path20.join(projectRoot, "package.json")
+      path21.join(projectRoot, "package.json")
     );
     const packageJson = requireFromProject.resolve(
       "@playwright/test/package.json"
     );
-    return path20.join(path20.dirname(packageJson), "cli.js");
+    return path21.join(path21.dirname(packageJson), "cli.js");
   } catch {
     throw new CliError(
       "PLAYWRIGHT_NOT_INSTALLED",
@@ -5942,7 +6413,7 @@ function resolvePlaywrightCli(projectRoot) {
   }
 }
 async function runProjectTests(input) {
-  const projectRoot = path20.resolve(input.projectRoot);
+  const projectRoot = path21.resolve(input.projectRoot);
   const config = await loadChecksConfig(projectRoot);
   const report = await discoverProjectFiles(projectRoot, config);
   if (!report.valid) {
@@ -5999,9 +6470,9 @@ async function runProjectTests(input) {
 }
 
 // src/pulse/validate.ts
-import path21 from "path";
+import path22 from "path";
 async function validateProject(projectRoot) {
-  const root = path21.resolve(projectRoot);
+  const root = path22.resolve(projectRoot);
   const config = await loadChecksConfig(root);
   return discoverProjectFiles(root, config);
 }
@@ -6034,7 +6505,7 @@ async function runPulseCommand(options) {
   }
 }
 async function runInitCommand(options, args2) {
-  const { values } = parseArgs({
+  const { values } = parseArgs2({
     args: args2,
     options: {
       "base-url": { type: "string" },
@@ -6063,7 +6534,7 @@ async function runInitCommand(options, args2) {
   };
 }
 async function runValidateCommand(options, args2) {
-  const { values } = parseArgs({
+  const { values } = parseArgs2({
     args: args2,
     options: { json: { default: false, type: "boolean" } },
     strict: true
@@ -6075,7 +6546,7 @@ async function runValidateCommand(options, args2) {
   };
 }
 async function runSyncCommand(options, args2) {
-  const { values } = parseArgs({
+  const { values } = parseArgs2({
     args: args2,
     options: {
       check: { default: false, type: "boolean" },
@@ -6108,7 +6579,7 @@ async function runTestCommand(options, args2) {
   const separator = args2.indexOf("--");
   const commandArgs = separator === -1 ? args2 : args2.slice(0, separator);
   const passthrough = separator === -1 ? [] : args2.slice(separator + 1);
-  const { values } = parseArgs({
+  const { values } = parseArgs2({
     args: commandArgs,
     options: {
       "base-url": { type: "string" },
@@ -6142,7 +6613,7 @@ async function optionalProjectContext(options) {
   return context;
 }
 async function runDeployCommand(options, args2) {
-  const { values } = parseArgs({
+  const { values } = parseArgs2({
     args: args2,
     options: {
       "dry-run": { default: false, type: "boolean" },
@@ -6151,7 +6622,7 @@ async function runDeployCommand(options, args2) {
     },
     strict: true
   });
-  const projectRoot = path22.resolve(options.cwd ?? process.cwd());
+  const projectRoot = path23.resolve(options.cwd ?? process.cwd());
   const repositoryRoot = await findRepositoryRoot(projectRoot);
   const common = await commonServiceContext(options, "pulse");
   if (common && (!common.environmentBinding?.slug || !common.environment.url))
@@ -6175,7 +6646,7 @@ async function runDeployCommand(options, args2) {
       values.json,
       { dryRun: true, manifest },
       [
-        `Bundle: ${path22.relative(projectRoot, manifest.archivePath)}`,
+        `Bundle: ${path23.relative(projectRoot, manifest.archivePath)}`,
         `Checksum: ${manifest.checksum}`,
         `Files: ${manifest.fileCount}`,
         "Dry run complete; nothing was uploaded."
@@ -6217,7 +6688,7 @@ async function runDeployCommand(options, args2) {
     values.json,
     { deployment, dryRun: false, manifest },
     [
-      `Bundle: ${path22.relative(projectRoot, manifest.archivePath)}`,
+      `Bundle: ${path23.relative(projectRoot, manifest.archivePath)}`,
       `Checksum: ${manifest.checksum}`,
       `Files: ${manifest.fileCount}`,
       `Project ${deployment.projectId} deployed.`,
@@ -6357,63 +6828,63 @@ function exitCodeForPulseError(error) {
 }
 
 // src/siteos-search-api.ts
-import { z as z10 } from "zod";
-var permissiveObjectSchema = z10.record(z10.unknown());
-var environmentSlugSchema = z10.string().min(2).max(30).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
-var searchCredentialMetadataSchema = z10.object({
-  createdAt: z10.string().datetime({ offset: true }),
-  id: z10.string().trim().min(1).max(255),
-  lastUsedAt: z10.string().datetime({ offset: true }).nullable(),
-  name: z10.string().trim().min(1).max(255),
-  projectEnvironmentId: z10.string().trim().min(1).max(255),
-  revokedAt: z10.string().datetime({ offset: true }).nullable(),
-  status: z10.enum(["active", "revoked"])
+import { z as z11 } from "zod";
+var permissiveObjectSchema = z11.record(z11.unknown());
+var environmentSlugSchema = z11.string().min(2).max(30).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+var searchCredentialMetadataSchema = z11.object({
+  createdAt: z11.string().datetime({ offset: true }),
+  id: z11.string().trim().min(1).max(255),
+  lastUsedAt: z11.string().datetime({ offset: true }).nullable(),
+  name: z11.string().trim().min(1).max(255),
+  projectEnvironmentId: z11.string().trim().min(1).max(255),
+  revokedAt: z11.string().datetime({ offset: true }).nullable(),
+  status: z11.enum(["active", "revoked"])
 }).strict();
-var searchCredentialListResponseSchema = z10.object({
+var searchCredentialListResponseSchema = z11.object({
   environmentSlug: environmentSlugSchema,
-  success: z10.literal(true),
-  tokens: z10.array(searchCredentialMetadataSchema)
+  success: z11.literal(true),
+  tokens: z11.array(searchCredentialMetadataSchema)
 }).strict();
-var searchCredentialExchangeResponseSchema = z10.object({
+var searchCredentialExchangeResponseSchema = z11.object({
   environmentSlug: environmentSlugSchema,
-  success: z10.literal(true),
+  success: z11.literal(true),
   token: searchCredentialMetadataSchema.extend({
-    token: z10.string().regex(/^psq_[A-Za-z0-9_-]{22}$/)
+    token: z11.string().regex(/^psq_[A-Za-z0-9_-]{22}$/)
   })
 }).strict();
-var searchCredentialRevokeResponseSchema = z10.object({
+var searchCredentialRevokeResponseSchema = z11.object({
   environmentSlug: environmentSlugSchema,
-  success: z10.literal(true),
+  success: z11.literal(true),
   token: searchCredentialMetadataSchema
 }).strict();
-var searchIndexingCredentialListResponseSchema = z10.object({
-  credentials: z10.array(searchCredentialMetadataSchema),
+var searchIndexingCredentialListResponseSchema = z11.object({
+  credentials: z11.array(searchCredentialMetadataSchema),
   environmentSlug: environmentSlugSchema,
-  success: z10.literal(true)
+  success: z11.literal(true)
 }).strict();
-var searchIndexingCredentialExchangeResponseSchema = z10.object({
+var searchIndexingCredentialExchangeResponseSchema = z11.object({
   credential: searchCredentialMetadataSchema.extend({
-    credential: z10.string().regex(/^psi_[A-Za-z0-9_-]{22}$/)
+    credential: z11.string().regex(/^psi_[A-Za-z0-9_-]{22}$/)
   }).strict(),
   environmentSlug: environmentSlugSchema,
-  success: z10.literal(true)
+  success: z11.literal(true)
 }).strict();
-var searchIndexingCredentialRevokeResponseSchema = z10.object({
+var searchIndexingCredentialRevokeResponseSchema = z11.object({
   credential: searchCredentialMetadataSchema,
   environmentSlug: environmentSlugSchema,
-  success: z10.literal(true)
+  success: z11.literal(true)
 }).strict();
-var nestedApiErrorResponseSchema = z10.object({
-  error: z10.object({
-    code: z10.string().trim().min(1).optional(),
-    message: z10.string().trim().min(1),
-    nextActions: z10.array(z10.string()).optional()
+var nestedApiErrorResponseSchema = z11.object({
+  error: z11.object({
+    code: z11.string().trim().min(1).optional(),
+    message: z11.string().trim().min(1),
+    nextActions: z11.array(z11.string()).optional()
   })
 }).passthrough();
-var directApiErrorResponseSchema = z10.object({
-  code: z10.string().trim().min(1).optional(),
-  message: z10.string().trim().min(1).optional(),
-  status: z10.number().int().optional()
+var directApiErrorResponseSchema = z11.object({
+  code: z11.string().trim().min(1).optional(),
+  message: z11.string().trim().min(1).optional(),
+  status: z11.number().int().optional()
 }).passthrough();
 var SiteOSSearchApiError = class extends Error {
   code;
@@ -6683,12 +7154,12 @@ import { randomUUID as randomUUID5 } from "crypto";
 import {
   chmod as chmod4,
   lstat as lstat6,
-  readFile as readFile14,
+  readFile as readFile15,
   rename as rename6,
   rm as rm5,
-  writeFile as writeFile7
+  writeFile as writeFile8
 } from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 var SITEOS_SEARCH_QUERY_CREDENTIAL_ENV = "SITEOS_SEARCH_TOKEN";
 var SITEOS_SEARCH_ENVIRONMENT_ENV = "SITEOS_SEARCH_ENV";
 var SITEOS_SEARCH_INDEXING_CREDENTIAL_ENV = "SITEOS_SEARCH_INDEXING_CREDENTIAL";
@@ -6706,8 +7177,8 @@ var SiteOSSearchCredentialStorageError = class extends Error {
   }
 };
 async function prepareSiteOSSearchCredentialInstallation(options) {
-  const projectRoot = path23.resolve(options.projectRoot);
-  const dotenvPath = path23.join(projectRoot, ".env");
+  const projectRoot = path24.resolve(options.projectRoot);
+  const dotenvPath = path24.join(projectRoot, ".env");
   try {
     await assertSafeProjectRoot2(projectRoot);
     if (!await isDotenvIgnored2(projectRoot)) {
@@ -6765,8 +7236,8 @@ async function prepareSiteOSSearchCredentialInstallation(options) {
   }
 }
 async function prepareSiteOSSearchIndexingCredentialInstallation(options) {
-  const projectRoot = path23.resolve(options.projectRoot);
-  const dotenvPath = path23.join(projectRoot, ".env");
+  const projectRoot = path24.resolve(options.projectRoot);
+  const dotenvPath = path24.join(projectRoot, ".env");
   try {
     await assertSafeProjectRoot2(projectRoot);
     if (!await isDotenvIgnored2(projectRoot)) {
@@ -6842,7 +7313,7 @@ async function readSafeDotenv2(dotenvPath, managedEnvironmentNames) {
       "SEARCH_CREDENTIAL_STORAGE_INVALID"
     );
   }
-  const content = dotenvStats ? await readFile14(dotenvPath, "utf8") : "";
+  const content = dotenvStats ? await readFile15(dotenvPath, "utf8") : "";
   if (managedEnvironmentNames.some(
     (name) => countManagedEntries(content, name) > 1
   )) {
@@ -6853,12 +7324,12 @@ async function readSafeDotenv2(dotenvPath, managedEnvironmentNames) {
   return content;
 }
 async function writeCredentialAtomically2(options) {
-  const temporaryPath = path23.join(
+  const temporaryPath = path24.join(
     options.projectRoot,
     `.siteos-search-credential.${process.pid}.${randomUUID5()}.tmp`
   );
   try {
-    await writeFile7(temporaryPath, options.content, {
+    await writeFile8(temporaryPath, options.content, {
       encoding: "utf8",
       flag: "wx",
       mode: 384
@@ -7562,7 +8033,7 @@ ${SEARCH_HELP}` };
 }
 
 // src/projects/project-command.ts
-import { parseArgs as parseArgs2 } from "util";
+import { parseArgs as parseArgs3 } from "util";
 var PROJECT_HELP = `One Project for your website and all its services.
 
 Usage:
@@ -7593,7 +8064,7 @@ async function runProjectCommand(options) {
       action
     ))
       throw new Error("Unknown Project command.");
-    const parsed = parseArgs2({
+    const parsed = parseArgs3({
       args: args2,
       allowPositionals: true,
       strict: true,
@@ -7717,7 +8188,7 @@ async function runEnvironmentCommand(options) {
     action
   ))
     throw new Error("Unknown Project environment command.");
-  const { positionals, values } = parseArgs2({
+  const { positionals, values } = parseArgs3({
     args: args2,
     allowPositionals: true,
     strict: true,
@@ -7824,14 +8295,14 @@ async function runEnvironmentCommand(options) {
 }
 
 // src/services/service-command.ts
-import { readFile as readFile15, stat } from "fs/promises";
-import path24 from "path";
-import { parseArgs as parseArgs3 } from "util";
-import { z as z13 } from "zod";
+import { readFile as readFile16, stat } from "fs/promises";
+import path25 from "path";
+import { parseArgs as parseArgs4 } from "util";
+import { z as z14 } from "zod";
 
 // src/services/trace-explorer-command.ts
-import { z as z11 } from "zod";
-var filters = [
+import { z as z12 } from "zod";
+var filters2 = [
   "environment",
   "provider",
   "event",
@@ -7850,16 +8321,16 @@ var TRACE_EXPLORER_FLAGS = {
   "ga4 show": ["environment"],
   "notifications show": ["environment"],
   "notifications destinations": ["environment", "cursor"],
-  destinations: filters,
-  events: filters,
-  properties: filters,
-  issues: [...filters, "container-id", "tag-id"],
-  observations: [...filters, "container-id", "tag-id", "result"],
+  destinations: filters2,
+  events: filters2,
+  properties: filters2,
+  issues: [...filters2, "container-id", "tag-id"],
+  observations: [...filters2, "container-id", "tag-id", "result"],
   "issue show": ["environment", "id", "cursor"],
   "observation show": ["environment", "batch-id", "event-id"]
 };
-var FilterValues = z11.object({
-  provider: z11.enum([
+var FilterValues = z12.object({
+  provider: z12.enum([
     "siteos_analytics",
     "ga4",
     "google_ads",
@@ -7867,12 +8338,12 @@ var FilterValues = z11.object({
     "meta",
     "custom"
   ]).optional(),
-  event: z11.string().min(1).max(160).optional(),
-  property: z11.string().min(1).max(160).optional(),
-  "page-view": z11.string().uuid().optional(),
-  "container-id": z11.string().regex(/^GTM-[A-Z0-9]{4,20}$/u).optional(),
-  "tag-id": z11.string().regex(/^[0-9]{1,20}$/u).optional(),
-  result: z11.enum([
+  event: z12.string().min(1).max(160).optional(),
+  property: z12.string().min(1).max(160).optional(),
+  "page-view": z12.string().uuid().optional(),
+  "container-id": z12.string().regex(/^GTM-[A-Z0-9]{4,20}$/u).optional(),
+  "tag-id": z12.string().regex(/^[0-9]{1,20}$/u).optional(),
+  result: z12.enum([
     "success",
     "failure",
     "exception",
@@ -7885,8 +8356,8 @@ var FilterValues = z11.object({
     "beacon_accepted",
     "result_unknown"
   ]).optional(),
-  search: z11.string().max(160).optional(),
-  state: z11.enum([
+  search: z12.string().max(160).optional(),
+  state: z12.enum([
     "all",
     "active",
     "snoozed",
@@ -7896,8 +8367,8 @@ var FilterValues = z11.object({
     "tracked",
     "ignored"
   ]).optional(),
-  rule: z11.string().min(1).max(80).optional(),
-  kind: z11.enum([
+  rule: z12.string().min(1).max(80).optional(),
+  kind: z12.enum([
     "tag_execution",
     "data_layer",
     "fetch",
@@ -7908,8 +8379,8 @@ var FilterValues = z11.object({
     "heartbeat",
     "runtime_diagnostic"
   ]).optional(),
-  period: z11.enum(["24h", "7d"]).optional(),
-  cursor: z11.string().min(1).max(4096).optional()
+  period: z12.enum(["24h", "7d"]).optional(),
+  cursor: z12.string().min(1).max(4096).optional()
 });
 function traceExplorerSuffix(route, values) {
   if (!TRACE_EXPLORER_FLAGS[route]) return null;
@@ -7919,11 +8390,11 @@ function traceExplorerSuffix(route, values) {
     for (const key of keys) {
       const value = values[key];
       const plain = key === "id" && typeof value === "string" ? value.replace(/^trc_incident_/u, "") : value;
-      if (!z11.string().uuid().safeParse(plain).success)
+      if (!z12.string().uuid().safeParse(plain).success)
         throw new Error(`Use --${key} with the UUID returned by Trace.`);
     }
     if (values.cursor !== void 0) {
-      if (!z11.string().uuid().safeParse(
+      if (!z12.string().uuid().safeParse(
         typeof values.cursor === "string" ? values.cursor.replace(/^trc_finding_/u, "") : values.cursor
       ).success)
         throw new Error(
@@ -8047,7 +8518,7 @@ async function runServiceCommand(service, options) {
   if (!options.args.length || options.args.includes("--help") || options.args.includes("-h"))
     return { exitCode: 0, stdout: SERVICE_HELP[service] };
   try {
-    const { positionals, values } = parseArgs3({
+    const { positionals, values } = parseArgs4({
       args: options.args,
       allowPositionals: true,
       strict: true,
@@ -8195,8 +8666,8 @@ async function runServiceCommand(service, options) {
       );
       const result2 = await response.json();
       if (!response.ok) {
-        const error = z13.object({
-          error: z13.object({ code: z13.string(), message: z13.string().max(500) })
+        const error = z14.object({
+          error: z14.object({ code: z14.string(), message: z14.string().max(500) })
         }).safeParse(result2);
         throw new SiteOSAuthApiError({
           code: error.success ? error.data.error.code : "SERVICE_REQUEST_FAILED",
@@ -8209,11 +8680,11 @@ async function runServiceCommand(service, options) {
     async function inputFile() {
       if (!values.input)
         throw new Error("This operation requires --input <json-file>.");
-      const filename = path24.resolve(options.cwd ?? process.cwd(), values.input);
+      const filename = path25.resolve(options.cwd ?? process.cwd(), values.input);
       const info = await stat(filename);
       if (!info.isFile() || info.size > 512 * 1024)
         throw new Error("Use a JSON file smaller than 512 KB.");
-      return JSON.parse(await readFile15(filename, "utf8"));
+      return JSON.parse(await readFile16(filename, "utf8"));
     }
     const site = common ? `/sites/${encodeURIComponent(common.resourceId)}` : "";
     let result;
@@ -8233,9 +8704,9 @@ async function runServiceCommand(service, options) {
           await inputFile(),
           "cookie:workspace:read"
         );
-        const validation = z13.object({
-          valid: z13.boolean(),
-          draftVersionMatches: z13.boolean().optional()
+        const validation = z14.object({
+          valid: z14.boolean(),
+          draftVersionMatches: z14.boolean().optional()
         }).parse(result);
         if (!validation.valid || validation.draftVersionMatches === false)
           return { exitCode: 2, stdout: JSON.stringify(result, null, 2) };
@@ -8274,11 +8745,11 @@ async function runServiceCommand(service, options) {
       } else if (action === "installation")
         result = await request(`${site}/installation`);
       else if (action === "draft" && subaction === "get" && positionals.length === 2) {
-        const response = z13.object({
-          name: z13.string(),
-          hostname: z13.string(),
-          draftVersion: z13.number(),
-          draft: z13.unknown()
+        const response = z14.object({
+          name: z14.string(),
+          hostname: z14.string(),
+          draftVersion: z14.number(),
+          draft: z14.unknown()
         }).parse(await request(site));
         result = {
           name: response.name,
@@ -8310,9 +8781,9 @@ async function runServiceCommand(service, options) {
       else if (action === "environments" && positionals.length === 1)
         result = await request(`${site}/environments`);
       else if (action === "ga4" || action === "notifications" || action === "schema" || action === "report" || action === "installation" || action === "tracking-plan" || explorerSuffix !== null) {
-        const response = z13.object({
-          environments: z13.array(
-            z13.object({ id: z13.string(), slug: z13.string() })
+        const response = z14.object({
+          environments: z14.array(
+            z14.object({ id: z14.string(), slug: z14.string() })
           )
         }).parse(await request(`${site}/environments`));
         const environment = common.overview.project.environments.find(
@@ -8351,11 +8822,11 @@ async function runServiceCommand(service, options) {
             await inputFile()
           );
         } else if (action === "report" && positionals.length === 1) {
-          const detail = z13.object({
-            site: z13.object({
-              id: z13.literal(common.resourceId),
-              environments: z13.array(
-                z13.object({ id: z13.string(), evidence: z13.unknown() })
+          const detail = z14.object({
+            site: z14.object({
+              id: z14.literal(common.resourceId),
+              environments: z14.array(
+                z14.object({ id: z14.string(), evidence: z14.unknown() })
               )
             })
           }).parse(await request(site));
@@ -8413,35 +8884,35 @@ async function runServiceCommand(service, options) {
   } catch (cause) {
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
-      stderr: cause instanceof SiteOSAuthApiError || !(cause instanceof z13.ZodError) && cause instanceof Error ? cause.message : "The service returned an invalid response."
+      stderr: cause instanceof SiteOSAuthApiError || !(cause instanceof z14.ZodError) && cause instanceof Error ? cause.message : "The service returned an invalid response."
     };
   }
 }
 
 // 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()) })
+import { z as z15 } from "zod";
+var table = z15.object({
+  dimensions: z15.array(z15.string()),
+  metrics: z15.array(z15.object({ name: z15.string() })),
+  rows: z15.array(
+    z15.object({ dimensions: z15.array(z15.string()), metrics: z15.array(z15.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()
+  const report = z15.object({
+    request: z15.object({
+      kind: z15.string(),
+      propertyId: z15.string(),
+      streamId: z15.string(),
+      startDate: z15.string(),
+      endDate: z15.string(),
+      filters: z15.array(z15.unknown()),
+      minuteRange: z15.unknown().optional(),
+      comparison: z15.object({ startDate: z15.string(), endDate: z15.string() }).optional()
     }).passthrough(),
-    timeZone: z14.string(),
-    limitations: z14.array(z14.string()),
-    quality: z14.unknown(),
+    timeZone: z15.string(),
+    limitations: z15.array(z15.string()),
+    quality: z15.unknown(),
     table,
     previous: table.optional()
   }).parse(value);
@@ -8480,10 +8951,10 @@ function googleReportCsv(value, fetchedAt) {
 }
 
 // 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 z15 } from "zod";
+import { readFile as readFile17, stat as stat2 } from "fs/promises";
+import path26 from "path";
+import { parseArgs as parseArgs5 } from "util";
+import { z as z16 } from "zod";
 var GOOGLE_ANALYTICS_HELP = `Read GA4 reports in the selected Project environment.
 
 Usage:
@@ -8505,7 +8976,7 @@ async function runAnalyticsGoogleCommand(options) {
   if (options.args.length <= 1 || options.args.includes("--help"))
     return { exitCode: 0, stdout: GOOGLE_ANALYTICS_HELP };
   try {
-    const { values, positionals } = parseArgs4({
+    const { values, positionals } = parseArgs5({
       args: options.args.slice(1),
       allowPositionals: true,
       strict: true,
@@ -8590,8 +9061,8 @@ async function runAnalyticsGoogleCommand(options) {
       );
       const value = await response.json();
       if (!response.ok) {
-        const error = z15.object({
-          error: z15.object({ code: z15.string(), message: z15.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",
@@ -8599,31 +9070,31 @@ async function runAnalyticsGoogleCommand(options) {
           status: response.status
         });
       }
-      return z15.object({
-        contractVersion: z15.literal(1),
-        resourceId: z15.literal(context.resourceId)
+      return z16.object({
+        contractVersion: z16.literal(1),
+        resourceId: z16.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);
+      const name = path26.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");
+      const text = await readFile17(name, "utf8");
       if (Buffer.byteLength(text) > 16384)
         throw new Error("Definition exceeds 16 KiB.");
-      return z15.record(z15.unknown()).parse(JSON.parse(text));
+      return z16.record(z16.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))
+        id: z16.string().uuid().parse(positionals[2]),
+        revision: z16.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);
+      const binding = z16.object({ revision: z16.number().int().positive(), state: z16.string() }).parse(base.binding);
       if (binding.state === "disconnected")
         throw new Error("Connect GA4 in Analytics Setup first.");
       if (action === "report") {
@@ -8656,16 +9127,16 @@ async function runAnalyticsGoogleCommand(options) {
           result = await send(`?${params}`);
         }
       } else if (action === "realtime") {
-        const filters2 = values.filters ? JSON.parse(values.filters) : [];
+        const filters3 = values.filters ? JSON.parse(values.filters) : [];
         const params = new URLSearchParams({
-          filters: JSON.stringify(filters2)
+          filters: JSON.stringify(filters3)
         });
         result = await send(`/realtime?${params}`);
         const live = result.realtime;
         if (!live?.report || live.stale) {
           await send("/realtime", "POST", {
             revision: binding.revision,
-            filters: filters2
+            filters: filters3
           });
           result = await send(`/realtime?${params}`);
         }
@@ -8699,7 +9170,7 @@ async function runAnalyticsGoogleCommand(options) {
   } 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."
+      message: cause instanceof z16.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,
@@ -8709,10 +9180,10 @@ async function runAnalyticsGoogleCommand(options) {
 }
 
 // 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";
+import { readFile as readFile18, stat as stat3 } from "fs/promises";
+import path27 from "path";
+import { parseArgs as parseArgs6 } from "util";
+import { z as z17 } from "zod";
 var ANALYTICS_HELP = `Set up website Analytics in the selected Project environment.
 
 Usage:
@@ -8744,27 +9215,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 = 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)
+var EventInput = z17.object({
+  name: z17.string().regex(/^[a-z][a-z0-9_]{0,63}$/u).refine((v) => v !== "pageview" && !v.startsWith("cookie_")),
+  label: z17.string().trim().min(1).max(80),
+  properties: z17.record(
+    z17.string().regex(/^[a-z][a-z0-9_]{0,39}$/u),
+    z17.array(
+      z17.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 = 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 Resource = z17.object({
+  id: z17.string(),
+  organizationId: z17.string(),
+  name: z17.string(),
+  slug: z17.string(),
+  origin: z17.string().url(),
+  publicKey: z17.string(),
+  revision: z17.number().int().positive(),
+  enabled: z17.boolean(),
+  cookieEvents: z17.boolean(),
+  minimalRealtime: z17.boolean()
 });
 var readKeys = [
   "days",
@@ -8816,7 +9287,7 @@ async function runAnalyticsCommand(options) {
   if (options.args[0] === "ga4") return runAnalyticsGoogleCommand(options);
   const json = options.args.includes("--json");
   try {
-    const { positionals, values } = parseArgs5({
+    const { positionals, values } = parseArgs6({
       args: options.args,
       strict: true,
       allowPositionals: true,
@@ -8898,7 +9369,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) z16.string().uuid().parse(values.campaign);
+    if (values.campaign) z17.string().uuid().parse(values.campaign);
     const setting = route === "settings set", creating = positionals[1] === "create", archive = positionals[1] === "archive";
     let body;
     if (setting) {
@@ -8922,10 +9393,10 @@ async function runAnalyticsCommand(options) {
     } else if (creating) {
       if (!values.file)
         throw new Error("Creation requires --file with a JSON definition.");
-      const filename = path26.resolve(options.cwd ?? process.cwd(), values.file);
+      const filename = path27.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 readFile17(filename, "utf8");
+      const text = await readFile18(filename, "utf8");
       if (Buffer.byteLength(text) > 16384)
         throw new Error("The definition must not exceed 16 KiB.");
       let definition;
@@ -8934,9 +9405,9 @@ async function runAnalyticsCommand(options) {
       } catch {
         throw new Error("The definition must contain valid JSON.");
       }
-      body = z16.record(z16.unknown()).parse(definition);
+      body = z17.record(z17.unknown()).parse(definition);
       if (action === "events") body = EventInput.parse(body);
-    } else if (archive) body = { id: z16.string().uuid().parse(positionals[2]) };
+    } else if (archive) body = { id: z17.string().uuid().parse(positionals[2]) };
     const context = await commonServiceContext(
       options,
       "analytics",
@@ -8983,8 +9454,8 @@ async function runAnalyticsCommand(options) {
     );
     const value = await response.json();
     if (!response.ok) {
-      const error = z16.object({
-        error: z16.object({ code: z16.string(), message: z16.string().max(500) })
+      const error = z17.object({
+        error: z17.object({ code: z17.string(), message: z17.string().max(500) })
       }).safeParse(value);
       throw new SiteOSAuthApiError({
         code: error.success ? error.data.error.code : "ANALYTICS_REQUEST_FAILED",
@@ -8992,9 +9463,9 @@ async function runAnalyticsCommand(options) {
         status: response.status
       });
     }
-    const record = z16.object({
-      contractVersion: z16.literal(1),
-      resourceId: z16.literal(context.resourceId)
+    const record = z17.object({
+      contractVersion: z17.literal(1),
+      resourceId: z17.literal(context.resourceId)
     }).passthrough().parse(value);
     let output;
     if (setting) {
@@ -9013,16 +9484,16 @@ async function runAnalyticsCommand(options) {
           throw new Error("The saved event does not match this definition.");
       } else
         output = {
-          id: z16.string().uuid().parse(record.id),
+          id: z17.string().uuid().parse(record.id),
           ...pick(
             record,
             action === "campaigns" ? ["label", "source", "medium", "campaign"] : action === "goals" ? ["label", "match"] : ["label", "steps"]
           )
         };
     } else if (archive)
-      output = { archived: z16.literal(true).parse(record.archived) };
+      output = { archived: z17.literal(true).parse(record.archived) };
     else if (route === "monitoring prepare")
-      output = { state: z16.literal("prepared").parse(record.state) };
+      output = { state: z17.literal("prepared").parse(record.state) };
     else if (action === "realtime") output = pick(record, liveKeys);
     else {
       const resource = Resource.parse(record.resource);
@@ -9034,8 +9505,8 @@ async function runAnalyticsCommand(options) {
         output = {
           resource,
           lastReceivedAt: record.lastReceivedAt,
-          consentSource: z16.object({
-            consentSource: z16.enum([
+          consentSource: z17.object({
+            consentSource: z17.enum([
               "cookie",
               "external",
               "waiting_for_cookie",
@@ -9047,11 +9518,11 @@ async function runAnalyticsCommand(options) {
       else if (action === "installation")
         output = {
           resource,
-          installation: z16.string().parse(record.installation),
+          installation: z17.string().parse(record.installation),
           configuration: record.configuration
         };
       else if (action === "events") {
-        const definitions = z16.array(EventInput).parse(record.definitions);
+        const definitions = z17.array(EventInput).parse(record.definitions);
         if (route === "events snippet") {
           const definition = definitions.find((d) => d.name === positionals[2]);
           if (!definition)
@@ -9065,13 +9536,13 @@ async function runAnalyticsCommand(options) {
           };
         } else output = { definitions, eventCounts: record.eventCounts };
       } else
-        output = action === "report" ? pick(record, readKeys) : { [action]: z16.array(z16.unknown()).parse(record[action]) };
+        output = action === "report" ? pick(record, readKeys) : { [action]: z17.array(z17.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 z16.ZodError ? "The Analytics input or response does not match the supported contract." : cause instanceof Error ? cause.message : "The Analytics command failed."
+      message: cause instanceof z17.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,
@@ -9081,13 +9552,13 @@ async function runAnalyticsCommand(options) {
 }
 
 // src/services/seo-repair-command.ts
-import { parseArgs as parseArgs6 } from "util";
-import { z as z18 } from "zod";
+import { parseArgs as parseArgs7 } from "util";
+import { z as z19 } from "zod";
 
 // src/services/seo-report-client.ts
-import { open, writeFile as writeFile8 } from "fs/promises";
-import path27 from "path";
-import { z as z17 } from "zod";
+import { open, writeFile as writeFile9 } from "fs/promises";
+import path28 from "path";
+import { z as z18 } from "zod";
 async function seoReportClient(options, environment) {
   const context = await commonServiceContext(options, "seo", environment);
   if (!context)
@@ -9122,8 +9593,8 @@ async function seoReportClient(options, environment) {
         }
       );
       if (!response.ok) {
-        const result = z17.object({
-          error: z17.object({ code: z17.string(), message: z17.string().max(500) })
+        const result = z18.object({
+          error: z18.object({ code: z18.string(), message: z18.string().max(500) })
         }).safeParse(await response.json());
         throw new SiteOSAuthApiError({
           code: result.success ? result.data.error.code : "SEO_REQUEST_FAILED",
@@ -9137,9 +9608,9 @@ async function seoReportClient(options, environment) {
     }
   };
 }
-var versionedReport = z17.object({ contractVersion: z17.literal(1) }).passthrough();
+var versionedReport = z18.object({ contractVersion: z18.literal(1) }).passthrough();
 async function readSeoInput(cwd, filename) {
-  const file = await open(path27.resolve(cwd ?? process.cwd(), filename), "r");
+  const file = await open(path28.resolve(cwd ?? process.cwd(), filename), "r");
   try {
     const stat4 = await file.stat();
     if (!stat4.isFile() || stat4.size > 32e3)
@@ -9163,14 +9634,14 @@ async function readSeoInput(cwd, filename) {
   }
 }
 async function writeSeoReport(options, filename, content) {
-  const output = path27.resolve(options.cwd ?? process.cwd(), filename);
-  await writeFile8(output, content, { flag: "wx", mode: 384 });
+  const output = path28.resolve(options.cwd ?? process.cwd(), filename);
+  await writeFile9(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 z17.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
+    message: cause instanceof z18.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
   };
   return {
     exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
@@ -9189,7 +9660,7 @@ function seoReportFailure(cause, json, idempotencyKey) {
 async function runSeoRepairCommand(options) {
   const json = options.args.includes("--json");
   try {
-    const { positionals, values } = parseArgs6({
+    const { positionals, values } = parseArgs7({
       args: options.args,
       allowPositionals: true,
       strict: true,
@@ -9234,32 +9705,32 @@ async function runSeoRepairCommand(options) {
     });
     const record = versionedReport.parse(await response.json());
     if (recheck) {
-      z18.object({
-        id: z18.string(),
-        resourceId: z18.literal(client.resourceId),
-        organizationId: z18.literal(client.organizationId),
-        state: z18.literal("queued")
+      z19.object({
+        id: z19.string(),
+        resourceId: z19.literal(client.resourceId),
+        organizationId: z19.literal(client.organizationId),
+        state: z19.literal("queued")
       }).parse(record.audit);
       return { exitCode: 0, stdout: JSON.stringify(record, null, 2) };
     }
-    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)
+    const brief = z19.object({
+      schemaVersion: z19.literal(1),
+      context: z19.object({
+        auditId: z19.literal(values.audit),
+        resourceId: z19.literal(client.resourceId),
+        organizationId: z19.literal(client.organizationId),
+        selectedUrls: z19.array(z19.string()).min(1).max(20),
+        ruleId: z19.literal(values.rule ?? null)
       }),
-      evidence: z18.array(
-        z18.object({
-          url: z18.string(),
-          findings: z18.array(z18.unknown()).max(12)
+      evidence: z19.array(
+        z19.object({
+          url: z19.string(),
+          findings: z19.array(z19.unknown()).max(12)
         })
       ).min(1).max(20),
-      suggestedGroups: z18.array(z18.unknown()),
-      verificationCommand: z18.string().min(1),
-      text: z18.string().min(1)
+      suggestedGroups: z19.array(z19.unknown()),
+      verificationCommand: z19.string().min(1),
+      text: z19.string().min(1)
     }).parse(record);
     const canonical = (value) => {
       const url = new URL(value);
@@ -9279,16 +9750,16 @@ async function runSeoRepairCommand(options) {
 }
 
 // src/services/seo-command.ts
-import { writeFile as writeFile10 } from "fs/promises";
-import path29 from "path";
-import { parseArgs as parseArgs10 } from "util";
-import { z as z22 } from "zod";
+import { writeFile as writeFile11 } from "fs/promises";
+import path30 from "path";
+import { parseArgs as parseArgs11 } from "util";
+import { z as z23 } 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 parseArgs7 } from "util";
-import { z as z19 } from "zod";
+import { isDeepStrictEqual, parseArgs as parseArgs8 } from "util";
+import { z as z20 } from "zod";
 var RESEARCH_HELP = `
   siteos seo research summary [--environment <slug>] [--json]
   siteos seo research status --kind <kind> [--environment <slug>] [--json]
@@ -9335,11 +9806,11 @@ var kinds = [
 ];
 var sections = [...kinds, "ai-rankings"];
 var sectionOf = (request) => request.kind === "ai-visibility" && request.category ? "ai-rankings" : request.kind;
-var requestSchema = z19.object({
-  kind: z19.enum(["domain", ...kinds]).transform((kind) => kind === "domain" ? "competitors" : kind),
-  target: z19.string().min(1).max(253)
+var requestSchema = z20.object({
+  kind: z20.enum(["domain", ...kinds]).transform((kind) => kind === "domain" ? "competitors" : kind),
+  target: z20.string().min(1).max(253)
 }).passthrough();
-var runStates = z19.enum([
+var runStates = z20.enum([
   "queued",
   "running",
   "completed",
@@ -9355,7 +9826,7 @@ var csvCell = (value) => {
 async function runSeoResearchCommand(options) {
   let idempotencyKey;
   try {
-    const { values, positionals } = parseArgs7({
+    const { values, positionals } = parseArgs8({
       args: options.args.slice(1),
       strict: true,
       allowPositionals: true,
@@ -9374,7 +9845,7 @@ async function runSeoResearchCommand(options) {
       }
     });
     const action = ["saved", "serp"].includes(positionals[0] ?? "") ? positionals.slice(0, 2).join(" ") : positionals[0] ?? "";
-    const id = positionals[action.includes(" ") ? 2 : 1];
+    const id2 = positionals[action.includes(" ") ? 2 : 1];
     const operations = {
       "serp show": { args: 3, flags: ["keyword"] },
       "serp ensure": { args: 3, flags: ["keyword"] },
@@ -9437,26 +9908,26 @@ async function runSeoResearchCommand(options) {
         );
     }
     const client = await seoReportClient(options, values.environment);
-    const resourceSchema = z19.object({
-      id: z19.literal(client.resourceId),
-      organizationId: z19.literal(client.organizationId)
+    const resourceSchema = z20.object({
+      id: z20.literal(client.resourceId),
+      organizationId: z20.literal(client.organizationId)
     }).passthrough();
-    const runSchema = z19.object({
-      id: z19.string(),
-      resourceId: z19.literal(client.resourceId),
-      organizationId: z19.literal(client.organizationId),
-      websiteUrl: z19.string(),
+    const runSchema = z20.object({
+      id: z20.string(),
+      resourceId: z20.literal(client.resourceId),
+      organizationId: z20.literal(client.organizationId),
+      websiteUrl: z20.string(),
       request: requestSchema,
       state: runStates,
-      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()
+      createdAt: z20.string(),
+      finishedAt: z20.string().nullable(),
+      parts: z20.array(
+        z20.object({
+          key: z20.string(),
+          state: z20.enum(["completed", "failed"]),
+          error: z20.string().nullable(),
+          dataset: z20.record(z20.unknown()).nullable(),
+          observedAt: z20.string()
         }).passthrough()
       )
     }).passthrough();
@@ -9470,41 +9941,41 @@ async function runSeoResearchCommand(options) {
     const query = `?kind=${encodeURIComponent(values.kind ?? "rankings")}`;
     let record;
     if (action.startsWith("serp ")) {
-      const snapshotSchema = z19.object({
-        id: z19.string(),
-        organizationId: z19.literal(client.organizationId),
-        resourceId: z19.literal(client.resourceId),
-        sourceRunId: z19.literal(id),
+      const snapshotSchema = z20.object({
+        id: z20.string(),
+        organizationId: z20.literal(client.organizationId),
+        resourceId: z20.literal(client.resourceId),
+        sourceRunId: z20.literal(id2),
         request: requestSchema,
-        keywordKey: z19.literal(
+        keywordKey: z20.literal(
           values.keyword.normalize("NFKC").trim().toLowerCase().replace(/\s+/gu, " ")
         ),
-        state: z19.enum([
+        state: z20.enum([
           "queued",
           "running",
           "completed",
           "failed",
           "cancelled"
         ]),
-        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()
+        dataset: z20.object({
+          type: z20.literal("serp"),
+          keyword: z20.string(),
+          country: z20.string(),
+          language: z20.string(),
+          device: z20.enum(["desktop", "mobile"]),
+          observedAt: z20.string(),
+          rows: z20.array(
+            z20.object({
+              position: z20.number(),
+              title: z20.string(),
+              url: z20.string(),
+              domain: z20.string(),
+              description: z20.string()
             })
           )
         }).nullable()
       }).passthrough();
-      const suffix = `/runs/${encodeURIComponent(id)}/serp`;
+      const suffix = `/runs/${encodeURIComponent(id2)}/serp`;
       const read = () => get(`${suffix}?keyword=${encodeURIComponent(values.keyword)}`);
       record = action === "serp ensure" ? await get(suffix, "run", { keyword: values.keyword }) : await read();
       const deadline = Date.now() + timeout * 1e3;
@@ -9543,7 +10014,7 @@ async function runSeoResearchCommand(options) {
             "description"
           ],
           ...(data?.rows.length ? data.rows : [null]).map((row) => [
-            id,
+            id2,
             values.keyword,
             data?.country,
             data?.language,
@@ -9560,7 +10031,7 @@ async function runSeoResearchCommand(options) {
         const output = await writeSeoReport(options, values.output, content);
         record = {
           contractVersion: 1,
-          runId: id,
+          runId: id2,
           keyword: values.keyword,
           state: snapshot.state,
           format: values.format,
@@ -9573,18 +10044,18 @@ async function runSeoResearchCommand(options) {
       };
     }
     if (action === "retry") {
-      const source = await get(`/runs/${encodeURIComponent(id)}`);
+      const source = await get(`/runs/${encodeURIComponent(id2)}`);
       resourceSchema.parse(source.resource);
       const original = runSchema.parse(source.run);
-      if (original.id !== id || ["queued", "running"].includes(original.state))
+      if (original.id !== id2 || ["queued", "running"].includes(original.state))
         throw new Error("Choose the exact stopped research report to retry.");
       record = await get("/runs", "run", {
         request: original.request,
-        retryOf: id,
+        retryOf: id2,
         idempotencyKey
       });
       const next = runSchema.parse(record.run);
-      if (next.retryOf !== id || !isDeepStrictEqual(next.request, original.request))
+      if (next.retryOf !== id2 || !isDeepStrictEqual(next.request, original.request))
         throw new Error(
           "The continued check does not match the original report."
         );
@@ -9609,9 +10080,9 @@ async function runSeoResearchCommand(options) {
           name: values.name.trim(),
           ...values.id ? { id: values.id } : {}
         });
-        const saved = z19.object({
-          id: z19.string(),
-          name: z19.literal(values.name.trim()),
+        const saved = z20.object({
+          id: z20.string(),
+          name: z20.literal(values.name.trim()),
           request: requestSchema
         }).parse(record.saved);
         if (values.id && saved.id !== values.id || !isDeepStrictEqual(saved.request, plan.request))
@@ -9621,27 +10092,27 @@ async function runSeoResearchCommand(options) {
       } else record = plan;
     } else if (action === "cancel" || action === "saved remove") {
       record = await get(
-        `/${action === "cancel" ? "runs" : "saved"}/${encodeURIComponent(id)}/${action === "cancel" ? "cancel" : "remove"}`,
+        `/${action === "cancel" ? "runs" : "saved"}/${encodeURIComponent(id2)}/${action === "cancel" ? "cancel" : "remove"}`,
         action === "cancel" ? "run" : "write",
         {}
       );
-      z19.literal(true).parse(
+      z20.literal(true).parse(
         record[action === "cancel" ? "cancelled" : "removed"]
       );
     } else if (action === "summary") {
       record = await get("/summary");
       resourceSchema.parse(record.resource);
-      z19.array(z19.object({ kind: z19.enum(sections), summary: z19.unknown() })).parse(
+      z20.array(z20.object({ kind: z20.enum(sections), summary: z20.unknown() })).parse(
         record.checks
       );
     } else if (["status", "history", "saved list"].includes(action)) {
       const view = await get(query);
       resourceSchema.parse(view.resource);
-      const runs = z19.array(runSchema).parse(view.runs);
-      const saved = z19.array(
-        z19.object({
-          id: z19.string(),
-          name: z19.string(),
+      const runs = z20.array(runSchema).parse(view.runs);
+      const saved = z20.array(
+        z20.object({
+          id: z20.string(),
+          name: z20.string(),
           request: requestSchema
         }).passthrough()
       ).parse(view.saved);
@@ -9663,10 +10134,10 @@ async function runSeoResearchCommand(options) {
     } else {
       const deadline = Date.now() + timeout * 1e3;
       while (true) {
-        record = await get(`/runs/${encodeURIComponent(id)}`);
+        record = await get(`/runs/${encodeURIComponent(id2)}`);
         resourceSchema.parse(record.resource);
         const run = runSchema.parse(record.run);
-        if (run.id !== id)
+        if (run.id !== id2)
           throw new Error(
             "The response does not match the selected research check."
           );
@@ -9756,7 +10227,7 @@ async function runSeoResearchCommand(options) {
         const output = await writeSeoReport(options, values.output, content);
         record = {
           contractVersion: 1,
-          runId: id,
+          runId: id2,
           state: run.state,
           format: values.format,
           output
@@ -9776,8 +10247,8 @@ async function runSeoResearchCommand(options) {
 }
 
 // src/services/seo-gsc-command.ts
-import { parseArgs as parseArgs8 } from "util";
-import { z as z20 } from "zod";
+import { parseArgs as parseArgs9 } from "util";
+import { z as z21 } 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]
@@ -9795,7 +10266,7 @@ Bind/disconnect require a current revision and separate settings authority. Disc
 `;
 async function runSeoGscCommand(options) {
   try {
-    const { values, positionals } = parseArgs8({
+    const { values, positionals } = parseArgs9({
       args: options.args.slice(1),
       strict: true,
       allowPositionals: true,
@@ -9877,13 +10348,13 @@ async function runSeoGscCommand(options) {
       `seo:search:${action === "sync" ? "sync" : writing ? "write" : "read"}`,
       body
     );
-    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([
+    const runSchema = z21.object({
+      id: z21.string(),
+      resourceId: z21.literal(client.resourceId),
+      organizationId: z21.literal(client.organizationId),
+      websiteUrl: z21.string(),
+      siteUrl: z21.string(),
+      state: z21.enum([
         "queued",
         "running",
         "completed",
@@ -9891,32 +10362,32 @@ async function runSeoGscCommand(options) {
         "failed",
         "cancelled"
       ]),
-      dates: z20.unknown()
+      dates: z21.unknown()
     }).passthrough();
-    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()
+    const bindingSchema = z21.object({
+      resourceId: z21.literal(client.resourceId),
+      organizationId: z21.literal(client.organizationId),
+      websiteUrl: z21.string(),
+      siteUrl: z21.string(),
+      revision: z21.number().int().positive()
     }).passthrough();
-    const metrics = z20.object({
-      clicks: z20.number(),
-      impressions: z20.number(),
-      ctr: z20.number(),
-      position: z20.number()
+    const metrics = z21.object({
+      clicks: z21.number(),
+      impressions: z21.number(),
+      ctr: z21.number(),
+      position: z21.number()
     }).passthrough().nullable();
     const validateView = (data) => {
       const record2 = versionedReport.parse(data);
-      z20.literal(client.resourceId).parse(record2.resourceId);
+      z21.literal(client.resourceId).parse(record2.resourceId);
       bindingSchema.nullable().parse(record2.binding);
       runSchema.nullable().parse(record2.latest);
       runSchema.nullable().parse(record2.report);
-      z20.array(
-        z20.object({ key: z20.string(), current: metrics, previous: metrics }).passthrough()
+      z21.array(
+        z21.object({ key: z21.string(), current: metrics, previous: metrics }).passthrough()
       ).parse(record2.rows);
-      z20.number().int().nonnegative().parse(record2.total);
-      z20.literal(values.dataset ?? "pages").parse(record2.dataset);
+      z21.number().int().nonnegative().parse(record2.total);
+      z21.literal(values.dataset ?? "pages").parse(record2.dataset);
       return record2;
     };
     if (action === "export") {
@@ -9932,9 +10403,9 @@ async function runSeoGscCommand(options) {
       const text = await response.text();
       if (values.format === "json") {
         const report = validateView(JSON.parse(text));
-        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);
+        z21.literal(reportId).parse(runSchema.parse(report.report).id);
+        z21.array(z21.unknown()).length(rows).parse(report.rows);
+        z21.literal(truncated === "true").parse(report.truncated);
       }
       const output = await writeSeoReport(options, values.output, text);
       return {
@@ -9955,7 +10426,7 @@ async function runSeoGscCommand(options) {
       };
     }
     const record = versionedReport.parse(await response.json());
-    if (action === "disconnect") z20.literal(true).parse(record.unbound);
+    if (action === "disconnect") z21.literal(true).parse(record.unbound);
     else if (writing) {
       runSchema.parse(record.run);
       if (action === "bind") {
@@ -9974,11 +10445,11 @@ async function runSeoGscCommand(options) {
 
 // src/services/seo-performance-command.ts
 import { randomUUID as randomUUID7 } from "crypto";
-import { writeFile as writeFile9 } from "fs/promises";
-import path28 from "path";
+import { writeFile as writeFile10 } from "fs/promises";
+import path29 from "path";
 import { setTimeout as setTimeout3 } from "timers/promises";
-import { parseArgs as parseArgs9 } from "util";
-import { z as z21 } from "zod";
+import { parseArgs as parseArgs10 } from "util";
+import { z as z22 } 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]
@@ -9995,7 +10466,7 @@ Reuse the returned idempotency key after an uncertain run response. Wait default
 async function runSeoPerformanceCommand(options) {
   let idempotencyKey;
   try {
-    const { values, positionals } = parseArgs9({
+    const { values, positionals } = parseArgs10({
       args: options.args.slice(1),
       strict: true,
       allowPositionals: true,
@@ -10012,7 +10483,7 @@ async function runSeoPerformanceCommand(options) {
       }
     });
     const action = positionals[0] ?? "";
-    const id = positionals[1];
+    const id2 = positionals[1];
     const operations = {
       run: { args: 1, flags: ["audit", "url", "device", "idempotency-key"] },
       list: { args: 1, flags: ["device"] },
@@ -10066,12 +10537,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 = z21.object({
-      id: z21.string(),
-      resourceId: z21.literal(context.resourceId),
-      organizationId: z21.literal(context.overview.project.organizationId),
-      sourceAuditId: z21.string(),
-      state: z21.enum([
+    const batchSchema = z22.object({
+      id: z22.string(),
+      resourceId: z22.literal(context.resourceId),
+      organizationId: z22.literal(context.overview.project.organizationId),
+      sourceAuditId: z22.string(),
+      state: z22.enum([
         "queued",
         "running",
         "completed",
@@ -10079,13 +10550,13 @@ async function runSeoPerformanceCommand(options) {
         "failed",
         "cancelled"
       ]),
-      device: z21.enum(["mobile", "desktop"]),
-      urls: z21.array(z21.string()).min(1).max(10)
+      device: z22.enum(["mobile", "desktop"]),
+      urls: z22.array(z22.string()).min(1).max(10)
     }).passthrough();
     const query = new URLSearchParams();
     if (values.device) query.set("device", values.device);
     if (!writing && values.url?.[0]) query.set("pageUrl", values.url[0]);
-    const suffix = id ? `/${encodeURIComponent(id)}${action === "cancel" ? "/cancel" : action === "export" ? "/export" : ""}` : "";
+    const suffix = id2 ? `/${encodeURIComponent(id2)}${action === "cancel" ? "/cancel" : action === "export" ? "/export" : ""}` : "";
     if (action === "export") query.set("format", values.format);
     const deadline = Date.now() + timeout * 1e3;
     while (true) {
@@ -10120,7 +10591,7 @@ async function runSeoPerformanceCommand(options) {
         }
       );
       if (action === "export" && response.ok) {
-        if (!(response instanceof Response) || response.headers.get("X-SEO-Browser-Id") !== id || !response.headers.get("Content-Type")?.startsWith(
+        if (!(response instanceof Response) || response.headers.get("X-SEO-Browser-Id") !== id2 || !response.headers.get("Content-Type")?.startsWith(
           values.format === "csv" ? "text/csv" : "application/json"
         ))
           throw new Error(
@@ -10128,25 +10599,25 @@ async function runSeoPerformanceCommand(options) {
           );
         const text = await response.text();
         if (values.format === "json") {
-          const parsed = z21.object({
-            contractVersion: z21.literal(1),
+          const parsed = z22.object({
+            contractVersion: z22.literal(1),
             batch: batchSchema,
-            pages: z21.array(z21.unknown())
+            pages: z22.array(z22.unknown())
           }).parse(JSON.parse(text));
-          if (parsed.batch.id !== id)
+          if (parsed.batch.id !== id2)
             throw new Error(
               "The export response does not match the selected check."
             );
         }
-        const output = path28.resolve(
+        const output = path29.resolve(
           options.cwd ?? process.cwd(),
           values.output
         );
-        await writeFile9(output, text, { flag: "wx", mode: 384 });
+        await writeFile10(output, text, { flag: "wx", mode: 384 });
         return {
           exitCode: 0,
           stdout: JSON.stringify(
-            { batchId: id, output, format: values.format },
+            { batchId: id2, output, format: values.format },
             null,
             2
           )
@@ -10154,8 +10625,8 @@ async function runSeoPerformanceCommand(options) {
       }
       const data = await response.json();
       if (!response.ok) {
-        const error = z21.object({
-          error: z21.object({ code: z21.string(), message: z21.string().max(500) })
+        const error = z22.object({
+          error: z22.object({ code: z22.string(), message: z22.string().max(500) })
         }).safeParse(data);
         throw new SiteOSAuthApiError({
           code: error.success ? error.data.error.code : "SEO_REQUEST_FAILED",
@@ -10163,8 +10634,8 @@ async function runSeoPerformanceCommand(options) {
           status: response.status
         });
       }
-      const record = z21.object({ contractVersion: z21.literal(1) }).passthrough().parse(data);
-      if (action === "cancel") z21.literal(true).parse(record.cancelled);
+      const record = z22.object({ contractVersion: z22.literal(1) }).passthrough().parse(data);
+      if (action === "cancel") z22.literal(true).parse(record.cancelled);
       else if (action === "run") {
         const accepted = batchSchema.parse(record.batch);
         const normalize = (url) => {
@@ -10177,10 +10648,10 @@ async function runSeoPerformanceCommand(options) {
             "The queued check does not match the requested source, device and URLs."
           );
       } else {
-        z21.literal(context.resourceId).parse(record.resourceId);
-        z21.array(batchSchema).parse(record.batches);
+        z22.literal(context.resourceId).parse(record.resourceId);
+        z22.array(batchSchema).parse(record.batches);
         const selected = batchSchema.nullable().parse(record.batch);
-        if (id && selected?.id !== id)
+        if (id2 && selected?.id !== id2)
           throw new Error(
             "The response does not match the selected performance check."
           );
@@ -10205,7 +10676,7 @@ async function runSeoPerformanceCommand(options) {
   } catch (cause) {
     const error = {
       code: cause instanceof SiteOSAuthApiError ? cause.code : "SEO_COMMAND_FAILED",
-      message: cause instanceof z21.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The performance command failed."
+      message: cause instanceof z22.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The performance command failed."
     };
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,
@@ -10245,7 +10716,7 @@ Usage:
   siteos seo recheck --audit <id> --url <url> [--url <url>...] [--resource <expected-id>] [--environment <slug>] [--json]
   siteos seo issue <ignore|restore> --audit <id> --url <url> --rule <id> --reason <text> --revision <number> [--environment <slug>] [--json]
   siteos seo schedule show [--environment <slug>] [--json]
-  siteos seo schedule set --enabled <true|false> --weekday <1-7> --time <HH:mm> --timezone <IANA> --revision <number> [--environment <slug>] [--json]
+  siteos seo schedule set --enabled <true|false> (--days <1,2,3|daily|weekdays> | --weekday <1-7>) --time <HH:mm> --timezone <IANA> --revision <number> [--environment <slug>] [--json]
   siteos seo notifications retry <notification-id> [--environment <slug>] [--json]
   siteos seo notifications show [--environment <slug>] [--json]
   siteos seo notifications destinations [--environment <slug>] [--json]
@@ -10277,7 +10748,7 @@ async function runSeoCommand(options) {
     return runSeoRepairCommand(options);
   const json = options.args.includes("--json");
   try {
-    const { positionals, values } = parseArgs10({
+    const { positionals, values } = parseArgs11({
       args: options.args,
       strict: true,
       allowPositionals: true,
@@ -10294,6 +10765,7 @@ async function runSeoCommand(options) {
         state: { type: "string" },
         enabled: { type: "string" },
         weekday: { type: "string" },
+        days: { type: "string" },
         time: { type: "string" },
         timezone: { type: "string" },
         destination: { type: "string" },
@@ -10310,7 +10782,7 @@ async function runSeoCommand(options) {
       status: { flags: [], args: 1 },
       "schedule show": { flags: [], args: 2 },
       "schedule set": {
-        flags: ["enabled", "weekday", "time", "timezone", "revision"],
+        flags: ["enabled", "weekday", "days", "time", "timezone", "revision"],
         args: 2
       },
       "notifications retry": { flags: [], args: 3 },
@@ -10375,9 +10847,12 @@ async function runSeoCommand(options) {
     const setting = automation && positionals[1] === "set";
     if (setting && (!values.revision || !["true", "false"].includes(values.enabled ?? "")))
       throw new Error("Settings require --enabled true|false and --revision.");
+    const days = values.days === "daily" ? [1, 2, 3, 4, 5, 6, 7] : values.days === "weekdays" ? [1, 2, 3, 4, 5] : values.days?.split(",").map(Number);
     if (route === "schedule set") {
-      if (!/^[1-7]$/u.test(values.weekday ?? "") || !/^([01]\d|2[0-3]):[0-5]\d$/u.test(values.time ?? "") || !values.timezone)
-        throw new Error("Use weekday 1\u20137, HH:mm and an IANA time zone.");
+      if (values.days !== void 0 === (values.weekday !== void 0) || (days ? !days.length || days.some((day) => !Number.isInteger(day) || day < 1 || day > 7) || new Set(days).size !== days.length : !/^[1-7]$/u.test(values.weekday ?? "")) || !/^([01]\d|2[0-3]):[0-5]\d$/u.test(values.time ?? "") || !values.timezone)
+        throw new Error(
+          "Use --days daily, weekdays or distinct days 1\u20137 (or --weekday), HH:mm and an IANA time zone."
+        );
       try {
         new Intl.DateTimeFormat("en", { timeZone: values.timezone });
       } catch {
@@ -10439,7 +10914,7 @@ async function runSeoCommand(options) {
     const suffix = retryNotification ? "/notification-retries" : automation ? setting ? `/${action}` : route === "notifications destinations" ? "/destinations" : "/automation" : action === "export" ? `/export?${query}` : route === "audit run" ? "/audits" : route === "audit cancel" ? `/audits/${encodeURIComponent(positionals[2])}/cancel` : action === "issue" ? "/dispositions" : `?${query}`;
     const body = retryNotification ? { notificationId: positionals[2] } : route === "schedule set" ? {
       enabled: values.enabled === "true",
-      weekday: Number(values.weekday),
+      ...days ? { days: [...days].sort((a, b) => a - b) } : { weekday: Number(values.weekday) },
       time: values.time,
       timeZone: values.timezone,
       expectedRevision: Number(values.revision)
@@ -10483,18 +10958,18 @@ async function runSeoCommand(options) {
         );
       const text = await response.text();
       if (values.format === "json")
-        z22.object({
-          contractVersion: z22.literal(1),
-          audit: z22.object({
-            id: z22.literal(values.audit),
-            resourceId: z22.literal(context.resourceId)
+        z23.object({
+          contractVersion: z23.literal(1),
+          audit: z23.object({
+            id: z23.literal(values.audit),
+            resourceId: z23.literal(context.resourceId)
           }),
-          kind: z22.literal(values.kind),
-          totalRows: z22.literal(rows),
-          rows: z22.array(z22.unknown()).length(rows)
+          kind: z23.literal(values.kind),
+          totalRows: z23.literal(rows),
+          rows: z23.array(z23.unknown()).length(rows)
         }).parse(JSON.parse(text));
-      const output = path29.resolve(options.cwd ?? process.cwd(), values.output);
-      await writeFile10(output, text, { flag: "wx", mode: 384 });
+      const output = path30.resolve(options.cwd ?? process.cwd(), values.output);
+      await writeFile11(output, text, { flag: "wx", mode: 384 });
       return {
         exitCode: 0,
         stdout: JSON.stringify(
@@ -10512,8 +10987,8 @@ async function runSeoCommand(options) {
     }
     const data = await response.json();
     if (!response.ok) {
-      const result = z22.object({
-        error: z22.object({ code: z22.string(), message: z22.string().max(500) })
+      const result = z23.object({
+        error: z23.object({ code: z23.string(), message: z23.string().max(500) })
       }).safeParse(data);
       throw new SiteOSAuthApiError({
         code: result.success ? result.data.error.code : "SEO_REQUEST_FAILED",
@@ -10521,34 +10996,35 @@ async function runSeoCommand(options) {
         status: response.status
       });
     }
-    const record = z22.object({ contractVersion: z22.literal(1) }).passthrough().parse(data);
+    const record = z23.object({ contractVersion: z23.literal(1) }).passthrough().parse(data);
     if (automation) {
-      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()
+      z23.literal(context.resourceId).parse(record.resourceId);
+      const schedule = z23.object({
+        enabled: z23.boolean(),
+        weekday: z23.number().int().min(1).max(7),
+        days: z23.array(z23.number().int().min(1).max(7)).min(1).max(7).optional(),
+        time: z23.string(),
+        timeZone: z23.string(),
+        revision: z23.number().int().min(0),
+        nextRunAt: z23.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()
+      const notificationRoute = z23.object({
+        enabled: z23.boolean(),
+        minimumSeverity: z23.enum(["error", "warning"]),
+        includeFailures: z23.boolean(),
+        revision: z23.number().int().min(0),
+        destinationId: z23.string().nullable()
       });
       if (retryNotification) {
-        z22.literal(true).parse(record.retryQueued);
-        z22.literal(positionals[2]).parse(record.notificationId);
+        z23.literal(true).parse(record.retryQueued);
+        z23.literal(positionals[2]).parse(record.notificationId);
       } else if (route === "notifications destinations")
-        z22.object({
-          candidates: z22.array(
-            z22.object({
-              candidateId: z22.string(),
-              label: z22.string(),
-              availability: z22.literal("available")
+        z23.object({
+          candidates: z23.array(
+            z23.object({
+              candidateId: z23.string(),
+              label: z23.string(),
+              availability: z23.literal("available")
             })
           )
         }).parse(record);
@@ -10561,46 +11037,46 @@ async function runSeoCommand(options) {
         notificationRoute.parse(record.route);
       }
     } else if (!writing) {
-      const validated = z22.object({
-        resource: z22.object({
-          id: z22.literal(context.resourceId),
-          organizationId: z22.literal(context.overview.project.organizationId)
+      const validated = z23.object({
+        resource: z23.object({
+          id: z23.literal(context.resourceId),
+          organizationId: z23.literal(context.overview.project.organizationId)
         }),
-        audits: z22.array(z22.object({ id: z22.string() }).passthrough()),
-        audit: z22.object({
-          id: z22.string(),
-          resourceId: z22.literal(context.resourceId)
+        audits: z23.array(z23.object({ id: z23.string() }).passthrough()),
+        audit: z23.object({
+          id: z23.string(),
+          resourceId: z23.literal(context.resourceId)
         }).passthrough().nullable(),
-        pages: z22.array(z22.unknown()),
-        issues: z22.array(z22.unknown()),
-        changes: z22.array(z22.unknown()),
-        totalChanges: z22.number(),
-        dispositions: z22.array(z22.unknown())
+        pages: z23.array(z23.unknown()),
+        issues: z23.array(z23.unknown()),
+        changes: z23.array(z23.unknown()),
+        totalChanges: z23.number(),
+        dispositions: z23.array(z23.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)
-      z22.object({
-        id: z22.string(),
-        resourceId: z22.literal(context.resourceId),
-        organizationId: z22.literal(context.overview.project.organizationId),
-        state: z22.literal("queued")
+      z23.object({
+        id: z23.string(),
+        resourceId: z23.literal(context.resourceId),
+        organizationId: z23.literal(context.overview.project.organizationId),
+        state: z23.literal("queued")
       }).parse(record.audit);
-    else if (route === "audit cancel") z22.literal(true).parse(record.cancelled);
+    else if (route === "audit cancel") z23.literal(true).parse(record.cancelled);
     else if (action === "issue")
-      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)
+      z23.object({
+        url: z23.literal(values.url),
+        ruleId: z23.literal(values.rule),
+        ignored: z23.literal(positionals[1] === "ignore"),
+        revision: z23.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 z22.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
+      message: cause instanceof z23.ZodError ? "The SEO service returned an invalid response." : cause instanceof Error ? cause.message : "The SEO command failed."
     };
     return {
       exitCode: cause instanceof SiteOSAuthApiError ? 1 : 2,