@parity-app/cli 0.7.1 → 0.7.2

package/dist/index.d.mts

@@ -13,100 +13,766 @@ interface Registry {
   path: string;
 }
 /**
- * Why an agent's call failed, as a stable code it can act on without reading the message. The CLI and MCP publish
- * these; the app throws them where it knows the cause.
+ * Each operation's input by RPC method, as the CLI and MCP take it and the app is sent it. Execute's is a snippet to
+ * run, or a failed snippet's editId with edits to it (PAR-451).
  */
-declare const errorCodes: readonly [
-/** The request is malformed: a field is missing, of the wrong type or out of range. */
-"invalid_input",
-/** The app isn't running, so there's nowhere to send the call. */
-"not_running",
-/** The app is running but didn't answer. */
-"not_answering", "unknown_tab",
-/** The tab is still opening, or failed to open. */
-"tab_not_ready", "unknown_design", "unknown_node",
-/** A reference matches more than one thing; the alternatives say how to name each. */
-"ambiguous_reference", "unknown_state", "unknown_mode", "unknown_viewport", "unknown_component", "unknown_icon_set",
-/** A retry named a failed snippet the app doesn't have, so the whole snippet has to be sent again. */
-"unknown_edit_id",
-/** The call's changes collided with edits made in the editor meanwhile. Running it again may succeed. */
-"conflict",
-/** A snippet threw. Retry it with its editId and edits. */
-"execution_failed",
-/** Anything else the app reported. */
-"app_error"];
-type ErrorCode = (typeof errorCodes)[number];
+declare const requests: {
+  tabs: z.ZodObject<{}, z.core.$strict>;
+  state: z.ZodObject<{
+    tab: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>;
+  status: z.ZodObject<{
+    tab: z.ZodOptional<z.ZodString>;
+    summary: z.ZodDefault<z.ZodBoolean>;
+    limit: z.ZodDefault<z.ZodInt>;
+  }, z.core.$strict>;
+  modes: z.ZodObject<{
+    tab: z.ZodOptional<z.ZodString>;
+    design: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>;
+  open: z.ZodObject<{
+    root: z.ZodString;
+  }, z.core.$strict>;
+  screenshot: z.ZodObject<{
+    tab: z.ZodOptional<z.ZodString>;
+    design: z.ZodString;
+    scale: z.ZodDefault<z.ZodNumber>;
+    state: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string | string[], string | string[]>>>;
+    mode: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string | string[], string | string[]>>>;
+  }, z.core.$strict>;
+  problems: z.ZodObject<{
+    tab: z.ZodOptional<z.ZodString>;
+    design: z.ZodString;
+    state: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string | string[], string | string[]>>;
+    mode: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string | string[], string | string[]>>;
+  }, z.core.$strict>;
+  accessibility: z.ZodObject<{
+    tab: z.ZodOptional<z.ZodString>;
+    design: z.ZodString;
+    state: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string | string[], string | string[]>>;
+    mode: z.ZodPipe<z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string | string[], string | string[]>>;
+  }, z.core.$strict>;
+  console: z.ZodObject<{
+    tab: z.ZodOptional<z.ZodString>;
+    clear: z.ZodDefault<z.ZodBoolean>;
+    limit: z.ZodDefault<z.ZodInt>;
+  }, z.core.$strict>;
+  tokens: z.ZodObject<{
+    tab: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodInt>;
+  }, z.core.$strict>;
+  components: z.ZodObject<{
+    tab: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>;
+  props: z.ZodObject<{
+    tab: z.ZodOptional<z.ZodString>;
+    component: z.ZodString;
+    all: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strict>;
+  exec: z.ZodUnion<readonly [z.ZodObject<{
+    tab: z.ZodOptional<z.ZodString>;
+    label: z.ZodDefault<z.ZodString>;
+    code: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    tab: z.ZodOptional<z.ZodString>;
+    label: z.ZodDefault<z.ZodString>;
+    editId: z.ZodString;
+    edits: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      find: z.ZodString;
+      replace: z.ZodString;
+      all: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+  }, z.core.$strict>]>;
+};
 /**
- * A failed call, the same in CLI `--json` and MCP `structuredContent`: a stable code to branch on, the message people
- * read, whether the same request can succeed when sent again, the input at fault, and what to use instead.
+ * Each method's answer by RPC method, which the CLI checks before reading it. `copy` is what a copy says about itself,
+ * which calls are routed by (PAR-514): its tabs, and when its window last had focus, missing from a copy too old to
+ * say. A screenshot is a snippet Parity writes, so it answers as `exec` does.
  */
-interface OperationError {
-  code: ErrorCode;
-  message: string;
-  /** Whether sending the same request again, unchanged, can succeed: the app was starting, or edits collided. */
-  retryable: boolean;
-  /** A JSON pointer to the input at fault, such as `/design` or `/edits/0/find`, in the operation's field names. */
-  path?: string;
-  /** Valid ids to use instead of an unknown or ambiguous one, closest first, at most 20. */
-  alternatives?: string[];
-  /** A failed snippet's id: retry it with `editId` and `edits` instead of sending it again. */
-  editId?: string;
-}
-interface Edit {
-  find: string;
-  replace: string;
-  all?: boolean;
-}
-interface Screenshot {
-  path: string;
-  png: string;
-  design: string;
-  state: string;
-  mode: string;
-}
-/** What one `Replace` threw away: the patches keyed to the old node and what was inside it (PAR-455). */
-interface Discarded {
-  design: string;
-  replaced: string;
-  replacement: string;
-  nodes: {
-    id: string;
-    name?: string;
-    viewports?: string[];
-    states?: string[];
-    variants?: string[];
-  }[];
-}
+declare const replies: {
+  copy: z.ZodObject<{
+    tabs: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      root: z.ZodString;
+      active: z.ZodBoolean;
+      status: z.ZodEnum<{
+        error: "error";
+        loading: "loading";
+        ready: "ready";
+      }>;
+      error: z.ZodOptional<z.ZodString>;
+      designs: z.ZodInt;
+    }, z.core.$loose>>;
+    focusedAt: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$loose>;
+  tabs: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    root: z.ZodString;
+    active: z.ZodBoolean;
+    status: z.ZodEnum<{
+      error: "error";
+      loading: "loading";
+      ready: "ready";
+    }>;
+    error: z.ZodOptional<z.ZodString>;
+    designs: z.ZodInt;
+  }, z.core.$loose>>;
+  state: z.ZodObject<{
+    tab: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      root: z.ZodString;
+      active: z.ZodBoolean;
+      status: z.ZodEnum<{
+        error: "error";
+        loading: "loading";
+        ready: "ready";
+      }>;
+      error: z.ZodOptional<z.ZodString>;
+      designs: z.ZodInt;
+    }, z.core.$loose>;
+    revision: z.ZodOptional<z.ZodString>;
+    selection: z.ZodObject<{
+      design: z.ZodOptional<z.ZodString>;
+      node: z.ZodOptional<z.ZodString>;
+      mode: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    designs: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      kind: z.ZodString;
+      file: z.ZodString;
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+      width: z.ZodOptional<z.ZodNumber>;
+      height: z.ZodOptional<z.ZodNumber>;
+      states: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+      }, z.core.$loose>>;
+      showing: z.ZodObject<{
+        state: z.ZodString;
+        mode: z.ZodString;
+        beside: z.ZodArray<z.ZodString>;
+      }, z.core.$loose>;
+      nodes: z.ZodInt;
+    }, z.core.$loose>>;
+    overlaps: z.ZodArray<z.ZodObject<{
+      designs: z.ZodArray<z.ZodString>;
+      names: z.ZodArray<z.ZodString>;
+      width: z.ZodOptional<z.ZodNumber>;
+      height: z.ZodOptional<z.ZodNumber>;
+      titleOnly: z.ZodOptional<z.ZodBoolean>;
+      estimated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    modes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      width: z.ZodNumber;
+      primary: z.ZodBoolean;
+    }, z.core.$loose>>;
+    components: z.ZodArray<z.ZodString>;
+    tokens: z.ZodObject<{
+      count: z.ZodInt;
+      semantic: z.ZodArray<z.ZodString>;
+      themeCategories: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>;
+    viewport: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    detection: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$loose>;
+  status: z.ZodObject<{
+    tab: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$loose>;
+    revision: z.ZodString;
+    dirty: z.ZodBoolean;
+    autosave: z.ZodBoolean;
+    unsaved: z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      kind: z.ZodEnum<{
+        document: "document";
+        stylesheet: "stylesheet";
+      }>;
+      designs: z.ZodOptional<z.ZodObject<{
+        added: z.ZodArray<z.ZodString>;
+        changed: z.ZodArray<z.ZodString>;
+        removed: z.ZodArray<z.ZodString>;
+      }, z.core.$loose>>;
+      modes: z.ZodOptional<z.ZodBoolean>;
+      tokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      more: z.ZodOptional<z.ZodInt>;
+    }, z.core.$loose>>;
+    tokenEdits: z.ZodInt;
+    save: z.ZodObject<{
+      status: z.ZodEnum<{
+        failed: "failed";
+        saved: "saved";
+        saving: "saving";
+        unsaved: "unsaved";
+      }>;
+      error: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    errors: z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      error: z.ZodString;
+    }, z.core.$loose>>;
+    undo: z.ZodObject<{
+      count: z.ZodInt;
+      labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>;
+    redo: z.ZodObject<{
+      count: z.ZodInt;
+      labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>;
+  }, z.core.$loose>;
+  modes: z.ZodObject<{
+    tab: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$loose>;
+    variables: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      kind: z.ZodEnum<{
+        custom: "custom";
+        locale: "locale";
+        theme: "theme";
+        viewport: "viewport";
+      }>;
+      options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        device: z.ZodOptional<z.ZodString>;
+        className: z.ZodOptional<z.ZodString>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+      }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    viewports: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+      device: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    modes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      primary: z.ZodBoolean;
+      viewport: z.ZodString;
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+      values: z.ZodRecord<z.ZodString, z.ZodString>;
+      classNames: z.ZodArray<z.ZodString>;
+      attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$loose>>;
+    designs: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      state: z.ZodString;
+      states: z.ZodArray<z.ZodString>;
+      main: z.ZodString;
+      beside: z.ZodArray<z.ZodString>;
+      frames: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        mode: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodOptional<z.ZodNumber>;
+        window: z.ZodObject<{
+          width: z.ZodNumber;
+          height: z.ZodNumber;
+        }, z.core.$loose>;
+      }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+  }, z.core.$loose>;
+  open: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    root: z.ZodString;
+    active: z.ZodBoolean;
+    status: z.ZodEnum<{
+      error: "error";
+      loading: "loading";
+      ready: "ready";
+    }>;
+    error: z.ZodOptional<z.ZodString>;
+    designs: z.ZodInt;
+  }, z.core.$loose>;
+  exec: z.ZodObject<{
+    ok: z.ZodBoolean;
+    applied: z.ZodBoolean;
+    output: z.ZodArray<z.ZodString>;
+    warnings: z.ZodArray<z.ZodString>;
+    warningGroups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      category: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        suggestion: "suggestion";
+        warning: "warning";
+      }>;
+      message: z.ZodString;
+      count: z.ZodInt;
+      at: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>>>;
+    error: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodUnknown>;
+    editId: z.ZodOptional<z.ZodString>;
+    created: z.ZodRecord<z.ZodString, z.ZodString>;
+    discarded: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      design: z.ZodString;
+      replaced: z.ZodString;
+      replacement: z.ZodString;
+      nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        viewports: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        states: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        variants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+    screenshots: z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      png: z.ZodString;
+      design: z.ZodString;
+      state: z.ZodString;
+      mode: z.ZodString;
+    }, z.core.$loose>>;
+  }, z.core.$loose>;
+  screenshot: z.ZodObject<{
+    ok: z.ZodBoolean;
+    applied: z.ZodBoolean;
+    output: z.ZodArray<z.ZodString>;
+    warnings: z.ZodArray<z.ZodString>;
+    warningGroups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      category: z.ZodString;
+      severity: z.ZodEnum<{
+        error: "error";
+        suggestion: "suggestion";
+        warning: "warning";
+      }>;
+      message: z.ZodString;
+      count: z.ZodInt;
+      at: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>>>;
+    error: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodUnknown>;
+    editId: z.ZodOptional<z.ZodString>;
+    created: z.ZodRecord<z.ZodString, z.ZodString>;
+    discarded: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      design: z.ZodString;
+      replaced: z.ZodString;
+      replacement: z.ZodString;
+      nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        viewports: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        states: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        variants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+    screenshots: z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      png: z.ZodString;
+      design: z.ZodString;
+      state: z.ZodString;
+      mode: z.ZodString;
+    }, z.core.$loose>>;
+  }, z.core.$loose>;
+  problems: z.ZodObject<{
+    tab: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$loose>;
+    design: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$loose>;
+    problems: z.ZodArray<z.ZodObject<{
+      state: z.ZodString;
+      mode: z.ZodString;
+      kind: z.ZodOptional<z.ZodEnum<{
+        clipped: "clipped";
+        "content-wider": "content-wider";
+        "frame-overflow": "frame-overflow";
+        "render-error": "render-error";
+        "unknown-component": "unknown-component";
+      }>>;
+      problem: z.ZodString;
+      node: z.ZodOptional<z.ZodString>;
+      name: z.ZodOptional<z.ZodString>;
+      box: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+      }, z.core.$loose>>;
+      container: z.ZodOptional<z.ZodObject<{
+        node: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        box: z.ZodObject<{
+          x: z.ZodNumber;
+          y: z.ZodNumber;
+          width: z.ZodNumber;
+          height: z.ZodNumber;
+        }, z.core.$loose>;
+      }, z.core.$loose>>;
+      overflow: z.ZodOptional<z.ZodObject<{
+        left: z.ZodOptional<z.ZodNumber>;
+        right: z.ZodOptional<z.ZodNumber>;
+        top: z.ZodOptional<z.ZodNumber>;
+        bottom: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    frames: z.ZodInt;
+    warnings: z.ZodArray<z.ZodString>;
+  }, z.core.$loose>;
+  accessibility: z.ZodObject<{
+    tab: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$loose>;
+    design: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$loose>;
+    findings: z.ZodArray<z.ZodObject<{
+      state: z.ZodString;
+      mode: z.ZodString;
+      rule: z.ZodString;
+      impact: z.ZodEnum<{
+        critical: "critical";
+        minor: "minor";
+        moderate: "moderate";
+        serious: "serious";
+      }>;
+      help: z.ZodString;
+      helpUrl: z.ZodString;
+      node: z.ZodOptional<z.ZodString>;
+      name: z.ZodOptional<z.ZodString>;
+      detail: z.ZodString;
+      contrast: z.ZodOptional<z.ZodObject<{
+        fix: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodObject<{
+          token: z.ZodString;
+          ratio: z.ZodNumber;
+        }, z.core.$loose>]>>;
+      }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    frames: z.ZodInt;
+    warnings: z.ZodArray<z.ZodString>;
+  }, z.core.$loose>;
+  console: z.ZodObject<{
+    tab: z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+    }, z.core.$loose>;
+    entries: z.ZodArray<z.ZodObject<{
+      level: z.ZodEnum<{
+        debug: "debug";
+        error: "error";
+        info: "info";
+        warning: "warning";
+      }>;
+      text: z.ZodString;
+      source: z.ZodString;
+      line: z.ZodInt;
+      where: z.ZodEnum<{
+        canvas: "canvas";
+        offscreen: "offscreen";
+      }>;
+      count: z.ZodInt;
+      first: z.ZodNumber;
+      last: z.ZodNumber;
+    }, z.core.$loose>>;
+  }, z.core.$loose>;
+  tokens: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    category: z.ZodString;
+    source: z.ZodString;
+    values: z.ZodRecord<z.ZodString, z.ZodString>;
+  }, z.core.$loose>>;
+  components: z.ZodObject<{
+    components: z.ZodArray<z.ZodString>;
+    iconLibraries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    leftOut: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      path: z.ZodString;
+      reason: z.ZodString;
+      undecided: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+    drawn: z.ZodOptional<z.ZodInt>;
+    failing: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      problem: z.ZodEnum<{
+        async: "async";
+        error: "error";
+        provider: "provider";
+        server: "server";
+      }>;
+      reason: z.ZodString;
+    }, z.core.$loose>>>;
+    corrections: z.ZodOptional<z.ZodObject<{
+      include: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        export: z.ZodString;
+      }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+  }, z.core.$loose>;
+  props: z.ZodObject<{
+    component: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    import: z.ZodOptional<z.ZodString>;
+    known: z.ZodBoolean;
+    props: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      kind: z.ZodEnum<{
+        boolean: "boolean";
+        enum: "enum";
+        function: "function";
+        node: "node";
+        number: "number";
+        object: "object";
+        string: "string";
+        unknown: "unknown";
+      }>;
+      group: z.ZodEnum<{
+        aria: "aria";
+        event: "event";
+        html: "html";
+        own: "own";
+        variant: "variant";
+      }>;
+      options: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+      default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+      required: z.ZodOptional<z.ZodBoolean>;
+      type: z.ZodOptional<z.ZodString>;
+      description: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    composition: z.ZodOptional<z.ZodObject<{
+      role: z.ZodEnum<{
+        component: "component";
+        provider: "provider";
+        wrapper: "wrapper";
+      }>;
+      parents: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"listed">;
+        chain: z.ZodArray<z.ZodObject<{
+          component: z.ZodString;
+          optional: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>;
+        from: z.ZodOptional<z.ZodString>;
+      }, z.core.$loose>, z.ZodObject<{
+        status: z.ZodLiteral<"none">;
+      }, z.core.$loose>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+      }, z.core.$loose>], "status">;
+      holds: z.ZodArray<z.ZodString>;
+      slots: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        key: z.ZodString;
+        kind: z.ZodEnum<{
+          children: "children";
+          element: "element";
+          render: "render";
+        }>;
+      }, z.core.$loose>>;
+      example: z.ZodObject<{
+        node: z.ZodUnknown;
+        status: z.ZodEnum<{
+          drawn: "drawn";
+          failing: "failing";
+          untried: "untried";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+      }, z.core.$loose>;
+    }, z.core.$loose>>;
+  }, z.core.$loose>;
+};
+declare const tabsResult: z.ZodObject<{
+  tabs: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    root: z.ZodString;
+    active: z.ZodBoolean;
+    status: z.ZodEnum<{
+      error: "error";
+      loading: "loading";
+      ready: "ready";
+    }>;
+    error: z.ZodOptional<z.ZodString>;
+    designs: z.ZodInt;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const consoleResult: z.ZodObject<{
+  tab: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+  }, z.core.$loose>;
+  total: z.ZodInt;
+  truncated: z.ZodBoolean;
+  entries: z.ZodArray<z.ZodObject<{
+    level: z.ZodEnum<{
+      debug: "debug";
+      error: "error";
+      info: "info";
+      warning: "warning";
+    }>;
+    text: z.ZodString;
+    source: z.ZodString;
+    line: z.ZodInt;
+    where: z.ZodEnum<{
+      canvas: "canvas";
+      offscreen: "offscreen";
+    }>;
+    count: z.ZodInt;
+    first: z.ZodNumber;
+    last: z.ZodNumber;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const tokensResult: z.ZodObject<{
+  total: z.ZodInt;
+  truncated: z.ZodBoolean;
+  tokens: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    category: z.ZodString;
+    source: z.ZodString;
+    values: z.ZodRecord<z.ZodString, z.ZodString>;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+type TabsResponse = z.output<typeof tabsResult>;
+type ConsoleResponse = z.output<typeof consoleResult>;
+type TokensResponse = z.output<typeof tokensResult>;
+/** What the app answers: a failure's message, with its details beside it when the app knew the cause. */
+type ExecReply = z.output<typeof replies.exec>;
+type Screenshot = ExecReply["screenshots"][number];
+type Edit = z.output<(typeof requests.exec.options)[1]>["edits"][number];
+/** The canonical result: the reply with its failure as one error, which carries the editId to retry a snippet by. */
+declare const execResult: z.ZodObject<{
+  ok: z.ZodBoolean;
+  applied: z.ZodBoolean;
+  output: z.ZodArray<z.ZodString>;
+  warnings: z.ZodArray<z.ZodString>;
+  warningGroups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    category: z.ZodString;
+    severity: z.ZodEnum<{
+      error: "error";
+      suggestion: "suggestion";
+      warning: "warning";
+    }>;
+    message: z.ZodString;
+    count: z.ZodInt;
+    at: z.ZodArray<z.ZodString>;
+  }, z.core.$loose>>>;
+  created: z.ZodRecord<z.ZodString, z.ZodString>;
+  discarded: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    design: z.ZodString;
+    replaced: z.ZodString;
+    replacement: z.ZodString;
+    nodes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodOptional<z.ZodString>;
+      viewports: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      states: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      variants: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
+  }, z.core.$loose>>>;
+  screenshots: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    png: z.ZodString;
+    design: z.ZodString;
+    state: z.ZodString;
+    mode: z.ZodString;
+  }, z.core.$loose>>;
+  error: z.ZodOptional<z.ZodObject<{
+    code: z.ZodEnum<{
+      ambiguous_reference: "ambiguous_reference";
+      app_error: "app_error";
+      conflict: "conflict";
+      execution_failed: "execution_failed";
+      invalid_input: "invalid_input";
+      not_answering: "not_answering";
+      not_running: "not_running";
+      tab_not_ready: "tab_not_ready";
+      unknown_component: "unknown_component";
+      unknown_design: "unknown_design";
+      unknown_edit_id: "unknown_edit_id";
+      unknown_icon_set: "unknown_icon_set";
+      unknown_mode: "unknown_mode";
+      unknown_node: "unknown_node";
+      unknown_state: "unknown_state";
+      unknown_tab: "unknown_tab";
+      unknown_viewport: "unknown_viewport";
+    }>;
+    message: z.ZodString;
+    retryable: z.ZodBoolean;
+    path: z.ZodOptional<z.ZodString>;
+    alternatives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    editId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$loose>;
+type ExecResponse = z.output<typeof execResult>;
 /**
- * Findings with the same category and message, once, with every place they were found (PAR-460). The app's
- * `warnings` are these as lines, in the same order.
+ * A failed call, the same in CLI `--json` and MCP `structuredContent`: a stable code to branch on, the message people
+ * read, whether the same request can succeed when sent again, the input at fault, and what to use instead. What each
+ * field means is in the CLI's README and the skill, too.
  */
-interface WarningGroup {
-  category: string;
-  severity: "error" | "warning" | "suggestion";
-  message: string;
-  count: number;
-  at: string[];
-}
-/** The canonical result. Structured output is this without the screenshots' image data. */
-interface ExecResponse {
-  ok: boolean;
-  applied: boolean;
-  output: string[];
-  warnings: string[];
-  warningGroups?: WarningGroup[];
-  /** Set when the call failed, with the editId to retry a snippet by. */
-  error?: OperationError;
-  created: Record<string, string>;
-  /** Set when a Replace threw away responsive, state or variant patches. */
-  discarded?: Discarded[];
-  screenshots: Screenshot[];
-}
+declare const failure: z.ZodObject<{
+  code: z.ZodEnum<{
+    ambiguous_reference: "ambiguous_reference";
+    app_error: "app_error";
+    conflict: "conflict";
+    execution_failed: "execution_failed";
+    invalid_input: "invalid_input";
+    not_answering: "not_answering";
+    not_running: "not_running";
+    tab_not_ready: "tab_not_ready";
+    unknown_component: "unknown_component";
+    unknown_design: "unknown_design";
+    unknown_edit_id: "unknown_edit_id";
+    unknown_icon_set: "unknown_icon_set";
+    unknown_mode: "unknown_mode";
+    unknown_node: "unknown_node";
+    unknown_state: "unknown_state";
+    unknown_tab: "unknown_tab";
+    unknown_viewport: "unknown_viewport";
+  }>;
+  message: z.ZodString;
+  retryable: z.ZodBoolean;
+  path: z.ZodOptional<z.ZodString>;
+  alternatives: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  editId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type OperationError = z.output<typeof failure>;
 /**
  * Where running copies of the app say how to reach them: `~/.parity/agents`, or the one file `PARITY_AGENT_FILE` names
  * for a copy kept apart from the person's.
  */
 export declare const registry: Registry;
+/** One open project. */
+export type TabSummary = z.output<typeof replies.open>;
+export type StateResponse = z.output<typeof replies.state>;
+export type StatusResponse = z.output<typeof replies.status>;
+export type ModesResponse = z.output<typeof replies.modes>;
+export type AccessibilityResponse = z.output<typeof replies.accessibility>;
+export type AccessibilityFinding = AccessibilityResponse["findings"][number];
+export type ProblemsResponse = z.output<typeof replies.problems>;
+export type Problem = ProblemsResponse["problems"][number];
+/** A box in a frame, in CSS pixels from its top left corner. */
+export type FrameBox = NonNullable<Problem["box"]>;
+export type TokenInfo = z.output<typeof replies.tokens>[number];
+export type ComponentsResponse = z.output<typeof replies.components>;
+/** One of the app's exports, by its file and export name. */
+export type ComponentRef = NonNullable<NonNullable<ComponentsResponse["corrections"]>["include"]>[number];
+export type PropsResponse = z.output<typeof replies.props>;
+/** A component's composition, as `@parity-app/editor`'s `componentComposition` reads it. */
+export type Composition = NonNullable<PropsResponse["composition"]>;
+export type ConsoleEntry = z.output<typeof replies.console>["entries"][number];
 /**
  * Names who's calling in later calls, so the canvas can say who's at work. The MCP server learns the name from its
  * client, and is one session: its calls share an id, apart from any other session of the same agent.
@@ -119,327 +785,35 @@ export declare function setCaller(name: string | undefined, session?: boolean):
 export type Routing = "tab" | "open" | "copies";
 /**
  * Calls the running Parity app: the copy that has the call's project open, with the exact tab it chose, by the rules
- * in `@parity-app/agent/routing`. Fails with a clear message, and a code, when no copy is running, none has the
- * project, or the call fails: the app's own code when it gives one.
+ * in `@parity-app/agent/routing`, and returns its answer once `reply` has checked it. Fails with a clear message, and a
+ * code, when no copy is running, none has the project, or the call fails: the app's own code when it gives one.
  */
-export declare function call<T>(method: string, params?: Record<string, unknown>, routing?: Routing): Promise<T>;
+export declare function call<Reply extends z.ZodType>(method: string, params: Record<string, unknown>, routing: Routing, reply: Reply): Promise<z.output<Reply>>;
 /** A readable account of an exec call, for terminals and for agents. */
 export declare function describeExec(result: ExecResponse): string;
-/** One open project. */
-export interface TabSummary {
-  id: string;
-  name: string;
-  root: string;
-  active: boolean;
-  status: "loading" | "ready" | "error";
-  error?: string;
-  designs: number;
-}
-export interface TabsResponse {
-  tabs: TabSummary[];
-}
-export interface StatusResponse {
-  tab: {
-    id: string;
-    name: string;
-  };
-  /** Opaque: the same only while nothing in the tab has changed. */
-  revision: string;
-  /** Something applied (and undoable) isn't on disk yet. */
-  dirty: boolean;
-  /** Changes save themselves a moment later; otherwise they wait for the person to save. */
-  autosave: boolean;
-  unsaved: {
-    path: string;
-    kind: "document" | "stylesheet";
-    designs?: {
-      added: string[];
-      changed: string[];
-      removed: string[];
-    };
-    modes?: boolean;
-    tokens?: string[];
-    more?: number;
-  }[];
-  tokenEdits: number;
-  save: {
-    status: "saved" | "unsaved" | "saving" | "failed";
-    error?: string;
-  };
-  errors: {
-    path: string;
-    error: string;
-  }[];
-  undo: {
-    count: number;
-    labels?: string[];
-  };
-  redo: {
-    count: number;
-    labels?: string[];
-  };
-}
 /** Where a tab's edits stand: the revision, what's applied and undoable, what's on disk, and what failed to write. */
 export declare function describeStatus(result: StatusResponse): string;
-export interface ModesResponse {
-  tab: {
-    id: string;
-    name: string;
-  };
-  variables: {
-    id: string;
-    name: string;
-    kind: "viewport" | "theme" | "locale" | "custom";
-    options: {
-      id: string;
-      name: string;
-      width?: number;
-      height?: number;
-      device?: string;
-      className?: string;
-      attributes?: Record<string, string>;
-    }[];
-  }[];
-  /** Viewport options: the ids Responsive takes, with the window each stands for. */
-  viewports: {
-    id: string;
-    name: string;
-    width: number;
-    height: number;
-    device?: string;
-  }[];
-  /** Modes: the ids renders take, each a combination of one option per variable. */
-  modes: {
-    id: string;
-    name: string;
-    primary: boolean;
-    viewport: string;
-    width: number;
-    height: number;
-    values: Record<string, string>;
-    classNames: string[];
-    attributes: Record<string, string>;
-  }[];
-  designs: {
-    id: string;
-    name: string;
-    state: string;
-    states: string[];
-    main: string;
-    beside: string[];
-    frames?: {
-      mode: string;
-      width: number;
-      height?: number;
-      window: {
-        width: number;
-        height: number;
-      };
-    }[];
-  }[];
-}
 /**
  * The project's viewports (what Responsive takes), its other variables, its modes (what renders take) and what each
  * design's board shows, with a named design's frames.
  */
 export declare function describeModes(result: ModesResponse): string;
-export interface AccessibilityFinding {
-  state: string;
-  mode: string;
-  rule: string;
-  impact: "critical" | "serious" | "moderate" | "minor";
-  help: string;
-  helpUrl: string;
-  node?: string;
-  name?: string;
-  detail: string;
-  /** For a contrast failure: the token to color the layer's text with, or `"none"` when none of the project's pass. */
-  contrast?: {
-    fix?: {
-      token: string;
-      ratio: number;
-    } | "none";
-  };
-}
-export interface AccessibilityResponse {
-  tab: {
-    id: string;
-    name: string;
-  };
-  design: {
-    id: string;
-    name: string;
-  };
-  findings: AccessibilityFinding[];
-  frames: number;
-  warnings: string[];
-}
 /**
  * A readable account of an accessibility check: each rule broken, worst first, with the layers that break it, the
  * frames they break it in and what's wrong. Alike layers, such as the rows of a list, share a line.
  */
 export declare function describeAccessibility(result: AccessibilityResponse): string;
-export interface ProblemsResponse {
-  tab: {
-    id: string;
-    name: string;
-  };
-  design: {
-    id: string;
-    name: string;
-  };
-  problems: Problem[];
-  frames: number;
-  warnings: string[];
-}
-/** A box in a frame, in CSS pixels from its top left corner. */
-export interface FrameBox {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
-/**
- * One problem in one frame. Layout problems (`frame-overflow`, `clipped`) name the node, what it overflows (the node
- * that clips it, or the frame, which has none), both boxes, and how far past each edge it reaches.
- */
-export interface Problem {
-  state: string;
-  mode: string;
-  kind?: "render-error" | "unknown-component" | "content-wider" | "frame-overflow" | "clipped";
-  problem: string;
-  node?: string;
-  name?: string;
-  box?: FrameBox;
-  container?: {
-    node?: string;
-    name?: string;
-    box: FrameBox;
-  };
-  overflow?: {
-    left?: number;
-    right?: number;
-    top?: number;
-    bottom?: number;
-  };
-}
 /** A readable account of the layout problems in a design's frames, each once with the frames it's in. */
 export declare function describeProblems(result: ProblemsResponse): string;
-export interface TokenInfo {
-  name: string;
-  category: string;
-  source: string;
-  values: Record<string, string>;
-}
-export interface TokensResponse {
-  tokens: TokenInfo[];
-  /** How many matched, before the limit. */
-  total: number;
-  truncated: boolean;
-}
 /** Tokens by category, each with its value in every theme that sets one. */
 export declare function describeTokens({ tokens, total, truncated }: TokensResponse): string;
-export interface ComponentsResponse {
-  components: string[];
-  iconLibraries?: string[];
-  /** The app's capitalised exports the type checker left out, with why. */
-  leftOut?: {
-    name: string;
-    path: string;
-    reason: string;
-    undecided?: true;
-  }[];
-  /** How many components have drawn on the canvas without errors so far. */
-  drawn?: number;
-  /** Components failing to draw on the canvas now: why in words, and the kind of problem. */
-  failing?: {
-    id: string;
-    problem: "provider" | "server" | "async" | "error";
-    reason: string;
-  }[];
-  /** The person's corrections in the main project file, saved or not: exports listed by hand. */
-  corrections?: {
-    include?: ComponentRef[];
-  };
-}
-/** One of the app's exports, by its file and export name. */
-export interface ComponentRef {
-  path: string;
-  export: string;
-}
 /**
  * The project's own components, then each library's, then the icon libraries, then the exports left out and why, the
  * components failing to draw and why, and what the person corrected by hand.
  */
 export declare function describeComponents({ components, iconLibraries, leftOut, drawn, failing, corrections }: ComponentsResponse): string;
-export interface PropsResponse {
-  component: string;
-  path?: string;
-  /** What the project's code imports it from: a package, or the file through the app's alias. */
-  import?: string;
-  known: boolean;
-  props: {
-    name: string;
-    kind: string;
-    group?: string;
-    options?: (string | number | boolean)[];
-    default?: string | number | boolean | null;
-    required?: boolean;
-  }[];
-  /** What it needs around it and holds inside it, read from its library's metadata (PAR-454). */
-  composition?: Composition;
-}
-/** A component's composition, as `@parity-app/editor`'s `componentComposition` reads it. */
-export interface Composition {
-  role: "provider" | "wrapper" | "component";
-  parents: {
-    status: "listed";
-    chain: {
-      component: string;
-      optional?: true;
-    }[];
-    from?: string;
-  } | {
-    status: "none";
-  } | {
-    status: "unknown";
-    reason: string;
-  };
-  holds: string[];
-  slots: {
-    name: string;
-    key: string;
-    kind: "children" | "element" | "render";
-  }[];
-  example: {
-    node: unknown;
-    status: "drawn" | "failing" | "untried";
-    reason?: string;
-  };
-}
 /** A component's props, with each variant's options and default, then what it needs around it and holds. */
 export declare function describeProps(result: PropsResponse): string;
-export interface ConsoleEntry {
-  level: "info" | "warning" | "error" | "debug";
-  text: string;
-  source: string;
-  line: number;
-  where: "canvas" | "offscreen";
-  count: number;
-  first: number;
-  last: number;
-}
-export interface ConsoleResponse {
-  tab: {
-    id: string;
-    name: string;
-  };
-  /** The newest entries, up to the limit, oldest first. */
-  entries: ConsoleEntry[];
-  /** How many there were, before the limit. */
-  total: number;
-  truncated: boolean;
-}
 /** A readable account of what a project's code wrote to the console, oldest first, with where each came from. */
 export declare function describeConsole(result: ConsoleResponse): string;
-export type { Edit, ExecResponse, OperationError, Screenshot };
+export type { ConsoleResponse, Edit, ExecResponse, OperationError, Screenshot, TabsResponse, TokensResponse };