---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (2, 6),
  },
  target: LetIn {
   bindings: [
    Inherit(
     Some(
      PropertyAccess {
       expression: Variable {
        identifier: "config",
        position: (4, 12),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "services",
          position: (4, 19),
         },
        ],
       },
       default: None,
      },
     ),
     [
      Raw {
       content: "nginx",
       position: (4, 29),
      },
      Raw {
       content: "postfix",
       position: (4, 35),
      },
      Raw {
       content: "postgresql",
       position: (4, 43),
      },
      Raw {
       content: "redis",
       position: (4, 54),
      },
     ],
    ),
    Inherit(
     Some(
      PropertyAccess {
       expression: Variable {
        identifier: "config",
        position: (5, 12),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "users",
          position: (5, 19),
         },
        ],
       },
       default: None,
      },
     ),
     [
      Raw {
       content: "users",
       position: (5, 26),
      },
      Raw {
       content: "groups",
       position: (5, 32),
      },
     ],
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (6, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (6, 16),
        },
        Raw {
         content: "sourcehut",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "domain",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (7, 12),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "settings",
         position: (7, 16),
        },
        Expression {
         expression: String {
          parts: [
           Raw {
            content: "sr.ht",
            position: (7, 26),
           },
          ],
         },
        },
        Raw {
         content: "global-domain",
         position: (7, 33),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "settingsFormat",
        position: (8, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (8, 20),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "formats",
          position: (8, 25),
         },
         Raw {
          content: "ini",
          position: (8, 33),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "listToValue",
             position: (9, 5),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "concatMapStringsSep",
            position: (9, 19),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ",",
               position: (9, 40),
              },
             ],
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "generators",
               position: (9, 44),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "mkValueStringDefault",
                 position: (9, 55),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Map {
               bindings: [],
               recursive: false,
               position: (9, 76),
              },
             ],
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "mkKeyValue",
             position: (10, 5),
            },
           ],
          },
          Function {
           argument: Some(
            "k",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "v",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: IfThenElse {
             predicate: BinaryOperation {
              operator: EqualTo,
              operands: [
               Variable {
                identifier: "v",
                position: (11, 10),
               },
               Variable {
                identifier: "null",
                position: (11, 15),
               },
              ],
              position: (11, 12),
             },
             then: String {
              parts: [],
             },
             else_: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "generators",
                position: (12, 12),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "mkKeyValueDefault",
                  position: (12, 23),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "mkValueString",
                     position: (13, 9),
                    },
                   ],
                  },
                  Function {
                   argument: Some(
                    "v",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: IfThenElse {
                    predicate: BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      Variable {
                       identifier: "v",
                       position: (14, 14),
                      },
                      Variable {
                       identifier: "true",
                       position: (14, 19),
                      },
                     ],
                     position: (14, 16),
                    },
                    then: String {
                     parts: [
                      Raw {
                       content: "yes",
                       position: (14, 30),
                      },
                     ],
                    },
                    else_: IfThenElse {
                     predicate: BinaryOperation {
                      operator: EqualTo,
                      operands: [
                       Variable {
                        identifier: "v",
                        position: (15, 19),
                       },
                       Variable {
                        identifier: "false",
                        position: (15, 24),
                       },
                      ],
                      position: (15, 21),
                     },
                     then: String {
                      parts: [
                       Raw {
                        content: "no",
                        position: (15, 36),
                       },
                      ],
                     },
                     else_: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "generators",
                        position: (16, 16),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "mkValueStringDefault",
                          position: (16, 27),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       Map {
                        bindings: [],
                        recursive: false,
                        position: (16, 48),
                       },
                       Variable {
                        identifier: "v",
                        position: (16, 51),
                       },
                      ],
                     },
                     position: (15, 16),
                    },
                    position: (14, 11),
                   },
                   position: (13, 25),
                  },
                 ),
                ],
                recursive: false,
                position: (12, 41),
               },
               String {
                parts: [
                 Raw {
                  content: "=",
                  position: (17, 10),
                 },
                ],
               },
               Variable {
                identifier: "k",
                position: (17, 13),
               },
               Variable {
                identifier: "v",
                position: (17, 15),
               },
              ],
             },
             position: (11, 7),
            },
            position: (10, 21),
           },
           position: (10, 18),
          },
         ),
        ],
        recursive: false,
        position: (8, 37),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configIniOfService",
        position: (19, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "srv",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "settingsFormat",
         position: (19, 29),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "generate",
           position: (19, 44),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "sourcehut-",
           position: (19, 54),
          },
          Expression {
           expression: Variable {
            identifier: "srv",
            position: (19, 66),
           },
          },
          Raw {
           content: "-config.ini",
           position: (19, 70),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "filterAttrs",
          position: (21, 6),
         },
         arguments: [
          Function {
           argument: Some(
            "k",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "v",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: BinaryOperation {
             operator: NotEqualTo,
             operands: [
              Variable {
               identifier: "v",
               position: (21, 25),
              },
              Variable {
               identifier: "null",
               position: (21, 30),
              },
             ],
             position: (21, 27),
            },
            position: (21, 22),
           },
           position: (21, 19),
          },
          FunctionApplication {
           function: Variable {
            identifier: "mapAttrs",
            position: (22, 6),
           },
           arguments: [
            Function {
             argument: Some(
              "section",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: Function {
              argument: Some(
               "v",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "srvMatch",
                    position: (23, 11),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "builtins",
                    position: (23, 22),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "match",
                      position: (23, 31),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "^([a-z]*)\\.sr\\.ht(::.*)?$",
                      position: (23, 38),
                     },
                    ],
                   },
                   Variable {
                    identifier: "section",
                    position: (23, 67),
                   },
                  ],
                 },
                ),
               ],
               target: IfThenElse {
                predicate: BinaryOperation {
                 operator: LogicalOr,
                 operands: [
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    Variable {
                     identifier: "srvMatch",
                     position: (24, 10),
                    },
                    Variable {
                     identifier: "null",
                     position: (24, 22),
                    },
                   ],
                   position: (24, 19),
                  },
                  BinaryOperation {
                   operator: EqualTo,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "head",
                      position: (25, 10),
                     },
                     arguments: [
                      Variable {
                       identifier: "srvMatch",
                       position: (25, 15),
                      },
                     ],
                    },
                    Variable {
                     identifier: "srv",
                     position: (25, 27),
                    },
                   ],
                   position: (25, 24),
                  },
                 ],
                 position: (25, 7),
                },
                then: Variable {
                 identifier: "v",
                 position: (26, 12),
                },
                else_: IfThenElse {
                 predicate: BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "tail",
                       position: (28, 15),
                      },
                      arguments: [
                       Variable {
                        identifier: "srvMatch",
                        position: (28, 20),
                       },
                      ],
                     },
                     List {
                      elements: [
                       Variable {
                        identifier: "null",
                        position: (28, 34),
                       },
                      ],
                      position: (28, 32),
                     },
                    ],
                    position: (28, 29),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "elem",
                     position: (28, 44),
                    },
                    arguments: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "head",
                       position: (28, 50),
                      },
                      arguments: [
                       Variable {
                        identifier: "srvMatch",
                        position: (28, 55),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (28, 65),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "services",
                         position: (28, 69),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  ],
                  position: (28, 41),
                 },
                 then: Map {
                  bindings: [
                   Inherit(
                    Some(
                     Variable {
                      identifier: "v",
                      position: (30, 18),
                     },
                    ),
                    [
                     Raw {
                      content: "origin",
                      position: (30, 21),
                     },
                    ],
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "oauth-client-id",
                       position: (32, 9),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "v",
                      position: (32, 27),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "oauth-client-id",
                        position: (32, 29),
                       },
                      ],
                     },
                     default: Some(
                      Variable {
                       identifier: "null",
                       position: (32, 48),
                      },
                     ),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (29, 12),
                 },
                 else_: Variable {
                  identifier: "null",
                  position: (35, 12),
                 },
                 position: (28, 12),
                },
                position: (24, 7),
               },
               position: (23, 7),
              },
              position: (22, 25),
             },
             position: (22, 16),
            },
            FunctionApplication {
             function: Variable {
              identifier: "recursiveUpdate",
              position: (36, 6),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (36, 22),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "settings",
                  position: (36, 26),
                 },
                ],
               },
               default: None,
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Expression {
                    expression: String {
                     parts: [
                      Raw {
                       content: "builds.sr.ht::worker",
                       position: (39, 8),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "buildlogs",
                    position: (39, 30),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/log/sourcehut/buildsrht-worker",
                    position: (39, 43),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Expression {
                    expression: String {
                     parts: [
                      Raw {
                       content: "git.sr.ht",
                       position: (40, 8),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "post-update-script",
                    position: (40, 19),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/usr/bin/gitsrht-update-hook",
                    position: (40, 41),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Expression {
                    expression: String {
                     parts: [
                      Raw {
                       content: "git.sr.ht",
                       position: (41, 8),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "repos",
                    position: (41, 19),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/lib/sourcehut/gitsrht/repos",
                    position: (41, 28),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Expression {
                    expression: String {
                     parts: [
                      Raw {
                       content: "hg.sr.ht",
                       position: (42, 8),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "changegroup-script",
                    position: (42, 18),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/usr/bin/hgsrht-hook-changegroup",
                    position: (42, 40),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Expression {
                    expression: String {
                     parts: [
                      Raw {
                       content: "hg.sr.ht",
                       position: (43, 8),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "repos",
                    position: (43, 18),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/lib/sourcehut/hgsrht/repos",
                    position: (43, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Expression {
                    expression: String {
                     parts: [
                      Raw {
                       content: "sr.ht",
                       position: (46, 8),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "redis-host",
                    position: (46, 15),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (46, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Expression {
                     expression: Variable {
                      identifier: "srv",
                      position: (46, 34),
                     },
                    },
                    Raw {
                     content: "redis",
                     position: (46, 39),
                    },
                    Raw {
                     content: "host",
                     position: (46, 45),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (36, 35),
              },
             ],
            },
           ],
          },
         ],
        },
       ],
      },
      position: (19, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "commonServiceSettings",
        position: (48, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "srv",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "origin",
            position: (49, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (49, 14),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (50, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "URL ",
                 position: (50, 22),
                },
                Expression {
                 expression: Variable {
                  identifier: "srv",
                  position: (50, 28),
                 },
                },
                Raw {
                 content: ".sr.ht is being served at (protocol://domain)",
                 position: (50, 32),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (51, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (51, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (51, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (52, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "https://",
                 position: (52, 18),
                },
                Expression {
                 expression: Variable {
                  identifier: "srv",
                  position: (52, 28),
                 },
                },
                Raw {
                 content: ".",
                 position: (52, 32),
                },
                Expression {
                 expression: Variable {
                  identifier: "domain",
                  position: (52, 35),
                 },
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defaultText",
                 position: (53, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "https://",
                 position: (53, 22),
                },
                Expression {
                 expression: Variable {
                  identifier: "srv",
                  position: (53, 32),
                 },
                },
                Raw {
                 content: ".example.com",
                 position: (53, 36),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (49, 23),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "debug-host",
            position: (55, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (55, 18),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (56, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Address to bind the debug server to.",
                 position: (56, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (57, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "types",
                position: (57, 19),
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "nullOr",
                 position: (57, 26),
                },
                arguments: [
                 Variable {
                  identifier: "str",
                  position: (57, 33),
                 },
                ],
               },
               position: (57, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (58, 7),
                },
               ],
              },
              Variable {
               identifier: "null",
               position: (58, 17),
              },
             ),
            ],
            recursive: false,
            position: (55, 27),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "debug-port",
            position: (60, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (60, 18),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (61, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Port to bind the debug server to.",
                 position: (61, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (62, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "types",
                position: (62, 19),
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "nullOr",
                 position: (62, 26),
                },
                arguments: [
                 Variable {
                  identifier: "str",
                  position: (62, 33),
                 },
                ],
               },
               position: (62, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (63, 7),
                },
               ],
              },
              Variable {
               identifier: "null",
               position: (63, 17),
              },
             ),
            ],
            recursive: false,
            position: (60, 27),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "connection-string",
            position: (65, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (65, 25),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (66, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "SQLAlchemy connection string for the database.",
                 position: (66, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (67, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (67, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (67, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (68, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "postgresql:///localhost?user=",
                 position: (68, 18),
                },
                Expression {
                 expression: Variable {
                  identifier: "srv",
                  position: (68, 49),
                 },
                },
                Raw {
                 content: "srht&host=/run/postgresql",
                 position: (68, 53),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (65, 34),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "migrate-on-upgrade",
            position: (70, 5),
           },
          ],
         },
         BinaryOperation {
          operator: Update,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "mkEnableOption",
             position: (70, 26),
            },
            arguments: [
             String {
              parts: [
               Raw {
                content: "automatic migrations on package upgrade",
                position: (70, 42),
               },
              ],
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (70, 88),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (70, 98),
              },
             ),
            ],
            recursive: false,
            position: (70, 86),
           },
          ],
          position: (70, 83),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "oauth-client-id",
            position: (71, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (71, 23),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (72, 7),
                },
               ],
              },
              String {
               parts: [
                Expression {
                 expression: Variable {
                  identifier: "srv",
                  position: (72, 24),
                 },
                },
                Raw {
                 content: ".sr.ht's OAuth client id for meta.sr.ht.",
                 position: (72, 28),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (73, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (73, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (73, 20),
                 },
                ],
               },
               default: None,
              },
             ),
            ],
            recursive: false,
            position: (71, 32),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "oauth-client-secret",
            position: (75, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (75, 27),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (76, 7),
                },
               ],
              },
              String {
               parts: [
                Expression {
                 expression: Variable {
                  identifier: "srv",
                  position: (76, 24),
                 },
                },
                Raw {
                 content: ".sr.ht's OAuth client secret for meta.sr.ht.",
                 position: (76, 28),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (77, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (77, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "path",
                  position: (77, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "apply",
                 position: (78, 7),
                },
               ],
              },
              Function {
               argument: Some(
                "s",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: BinaryOperation {
                operator: Addition,
                operands: [
                 String {
                  parts: [
                   Raw {
                    content: "<",
                    position: (78, 19),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (78, 24),
                  },
                  arguments: [
                   Variable {
                    identifier: "s",
                    position: (78, 33),
                   },
                  ],
                 },
                ],
                position: (78, 22),
               },
               position: (78, 15),
              },
             ),
            ],
            recursive: false,
            position: (75, 36),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (48, 32),
      },
      position: (48, 27),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "python",
        position: (83, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (83, 12),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "sourcehut",
          position: (83, 17),
         },
         Raw {
          content: "python",
          position: (83, 27),
         },
         Raw {
          content: "withPackages",
          position: (83, 34),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Function {
        argument: Some(
         "ps",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: With {
         expression: Variable {
          identifier: "ps",
          position: (83, 57),
         },
         target: List {
          elements: [
           Variable {
            identifier: "gunicorn",
            position: (84, 5),
           },
           Variable {
            identifier: "eventlet",
            position: (85, 5),
           },
           Variable {
            identifier: "flower",
            position: (87, 5),
           },
           Variable {
            identifier: "srht",
            position: (89, 5),
           },
           Variable {
            identifier: "buildsrht",
            position: (90, 5),
           },
           Variable {
            identifier: "dispatchsrht",
            position: (91, 5),
           },
           Variable {
            identifier: "gitsrht",
            position: (92, 5),
           },
           Variable {
            identifier: "hgsrht",
            position: (93, 5),
           },
           Variable {
            identifier: "hubsrht",
            position: (94, 5),
           },
           Variable {
            identifier: "listssrht",
            position: (95, 5),
           },
           Variable {
            identifier: "mansrht",
            position: (96, 5),
           },
           Variable {
            identifier: "metasrht",
            position: (97, 5),
           },
           Variable {
            identifier: "pastesrht",
            position: (100, 5),
           },
           Variable {
            identifier: "todosrht",
            position: (101, 5),
           },
          ],
          position: (83, 61),
         },
         position: (83, 52),
        },
        position: (83, 48),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "mkOptionNullOrStr",
        position: (103, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "description",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "mkOption",
        position: (103, 36),
       },
       arguments: [
        Map {
         bindings: [
          Inherit(
           None,
           [
            Raw {
             content: "description",
             position: (104, 13),
            },
           ],
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "type",
              position: (105, 5),
             },
            ],
           },
           With {
            expression: Variable {
             identifier: "types",
             position: (105, 17),
            },
            target: FunctionApplication {
             function: Variable {
              identifier: "nullOr",
              position: (105, 24),
             },
             arguments: [
              Variable {
               identifier: "str",
               position: (105, 31),
              },
             ],
            },
            position: (105, 12),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "default",
              position: (106, 5),
             },
            ],
           },
           Variable {
            identifier: "null",
            position: (106, 15),
           },
          ),
         ],
         recursive: false,
         position: (103, 45),
        },
       ],
      },
      position: (103, 23),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (110, 3),
        },
        Raw {
         content: "services",
         position: (110, 11),
        },
        Raw {
         content: "sourcehut",
         position: (110, 20),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (111, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkEnableOption",
           position: (111, 14),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "sourcehut - git hosting, continuous integration, mailing list, ticket tracking,\ntask dispatching, wiki and account management services\n",
              position: (112, 1),
             },
            ],
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "services",
            position: (116, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (116, 16),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (117, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "types",
                position: (117, 19),
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "listOf",
                 position: (117, 26),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "enum",
                   position: (117, 34),
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "builds",
                        position: (118, 12),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "dispatch",
                        position: (118, 21),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "git",
                        position: (118, 32),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "hg",
                        position: (118, 38),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "hub",
                        position: (118, 43),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "lists",
                        position: (118, 49),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "man",
                        position: (118, 57),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "meta",
                        position: (118, 63),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "pages",
                        position: (118, 70),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "paste",
                        position: (118, 78),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "todo",
                        position: (118, 86),
                       },
                      ],
                     },
                    ],
                    position: (118, 9),
                   },
                  ],
                 },
                ],
               },
               position: (117, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "defaultText",
                 position: (119, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "locally enabled services",
                 position: (119, 22),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (120, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Services that may be displayed as links in the title bar of the Web interface.\n",
                 position: (121, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (116, 25),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "listenAddress",
            position: (125, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (125, 21),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (126, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (126, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (126, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (127, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "localhost",
                 position: (127, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (128, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Address to bind to.",
                 position: (128, 22),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (125, 30),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "python",
            position: (131, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (131, 14),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "internal",
                 position: (132, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (132, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (133, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (133, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "package",
                  position: (133, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (134, 7),
                },
               ],
              },
              Variable {
               identifier: "python",
               position: (134, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (135, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "The python package to use. It should contain references to the *srht modules and also\ngunicorn.\n",
                 position: (136, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (131, 23),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "minio",
            position: (141, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (142, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (142, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "local minio integration",
                 position: (142, 33),
                },
               ],
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (141, 13),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "nginx",
            position: (145, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (146, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (146, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "local nginx integration",
                 position: (146, 33),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "virtualHost",
               position: (147, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (147, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (148, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (148, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (148, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (149, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (149, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (150, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Virtual-host configuration merged with all Sourcehut's virtual-hosts.",
                    position: (150, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (147, 30),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (145, 13),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "postfix",
            position: (154, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (155, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (155, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "local postfix integration",
                 position: (155, 33),
                },
               ],
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (154, 15),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "postgresql",
            position: (158, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (159, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (159, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "local postgresql integration",
                 position: (159, 33),
                },
               ],
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (158, 18),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "redis",
            position: (162, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (163, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (163, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "local redis integration in a dedicated redis-server",
                 position: (163, 33),
                },
               ],
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (162, 13),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "settings",
            position: (166, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (166, 16),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (167, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (167, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "types",
                   position: (167, 18),
                  },
                  Raw {
                   content: "submodule",
                   position: (167, 24),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "freeformType",
                      position: (168, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "settingsFormat",
                     position: (168, 24),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (168, 39),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (169, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "sr.ht",
                         position: (169, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "global-domain",
                         position: (170, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (170, 27),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (171, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Global domain name.",
                              position: (171, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (172, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (172, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (172, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "example",
                              position: (173, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "example.com",
                              position: (173, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (170, 36),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "environment",
                         position: (175, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (175, 25),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (176, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Values other than \"production\" adds a banner to each page.",
                              position: (176, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (177, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: PropertyAccess {
                             expression: Variable {
                              identifier: "types",
                              position: (177, 20),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "enum",
                                position: (177, 26),
                               },
                              ],
                             },
                             default: None,
                            },
                            arguments: [
                             List {
                              elements: [
                               String {
                                parts: [
                                 Raw {
                                  content: "development",
                                  position: (177, 34),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "production",
                                  position: (177, 48),
                                 },
                                ],
                               },
                              ],
                              position: (177, 31),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (178, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "development",
                              position: (178, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (175, 34),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "network-key",
                         position: (180, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (180, 25),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (181, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "An absolute file path (which should be outside the Nix-store)\nto a secret key to encrypt internal messages with. Use <code>srht-keygen network</code> to\ngenerate this key. It must be consistent between all services and nodes.\n",
                              position: (182, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (186, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (186, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "path",
                               position: (186, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "apply",
                              position: (187, 13),
                             },
                            ],
                           },
                           Function {
                            argument: Some(
                             "s",
                            ),
                            arguments: FunctionArguments {
                             arguments: [],
                             ellipsis: false,
                            },
                            definition: BinaryOperation {
                             operator: Addition,
                             operands: [
                              String {
                               parts: [
                                Raw {
                                 content: "<",
                                 position: (187, 25),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: Variable {
                                identifier: "toString",
                                position: (187, 30),
                               },
                               arguments: [
                                Variable {
                                 identifier: "s",
                                 position: (187, 39),
                                },
                               ],
                              },
                             ],
                             position: (187, 28),
                            },
                            position: (187, 21),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (180, 34),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "owner-email",
                         position: (189, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (189, 25),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (190, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Owner's email.",
                              position: (190, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (191, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (191, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (191, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (192, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "contact@example.com",
                              position: (192, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (189, 34),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "owner-name",
                         position: (194, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (194, 24),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (195, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Owner's name.",
                              position: (195, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (196, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (196, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (196, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (197, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "John Doe",
                              position: (197, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (194, 33),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "site-blurb",
                         position: (199, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (199, 24),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (200, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Blurb for your site.",
                              position: (200, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (201, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (201, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (201, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (202, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "the hacker's forge",
                              position: (202, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (199, 33),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "site-info",
                         position: (204, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (204, 23),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (205, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "The top-level info page for your site.",
                              position: (205, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (206, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (206, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (206, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (207, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "https://sourcehut.org",
                              position: (207, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (204, 32),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "service-key",
                         position: (209, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (209, 25),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (210, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "An absolute file path (which should be outside the Nix-store)\nto a key used for encrypting session cookies. Use <code>srht-keygen service</code> to\ngenerate the service key. This must be shared between each node of the same\nservice (e.g. git1.sr.ht and git2.sr.ht), but different services may use\ndifferent keys. If you configure all of your services with the same\nconfig.ini, you may use the same service-key for all of them.\n",
                              position: (211, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (218, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (218, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "path",
                               position: (218, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "apply",
                              position: (219, 13),
                             },
                            ],
                           },
                           Function {
                            argument: Some(
                             "s",
                            ),
                            arguments: FunctionArguments {
                             arguments: [],
                             ellipsis: false,
                            },
                            definition: BinaryOperation {
                             operator: Addition,
                             operands: [
                              String {
                               parts: [
                                Raw {
                                 content: "<",
                                 position: (219, 25),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: Variable {
                                identifier: "toString",
                                position: (219, 30),
                               },
                               arguments: [
                                Variable {
                                 identifier: "s",
                                 position: (219, 39),
                                },
                               ],
                              },
                             ],
                             position: (219, 28),
                            },
                            position: (219, 21),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (209, 34),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "site-name",
                         position: (221, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (221, 23),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (222, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "The name of your network of sr.ht-based sites.",
                              position: (222, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (223, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (223, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (223, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (224, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "sourcehut",
                              position: (224, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (221, 32),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "source-url",
                         position: (226, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (226, 24),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (227, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "The source code for your fork of sr.ht.",
                              position: (227, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (228, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (228, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (228, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (229, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "https://git.sr.ht/~sircmpwn/srht",
                              position: (229, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (226, 33),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (169, 27),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (232, 9),
                     },
                     Raw {
                      content: "mail",
                      position: (232, 17),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "smtp-host",
                         position: (233, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOptionNullOrStr",
                        position: (233, 23),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "Outgoing SMTP host.",
                           position: (233, 42),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "smtp-port",
                         position: (234, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (234, 23),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (235, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Outgoing SMTP port.",
                              position: (235, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (236, 13),
                             },
                            ],
                           },
                           With {
                            expression: Variable {
                             identifier: "types",
                             position: (236, 25),
                            },
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "nullOr",
                              position: (236, 32),
                             },
                             arguments: [
                              Variable {
                               identifier: "port",
                               position: (236, 39),
                              },
                             ],
                            },
                            position: (236, 20),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (237, 13),
                             },
                            ],
                           },
                           Variable {
                            identifier: "null",
                            position: (237, 23),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (234, 32),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "smtp-user",
                         position: (239, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOptionNullOrStr",
                        position: (239, 23),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "Outgoing SMTP user.",
                           position: (239, 42),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "smtp-password",
                         position: (240, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOptionNullOrStr",
                        position: (240, 27),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "Outgoing SMTP password.",
                           position: (240, 46),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "smtp-from",
                         position: (241, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOptionNullOrStr",
                        position: (241, 23),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "Outgoing SMTP FROM.",
                           position: (241, 42),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "error-to",
                         position: (242, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOptionNullOrStr",
                        position: (242, 22),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "Address receiving application exceptions",
                           position: (242, 41),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "error-from",
                         position: (243, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOptionNullOrStr",
                        position: (243, 24),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "Address sending application exceptions",
                           position: (243, 43),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "pgp-privkey",
                         position: (244, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOptionNullOrStr",
                        position: (244, 25),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "An absolute file path (which should be outside the Nix-store)\nto an OpenPGP private key.\n\nYour PGP key information (DO NOT mix up pub and priv here)\nYou must remove the password from your secret key, if present.\nYou can do this with <code>gpg --edit-key [key-id]</code>,\nthen use the <code>passwd</code> command and do not enter a new password.\n",
                           position: (245, 1),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "pgp-pubkey",
                         position: (253, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOptionNullOrStr",
                        position: (253, 24),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "OpenPGP public key.",
                           position: (253, 43),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "pgp-key-id",
                         position: (254, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOptionNullOrStr",
                        position: (254, 24),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "OpenPGP key identifier.",
                           position: (254, 43),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (232, 24),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (256, 9),
                     },
                     Raw {
                      content: "objects",
                      position: (256, 17),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "s3-upstream",
                         position: (257, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (257, 25),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (258, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Configure the S3-compatible object storage service.",
                              position: (258, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (259, 13),
                             },
                            ],
                           },
                           With {
                            expression: Variable {
                             identifier: "types",
                             position: (259, 25),
                            },
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "nullOr",
                              position: (259, 32),
                             },
                             arguments: [
                              Variable {
                               identifier: "str",
                               position: (259, 39),
                              },
                             ],
                            },
                            position: (259, 20),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (260, 13),
                             },
                            ],
                           },
                           Variable {
                            identifier: "null",
                            position: (260, 23),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (257, 34),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "s3-access-key",
                         position: (262, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (262, 27),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (263, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Access key to the S3-compatible object storage service",
                              position: (263, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (264, 13),
                             },
                            ],
                           },
                           With {
                            expression: Variable {
                             identifier: "types",
                             position: (264, 25),
                            },
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "nullOr",
                              position: (264, 32),
                             },
                             arguments: [
                              Variable {
                               identifier: "str",
                               position: (264, 39),
                              },
                             ],
                            },
                            position: (264, 20),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (265, 13),
                             },
                            ],
                           },
                           Variable {
                            identifier: "null",
                            position: (265, 23),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (262, 36),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "s3-secret-key",
                         position: (267, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (267, 27),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (268, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "An absolute file path (which should be outside the Nix-store)\nto the secret key of the S3-compatible object storage service.\n",
                              position: (269, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (272, 13),
                             },
                            ],
                           },
                           With {
                            expression: Variable {
                             identifier: "types",
                             position: (272, 25),
                            },
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "nullOr",
                              position: (272, 32),
                             },
                             arguments: [
                              Variable {
                               identifier: "path",
                               position: (272, 39),
                              },
                             ],
                            },
                            position: (272, 20),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (273, 13),
                             },
                            ],
                           },
                           Variable {
                            identifier: "null",
                            position: (273, 23),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "apply",
                              position: (274, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mapNullable",
                             position: (274, 21),
                            },
                            arguments: [
                             Function {
                              argument: Some(
                               "s",
                              ),
                              arguments: FunctionArguments {
                               arguments: [],
                               ellipsis: false,
                              },
                              definition: BinaryOperation {
                               operator: Addition,
                               operands: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "<",
                                   position: (274, 38),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "toString",
                                  position: (274, 43),
                                 },
                                 arguments: [
                                  Variable {
                                   identifier: "s",
                                   position: (274, 52),
                                  },
                                 ],
                                },
                               ],
                               position: (274, 41),
                              },
                              position: (274, 34),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (267, 36),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (256, 27),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (277, 9),
                     },
                     Raw {
                      content: "webhooks",
                      position: (277, 17),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "private-key",
                         position: (278, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (278, 25),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (279, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "An absolute file path (which should be outside the Nix-store)\nto a base64-encoded Ed25519 key for signing webhook payloads.\nThis should be consistent for all *.sr.ht sites,\nas this key will be used to verify signatures\nfrom other sites in your network.\nUse the <code>srht-keygen webhook</code> command to generate a key.\n",
                              position: (280, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (287, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (287, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "path",
                               position: (287, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "apply",
                              position: (288, 13),
                             },
                            ],
                           },
                           Function {
                            argument: Some(
                             "s",
                            ),
                            arguments: FunctionArguments {
                             arguments: [],
                             ellipsis: false,
                            },
                            definition: BinaryOperation {
                             operator: Addition,
                             operands: [
                              String {
                               parts: [
                                Raw {
                                 content: "<",
                                 position: (288, 25),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: Variable {
                                identifier: "toString",
                                position: (288, 30),
                               },
                               arguments: [
                                Variable {
                                 identifier: "s",
                                 position: (288, 39),
                                },
                               ],
                              },
                             ],
                             position: (288, 28),
                            },
                            position: (288, 21),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (278, 34),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (277, 28),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (292, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "dispatch.sr.ht",
                         position: (292, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "commonServiceSettings",
                       position: (292, 36),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "dispatch",
                          position: (292, 59),
                         },
                        ],
                       },
                      ],
                     },
                     Map {
                      bindings: [],
                      recursive: false,
                      position: (292, 72),
                     },
                    ],
                    position: (292, 69),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (294, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "dispatch.sr.ht::github",
                         position: (294, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "oauth-client-id",
                         position: (295, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOptionNullOrStr",
                        position: (295, 29),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "OAuth client id.",
                           position: (295, 48),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "oauth-client-secret",
                         position: (296, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOptionNullOrStr",
                        position: (296, 33),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "OAuth client secret.",
                           position: (296, 52),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (294, 44),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (298, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "dispatch.sr.ht::gitlab",
                         position: (298, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "enabled",
                         position: (299, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkEnableOption",
                        position: (299, 21),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "GitLab integration",
                           position: (299, 37),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "canonical-upstream",
                         position: (300, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (300, 32),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (301, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (301, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (301, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (302, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Canonical upstream.",
                              position: (302, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (303, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "gitlab.com",
                              position: (303, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (300, 41),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "repo-cache",
                         position: (305, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (305, 24),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (306, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (306, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (306, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (307, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Repository cache directory.",
                              position: (307, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (308, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "./repo-cache",
                              position: (308, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (305, 33),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Expression {
                         expression: String {
                          parts: [
                           Raw {
                            content: "gitlab.com",
                            position: (310, 12),
                           },
                          ],
                         },
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (310, 26),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (311, 13),
                             },
                            ],
                           },
                           With {
                            expression: Variable {
                             identifier: "types",
                             position: (311, 25),
                            },
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "nullOr",
                              position: (311, 32),
                             },
                             arguments: [
                              Variable {
                               identifier: "str",
                               position: (311, 39),
                              },
                             ],
                            },
                            position: (311, 20),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (312, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "GitLab id and secret.",
                              position: (312, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (313, 13),
                             },
                            ],
                           },
                           Variable {
                            identifier: "null",
                            position: (313, 23),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "example",
                              position: (314, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "GitLab:application id:secret",
                              position: (314, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (310, 35),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (298, 44),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (318, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "builds.sr.ht",
                         position: (318, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "commonServiceSettings",
                       position: (318, 34),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "builds",
                          position: (318, 57),
                         },
                        ],
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "allow-free",
                           position: (319, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkEnableOption",
                          position: (319, 24),
                         },
                         arguments: [
                          String {
                           parts: [
                            Raw {
                             content: "nonpaying users to submit builds",
                             position: (319, 40),
                            },
                           ],
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "redis",
                           position: (320, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (320, 19),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (321, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The Redis connection used for the Celery worker.",
                                position: (321, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (322, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (322, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (322, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (323, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "redis+socket:///run/redis-sourcehut-buildsrht/redis.sock?virtual_host=2",
                                position: (323, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (320, 28),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "shell",
                           position: (325, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (325, 19),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (326, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Scripts used to launch on SSH connection.\n<literal>/usr/bin/master-shell</literal> on master,\n<literal>/usr/bin/runner-shell</literal> on runner.\nIf master and worker are on the same system\nset to <literal>/usr/bin/runner-shell</literal>.\n",
                                position: (327, 1),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (333, 13),
                               },
                              ],
                             },
                             FunctionApplication {
                              function: PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (333, 20),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "enum",
                                  position: (333, 26),
                                 },
                                ],
                               },
                               default: None,
                              },
                              arguments: [
                               List {
                                elements: [
                                 String {
                                  parts: [
                                   Raw {
                                    content: "/usr/bin/master-shell",
                                    position: (333, 33),
                                   },
                                  ],
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "/usr/bin/runner-shell",
                                    position: (333, 57),
                                   },
                                  ],
                                 },
                                ],
                                position: (333, 31),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (334, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "/usr/bin/master-shell",
                                position: (334, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (325, 28),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (318, 68),
                     },
                    ],
                    position: (318, 65),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (337, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "builds.sr.ht::worker",
                         position: (337, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "bind-address",
                         position: (338, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (338, 26),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (339, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "HTTP bind address for serving local build information/monitoring.\n",
                              position: (340, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (342, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (342, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (342, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (343, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "localhost:8080",
                              position: (343, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (338, 35),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "buildlogs",
                         position: (345, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (345, 23),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (346, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Path to write build logs.",
                              position: (346, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (347, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (347, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (347, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (348, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "/var/log/sourcehut/buildsrht-worker",
                              position: (348, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (345, 32),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "name",
                         position: (350, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (350, 18),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (351, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Listening address and listening port\nof the build runner (with HTTP port if not 80).\n",
                              position: (352, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (355, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (355, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (355, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (356, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "localhost:5020",
                              position: (356, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (350, 27),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "timeout",
                         position: (358, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (358, 21),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (359, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Max build duration.\nSee <link xlink:href=\"https://golang.org/pkg/time/#ParseDuration\"/>.\n",
                              position: (360, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (363, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (363, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (363, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (364, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "3m",
                              position: (364, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (358, 30),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (337, 42),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (368, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "git.sr.ht",
                         position: (368, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "commonServiceSettings",
                       position: (368, 31),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "git",
                          position: (368, 54),
                         },
                        ],
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "outgoing-domain",
                           position: (369, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (369, 29),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (370, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Outgoing domain.",
                                position: (370, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (371, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (371, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (371, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (372, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "https://git.localhost.localdomain",
                                position: (372, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (369, 38),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "post-update-script",
                           position: (374, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (374, 32),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (375, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "A post-update script which is installed in every git repo.\nThis setting is propagated to newer and existing repositories.\n",
                                position: (376, 1),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (379, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (379, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "path",
                                 position: (379, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (380, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "pkgs",
                                  position: (380, 26),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "sourcehut",
                                    position: (380, 31),
                                   },
                                   Raw {
                                    content: "gitsrht",
                                    position: (380, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "/bin/gitsrht-update-hook",
                                position: (380, 49),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "defaultText",
                                position: (381, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "${pkgs.sourcehut.gitsrht}/bin/gitsrht-update-hook",
                                position: (381, 28),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (374, 41),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "repos",
                           position: (383, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (383, 19),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (384, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Path to git repositories on disk.\nIf changing the default, you must ensure that\nthe gitsrht's user as read and write access to it.\n",
                                position: (385, 1),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (389, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (389, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (389, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (390, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "/var/lib/sourcehut/gitsrht/repos",
                                position: (390, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (383, 28),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "webhooks",
                           position: (392, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (392, 22),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (393, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The Redis connection used for the webhooks worker.",
                                position: (393, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (394, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (394, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (394, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (395, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "redis+socket:///run/redis-sourcehut-gitsrht/redis.sock?virtual_host=1",
                                position: (395, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (392, 31),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (368, 62),
                     },
                    ],
                    position: (368, 59),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (398, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "git.sr.ht::api",
                         position: (398, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "internal-ipnet",
                         position: (399, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (399, 28),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (400, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Set of IP subnets which are permitted to utilize internal API\nauthentication. This should be limited to the subnets\nfrom which your *.sr.ht services are running.\nSee <xref linkend=\"opt-services.sourcehut.listenAddress\"/>.\n",
                              position: (401, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (406, 13),
                             },
                            ],
                           },
                           With {
                            expression: Variable {
                             identifier: "types",
                             position: (406, 25),
                            },
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "listOf",
                              position: (406, 32),
                             },
                             arguments: [
                              Variable {
                               identifier: "str",
                               position: (406, 39),
                              },
                             ],
                            },
                            position: (406, 20),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (407, 13),
                             },
                            ],
                           },
                           List {
                            elements: [
                             String {
                              parts: [
                               Raw {
                                content: "127.0.0.0/8",
                                position: (407, 26),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "::1/128",
                                position: (407, 40),
                               },
                              ],
                             },
                            ],
                            position: (407, 23),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (399, 37),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (398, 36),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (411, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "hg.sr.ht",
                         position: (411, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "commonServiceSettings",
                       position: (411, 30),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "hg",
                          position: (411, 53),
                         },
                        ],
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "changegroup-script",
                           position: (412, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (412, 32),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (413, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "A changegroup script which is installed in every mercurial repo.\nThis setting is propagated to newer and existing repositories.\n",
                                position: (414, 1),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (417, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (417, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (417, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (418, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (418, 26),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "python",
                                    position: (418, 30),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "/bin/hgsrht-hook-changegroup",
                                position: (418, 37),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "defaultText",
                                position: (419, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "${cfg.python}/bin/hgsrht-hook-changegroup",
                                position: (419, 28),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (412, 41),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "repos",
                           position: (421, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (421, 19),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (422, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Path to mercurial repositories on disk.\nIf changing the default, you must ensure that\nthe hgsrht's user as read and write access to it.\n",
                                position: (423, 1),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (427, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (427, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (427, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (428, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "/var/lib/sourcehut/hgsrht/repos",
                                position: (428, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (421, 28),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "srhtext",
                           position: (430, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOptionNullOrStr",
                          position: (430, 21),
                         },
                         arguments: [
                          String {
                           parts: [
                            Raw {
                             content: "Path to the srht mercurial extension\n(defaults to where the hgsrht code is)\n",
                             position: (431, 1),
                            },
                           ],
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "clone_bundle_threshold",
                           position: (434, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (434, 36),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (435, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: ".hg/store size (in MB) past which the nightly job generates clone bundles.",
                                position: (435, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (436, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (436, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "ints",
                                 position: (436, 26),
                                },
                                Raw {
                                 content: "unsigned",
                                 position: (436, 31),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (437, 13),
                               },
                              ],
                             },
                             Int {
                              value: 50,
                              position: (437, 23),
                             },
                            ),
                           ],
                           recursive: false,
                           position: (434, 45),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "hg_ssh",
                           position: (439, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (439, 20),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (440, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Path to hg-ssh (if not in $PATH).",
                                position: (440, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (441, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (441, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (441, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (442, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "pkgs",
                                  position: (442, 26),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "mercurial",
                                    position: (442, 31),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "/bin/hg-ssh",
                                position: (442, 41),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "defaultText",
                                position: (443, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "${pkgs.mercurial}/bin/hg-ssh",
                                position: (443, 28),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (439, 29),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "webhooks",
                           position: (445, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (445, 22),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (446, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The Redis connection used for the webhooks worker.",
                                position: (446, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (447, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (447, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (447, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (448, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "redis+socket:///run/redis-sourcehut-hgsrht/redis.sock?virtual_host=1",
                                position: (448, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (445, 31),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (411, 60),
                     },
                    ],
                    position: (411, 57),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (452, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "hub.sr.ht",
                         position: (452, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "commonServiceSettings",
                       position: (452, 31),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "hub",
                          position: (452, 54),
                         },
                        ],
                       },
                      ],
                     },
                     Map {
                      bindings: [],
                      recursive: false,
                      position: (452, 62),
                     },
                    ],
                    position: (452, 59),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (455, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "lists.sr.ht",
                         position: (455, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "commonServiceSettings",
                       position: (455, 33),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "lists",
                          position: (455, 56),
                         },
                        ],
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "allow-new-lists",
                           position: (456, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkEnableOption",
                          position: (456, 29),
                         },
                         arguments: [
                          String {
                           parts: [
                            Raw {
                             content: "Allow creation of new lists.",
                             position: (456, 45),
                            },
                           ],
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "notify-from",
                           position: (457, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (457, 25),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (458, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Outgoing email for notifications generated by users.",
                                position: (458, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (459, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (459, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (459, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (460, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "lists-notify@localhost.localdomain",
                                position: (460, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (457, 34),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "posting-domain",
                           position: (462, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (462, 28),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (463, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Posting domain.",
                                position: (463, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (464, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (464, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (464, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (465, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "lists.localhost.localdomain",
                                position: (465, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (462, 37),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "redis",
                           position: (467, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (467, 19),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (468, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The Redis connection used for the Celery worker.",
                                position: (468, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (469, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (469, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (469, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (470, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "redis+socket:///run/redis-sourcehut-listssrht/redis.sock?virtual_host=2",
                                position: (470, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (467, 28),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "webhooks",
                           position: (472, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (472, 22),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (473, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The Redis connection used for the webhooks worker.",
                                position: (473, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (474, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (474, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (474, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (475, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "redis+socket:///run/redis-sourcehut-listssrht/redis.sock?virtual_host=1",
                                position: (475, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (472, 31),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (455, 66),
                     },
                    ],
                    position: (455, 63),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (478, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "lists.sr.ht::worker",
                         position: (478, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "reject-mimetypes",
                         position: (479, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (479, 30),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (480, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Comma-delimited list of Content-Types to reject. Messages with Content-Types\nincluded in this list are rejected. Multipart messages are always supported,\nand each part is checked against this list.\n\nUses fnmatch for wildcard expansion.\n",
                              position: (481, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (487, 13),
                             },
                            ],
                           },
                           With {
                            expression: Variable {
                             identifier: "types",
                             position: (487, 25),
                            },
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "listOf",
                              position: (487, 32),
                             },
                             arguments: [
                              Variable {
                               identifier: "str",
                               position: (487, 39),
                              },
                             ],
                            },
                            position: (487, 20),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (488, 13),
                             },
                            ],
                           },
                           List {
                            elements: [
                             String {
                              parts: [
                               Raw {
                                content: "text/html",
                                position: (488, 25),
                               },
                              ],
                             },
                            ],
                            position: (488, 23),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (479, 39),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "reject-url",
                         position: (490, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (490, 24),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (491, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Reject URL.",
                              position: (491, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (492, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (492, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (492, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (493, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "https://man.sr.ht/lists.sr.ht/etiquette.md",
                              position: (493, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (490, 33),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "sock",
                         position: (495, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (495, 18),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (496, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Path for the lmtp daemon's unix socket. Direct incoming mail to this socket.\nAlternatively, specify IP:PORT and an SMTP server will be run instead.\n",
                              position: (497, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (500, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (500, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (500, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (501, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "/tmp/lists.sr.ht-lmtp.sock",
                              position: (501, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (495, 27),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "sock-group",
                         position: (503, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (503, 24),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (504, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "The lmtp daemon will make the unix socket group-read/write\nfor users in this group.\n",
                              position: (505, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (508, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (508, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (508, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (509, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "postfix",
                              position: (509, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (503, 33),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (478, 41),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (513, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "man.sr.ht",
                         position: (513, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "commonServiceSettings",
                       position: (513, 31),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "man",
                          position: (513, 54),
                         },
                        ],
                       },
                      ],
                     },
                     Map {
                      bindings: [],
                      recursive: false,
                      position: (513, 62),
                     },
                    ],
                    position: (513, 59),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (516, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "meta.sr.ht",
                         position: (516, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "removeAttrs",
                       position: (517, 11),
                      },
                      arguments: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "commonServiceSettings",
                         position: (517, 24),
                        },
                        arguments: [
                         String {
                          parts: [
                           Raw {
                            content: "meta",
                            position: (517, 47),
                           },
                          ],
                         },
                        ],
                       },
                       List {
                        elements: [
                         String {
                          parts: [
                           Raw {
                            content: "oauth-client-id",
                            position: (518, 15),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "oauth-client-secret",
                            position: (518, 33),
                           },
                          ],
                         },
                        ],
                        position: (518, 13),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "api-origin",
                           position: (519, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (519, 24),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (520, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Origin URL for API, 100 more than web.",
                                position: (520, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (521, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (521, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (521, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (522, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "http://",
                                position: (522, 24),
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (522, 33),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "listenAddress",
                                    position: (522, 37),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: ":",
                                position: (522, 51),
                               },
                               Expression {
                                expression: FunctionApplication {
                                 function: Variable {
                                  identifier: "toString",
                                  position: (522, 54),
                                 },
                                 arguments: [
                                  BinaryOperation {
                                   operator: Addition,
                                   operands: [
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "cfg",
                                      position: (522, 64),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "meta",
                                        position: (522, 68),
                                       },
                                       Raw {
                                        content: "port",
                                        position: (522, 73),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                    Int {
                                     value: 100,
                                     position: (522, 80),
                                    },
                                   ],
                                   position: (522, 78),
                                  },
                                 ],
                                },
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "defaultText",
                                position: (523, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "http://<xref linkend=\"opt-services.sourcehut.listenAddress\"/>:",
                                position: (523, 29),
                               },
                               Raw {
                                content: "$",
                                position: (523, 91),
                               },
                               Raw {
                                content: "{toString (<xref linkend=\"opt-services.sourcehut.meta.port\"/> + 100)}",
                                position: (523, 94),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (519, 33),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "webhooks",
                           position: (525, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (525, 22),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (526, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The Redis connection used for the webhooks worker.",
                                position: (526, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (527, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (527, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (527, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (528, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "redis+socket:///run/redis-sourcehut-metasrht/redis.sock?virtual_host=1",
                                position: (528, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (525, 31),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "welcome-emails",
                           position: (530, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkEnableOption",
                          position: (530, 28),
                         },
                         arguments: [
                          String {
                           parts: [
                            Raw {
                             content: "sending stock sourcehut welcome emails after signup",
                             position: (530, 44),
                            },
                           ],
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (518, 58),
                     },
                    ],
                    position: (518, 55),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (532, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "meta.sr.ht::api",
                         position: (532, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "internal-ipnet",
                         position: (533, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (533, 28),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (534, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Set of IP subnets which are permitted to utilize internal API\nauthentication. This should be limited to the subnets\nfrom which your *.sr.ht services are running.\nSee <xref linkend=\"opt-services.sourcehut.listenAddress\"/>.\n",
                              position: (535, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (540, 13),
                             },
                            ],
                           },
                           With {
                            expression: Variable {
                             identifier: "types",
                             position: (540, 25),
                            },
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "listOf",
                              position: (540, 32),
                             },
                             arguments: [
                              Variable {
                               identifier: "str",
                               position: (540, 39),
                              },
                             ],
                            },
                            position: (540, 20),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (541, 13),
                             },
                            ],
                           },
                           List {
                            elements: [
                             String {
                              parts: [
                               Raw {
                                content: "127.0.0.0/8",
                                position: (541, 26),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "::1/128",
                                position: (541, 40),
                               },
                              ],
                             },
                            ],
                            position: (541, 23),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (533, 37),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (532, 37),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (544, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "meta.sr.ht::aliases",
                         position: (544, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "mkOption",
                     position: (544, 41),
                    },
                    arguments: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "description",
                           position: (545, 11),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "Aliases for the client IDs of commonly used OAuth clients.",
                           position: (545, 26),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "type",
                           position: (546, 11),
                          },
                         ],
                        },
                        With {
                         expression: Variable {
                          identifier: "types",
                          position: (546, 23),
                         },
                         target: FunctionApplication {
                          function: Variable {
                           identifier: "attrsOf",
                           position: (546, 30),
                          },
                          arguments: [
                           Variable {
                            identifier: "int",
                            position: (546, 38),
                           },
                          ],
                         },
                         position: (546, 18),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "default",
                           position: (547, 11),
                          },
                         ],
                        },
                        Map {
                         bindings: [],
                         recursive: false,
                         position: (547, 21),
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "example",
                           position: (548, 11),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Expression {
                              expression: String {
                               parts: [
                                Raw {
                                 content: "git.sr.ht",
                                 position: (548, 24),
                                },
                               ],
                              },
                             },
                            ],
                           },
                           Int {
                            value: 12345,
                            position: (548, 37),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (548, 21),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (544, 50),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (550, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "meta.sr.ht::billing",
                         position: (550, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "enabled",
                         position: (551, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkEnableOption",
                        position: (551, 21),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "the billing system",
                           position: (551, 37),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "stripe-public-key",
                         position: (552, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOptionNullOrStr",
                        position: (552, 31),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "Public key for Stripe. Get your keys at https://dashboard.stripe.com/account/apikeys",
                           position: (552, 50),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "stripe-secret-key",
                         position: (553, 11),
                        },
                       ],
                      },
                      BinaryOperation {
                       operator: Update,
                       operands: [
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOptionNullOrStr",
                          position: (553, 31),
                         },
                         arguments: [
                          String {
                           parts: [
                            Raw {
                             content: "An absolute file path (which should be outside the Nix-store)\nto a secret key for Stripe. Get your keys at https://dashboard.stripe.com/account/apikeys\n",
                             position: (554, 1),
                            },
                           ],
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "apply",
                              position: (557, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mapNullable",
                             position: (557, 21),
                            },
                            arguments: [
                             Function {
                              argument: Some(
                               "s",
                              ),
                              arguments: FunctionArguments {
                               arguments: [],
                               ellipsis: false,
                              },
                              definition: BinaryOperation {
                               operator: Addition,
                               operands: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "<",
                                   position: (557, 38),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "toString",
                                  position: (557, 43),
                                 },
                                 arguments: [
                                  Variable {
                                   identifier: "s",
                                   position: (557, 52),
                                  },
                                 ],
                                },
                               ],
                               position: (557, 41),
                              },
                              position: (557, 34),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (556, 17),
                        },
                       ],
                       position: (556, 14),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (550, 41),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (560, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "meta.sr.ht::settings",
                         position: (560, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "registration",
                         position: (561, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkEnableOption",
                        position: (561, 26),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "public registration",
                           position: (561, 42),
                          },
                         ],
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "onboarding-redirect",
                         position: (562, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (562, 33),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (563, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Where to redirect new users upon registration.",
                              position: (563, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (564, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (564, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (564, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (565, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "https://meta.localhost.localdomain",
                              position: (565, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (562, 42),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "user-invites",
                         position: (567, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (567, 26),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (568, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "How many invites each user is issued upon registration\n(only applicable if open registration is disabled).\n",
                              position: (569, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (572, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (572, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "ints",
                               position: (572, 26),
                              },
                              Raw {
                               content: "unsigned",
                               position: (572, 31),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (573, 13),
                             },
                            ],
                           },
                           Int {
                            value: 5,
                            position: (573, 23),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (567, 35),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (560, 42),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (577, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "pages.sr.ht",
                         position: (577, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "commonServiceSettings",
                       position: (577, 33),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "pages",
                          position: (577, 56),
                         },
                        ],
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "gemini-certs",
                           position: (578, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (578, 26),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (579, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "An absolute file path (which should be outside the Nix-store)\nto Gemini certificates.\n",
                                position: (580, 1),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (583, 13),
                               },
                              ],
                             },
                             With {
                              expression: Variable {
                               identifier: "types",
                               position: (583, 25),
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (583, 32),
                               },
                               arguments: [
                                Variable {
                                 identifier: "path",
                                 position: (583, 39),
                                },
                               ],
                              },
                              position: (583, 20),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (584, 13),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (584, 23),
                             },
                            ),
                           ],
                           recursive: false,
                           position: (578, 35),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "max-site-size",
                           position: (586, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (586, 27),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (587, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Maximum size of any given site (post-gunzip), in MiB.",
                                position: (587, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (588, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (588, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "int",
                                 position: (588, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (589, 13),
                               },
                              ],
                             },
                             Int {
                              value: 1024,
                              position: (589, 23),
                             },
                            ),
                           ],
                           recursive: false,
                           position: (586, 36),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "user-domain",
                           position: (591, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (591, 25),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (592, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Configures the user domain, if enabled.\nAll users are given &lt;username&gt;.this.domain.\n",
                                position: (593, 1),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (596, 13),
                               },
                              ],
                             },
                             With {
                              expression: Variable {
                               identifier: "types",
                               position: (596, 25),
                              },
                              target: FunctionApplication {
                               function: Variable {
                                identifier: "nullOr",
                                position: (596, 32),
                               },
                               arguments: [
                                Variable {
                                 identifier: "str",
                                 position: (596, 39),
                                },
                               ],
                              },
                              position: (596, 20),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (597, 13),
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (597, 23),
                             },
                            ),
                           ],
                           recursive: false,
                           position: (591, 34),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (577, 66),
                     },
                    ],
                    position: (577, 63),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (600, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "pages.sr.ht::api",
                         position: (600, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "internal-ipnet",
                         position: (601, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (601, 28),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (602, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Set of IP subnets which are permitted to utilize internal API\nauthentication. This should be limited to the subnets\nfrom which your *.sr.ht services are running.\nSee <xref linkend=\"opt-services.sourcehut.listenAddress\"/>.\n",
                              position: (603, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (608, 13),
                             },
                            ],
                           },
                           With {
                            expression: Variable {
                             identifier: "types",
                             position: (608, 25),
                            },
                            target: FunctionApplication {
                             function: Variable {
                              identifier: "listOf",
                              position: (608, 32),
                             },
                             arguments: [
                              Variable {
                               identifier: "str",
                               position: (608, 39),
                              },
                             ],
                            },
                            position: (608, 20),
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (609, 13),
                             },
                            ],
                           },
                           List {
                            elements: [
                             String {
                              parts: [
                               Raw {
                                content: "127.0.0.0/8",
                                position: (609, 26),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "::1/128",
                                position: (609, 40),
                               },
                              ],
                             },
                            ],
                            position: (609, 23),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (601, 37),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (600, 38),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (613, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "paste.sr.ht",
                         position: (613, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "commonServiceSettings",
                       position: (613, 33),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "paste",
                          position: (613, 56),
                         },
                        ],
                       },
                      ],
                     },
                     Map {
                      bindings: [],
                      recursive: false,
                      position: (613, 66),
                     },
                    ],
                    position: (613, 63),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (616, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "todo.sr.ht",
                         position: (616, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Update,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "commonServiceSettings",
                       position: (616, 32),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "todo",
                          position: (616, 55),
                         },
                        ],
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "notify-from",
                           position: (617, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (617, 25),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (618, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "Outgoing email for notifications generated by users.",
                                position: (618, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (619, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (619, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (619, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (620, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "todo-notify@localhost.localdomain",
                                position: (620, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (617, 34),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "webhooks",
                           position: (622, 11),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkOption",
                          position: (622, 22),
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "description",
                                position: (623, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "The Redis connection used for the webhooks worker.",
                                position: (623, 28),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "type",
                                position: (624, 13),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "types",
                               position: (624, 20),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "str",
                                 position: (624, 26),
                                },
                               ],
                              },
                              default: None,
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "default",
                                position: (625, 13),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "redis+socket:///run/redis-sourcehut-todosrht/redis.sock?virtual_host=1",
                                position: (625, 24),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (622, 31),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (616, 64),
                     },
                    ],
                    position: (616, 61),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "options",
                      position: (628, 9),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "todo.sr.ht::mail",
                         position: (628, 18),
                        },
                       ],
                      },
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "posting-domain",
                         position: (629, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (629, 28),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (630, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Posting domain.",
                              position: (630, 28),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (631, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (631, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (631, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (632, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "todo.localhost.localdomain",
                              position: (632, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (629, 37),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "sock",
                         position: (634, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (634, 18),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (635, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "Path for the lmtp daemon's unix socket. Direct incoming mail to this socket.\nAlternatively, specify IP:PORT and an SMTP server will be run instead.\n",
                              position: (636, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (639, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (639, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (639, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (640, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "/tmp/todo.sr.ht-lmtp.sock",
                              position: (640, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (634, 27),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "sock-group",
                         position: (642, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkOption",
                        position: (642, 24),
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "description",
                              position: (643, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "The lmtp daemon will make the unix socket group-read/write\nfor users in this group.\n",
                              position: (644, 1),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "type",
                              position: (647, 13),
                             },
                            ],
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "types",
                             position: (647, 20),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "str",
                               position: (647, 26),
                              },
                             ],
                            },
                            default: None,
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "default",
                              position: (648, 13),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "postfix",
                              position: (648, 24),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (642, 33),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (628, 38),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (167, 34),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (652, 7),
                },
               ],
              },
              Map {
               bindings: [],
               recursive: false,
               position: (652, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (653, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "The configuration for the sourcehut network.\n",
                 position: (654, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (166, 25),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "builds",
            position: (658, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableWorker",
               position: (659, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (659, 22),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "worker for builds.sr.ht\n\n<warning><para>\nFor smaller deployments, job runners can be installed alongside the master server\nbut even if you only build your own software, integration with other services\nmay cause you to run untrusted builds\n(e.g. automatic testing of patches via listssrht).\nSee <link xlink:href=\"https://man.sr.ht/builds.sr.ht/configuration.md#security-model\"/>.\n</para></warning>\n",
                 position: (660, 1),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "images",
               position: (671, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (671, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (672, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (672, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (672, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "attrsOf",
                      position: (672, 37),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "attrsOf",
                        position: (672, 46),
                       },
                       arguments: [
                        Variable {
                         identifier: "package",
                         position: (672, 54),
                        },
                       ],
                      },
                     ],
                    },
                   ],
                  },
                  position: (672, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (673, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (673, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (674, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (674, 19),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "literalExpression",
                      position: (674, 23),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "(let\n            # Pinning unstable to allow usage with flakes and limit rebuilds.\n            pkgs_unstable = builtins.fetchGit {\n                url = \"https://github.com/NixOS/nixpkgs\";\n                rev = \"ff96a0fa5635770390b184ae74debea75c3fd534\";\n                ref = \"nixos-unstable\";\n            };\n            image_from_nixpkgs = (import (\"",
                      position: (674, 43),
                     },
                     Raw {
                      content: "$",
                      position: (681, 44),
                     },
                     Raw {
                      content: "{pkgs.sourcehut.buildsrht}/lib/images/nixos/image.nix\") {\n              pkgs = (import pkgs_unstable {});\n            });\n          in\n          {\n            nixos.unstable.x86_64 = image_from_nixpkgs;\n          }\n        )",
                      position: (681, 47),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (689, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Images for builds.sr.ht. Each package should be distro.release.arch and point to a /nix/store/package/root.img.qcow2.\n",
                    position: (690, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (671, 25),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (658, 14),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "git",
            position: (695, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (696, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (696, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (697, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (697, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (697, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (698, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (698, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "git",
                     position: (698, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (699, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (699, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.git",
                      position: (699, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (700, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (700, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.gitFull",
                      position: (700, 38),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (701, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Git package for git.sr.ht. This can help silence collisions.\n",
                    position: (702, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (696, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "fcgiwrap",
               position: (705, 7),
              },
              Raw {
               content: "preforkProcess",
               position: (705, 16),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (705, 33),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (706, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Number of fcgiwrap processes to prefork.",
                    position: (706, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (707, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (707, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (707, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (708, 9),
                   },
                  ],
                 },
                 Int {
                  value: 4,
                  position: (708, 19),
                 },
                ),
               ],
               recursive: false,
               position: (705, 42),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (695, 11),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "hg",
            position: (712, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (713, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (713, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (714, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (714, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (714, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (715, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (715, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "mercurial",
                     position: (715, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (716, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (716, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.mercurial",
                      position: (716, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (717, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Mercurial package for hg.sr.ht. This can help silence collisions.\n",
                    position: (718, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (713, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "cloneBundles",
               position: (721, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (721, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (722, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (722, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (722, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (723, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (723, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (724, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Generate clonebundles (which require more disk space but dramatically speed up cloning large repositories).\n",
                    position: (725, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (721, 31),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (712, 10),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "lists",
            position: (730, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "process",
               position: (731, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "extraArgs",
                  position: (732, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (732, 21),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (733, 11),
                      },
                     ],
                    },
                    With {
                     expression: Variable {
                      identifier: "types",
                      position: (733, 23),
                     },
                     target: FunctionApplication {
                      function: Variable {
                       identifier: "listOf",
                       position: (733, 30),
                      },
                      arguments: [
                       Variable {
                        identifier: "str",
                        position: (733, 37),
                       },
                      ],
                     },
                     position: (733, 18),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (734, 11),
                      },
                     ],
                    },
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "--loglevel DEBUG",
                         position: (734, 24),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "--pool eventlet",
                         position: (734, 43),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "--without-heartbeat",
                         position: (734, 61),
                        },
                       ],
                      },
                     ],
                     position: (734, 21),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (735, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Extra arguments passed to the Celery responsible for processing mails.",
                       position: (735, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (732, 30),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "celeryConfig",
                  position: (737, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkOption",
                 position: (737, 24),
                },
                arguments: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "type",
                       position: (738, 11),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (738, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "lines",
                        position: (738, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "default",
                       position: (739, 11),
                      },
                     ],
                    },
                    String {
                     parts: [],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (740, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Content of the <literal>celeryconfig.py</literal> used by the Celery of <literal>listssrht-process</literal>.",
                       position: (740, 26),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (737, 33),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (731, 17),
            },
           ),
          ],
          recursive: false,
          position: (730, 13),
         },
        ),
       ],
       recursive: false,
       position: (110, 32),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (746, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (746, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (746, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (746, 21),
           },
          ],
         },
         default: None,
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkMerge",
          position: (746, 29),
         },
         arguments: [
          List {
           elements: [
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "environment",
                  position: (748, 7),
                 },
                 Raw {
                  content: "systemPackages",
                  position: (748, 19),
                 },
                ],
               },
               List {
                elements: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (748, 38),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "sourcehut",
                     position: (748, 43),
                    },
                    Raw {
                     content: "coresrht",
                     position: (748, 53),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
                position: (748, 36),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "services",
                  position: (750, 7),
                 },
                 Raw {
                  content: "sourcehut",
                  position: (750, 16),
                 },
                 Raw {
                  content: "settings",
                  position: (750, 26),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "git.sr.ht",
                        position: (751, 10),
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "outgoing-domain",
                     position: (751, 21),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (751, 39),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "https://git.",
                       position: (751, 50),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "domain",
                        position: (751, 64),
                       },
                      },
                     ],
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "lists.sr.ht",
                        position: (752, 10),
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "notify-from",
                     position: (752, 23),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (752, 37),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "lists-notify@",
                       position: (752, 48),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "domain",
                        position: (752, 63),
                       },
                      },
                     ],
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "lists.sr.ht",
                        position: (753, 10),
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "posting-domain",
                     position: (753, 23),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (753, 40),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "lists.",
                       position: (753, 51),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "domain",
                        position: (753, 59),
                       },
                      },
                     ],
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "meta.sr.ht::settings",
                        position: (754, 10),
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "onboarding-redirect",
                     position: (754, 32),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (754, 54),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "https://meta.",
                       position: (754, 65),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "domain",
                        position: (754, 80),
                       },
                      },
                     ],
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "todo.sr.ht",
                        position: (755, 10),
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "notify-from",
                     position: (755, 22),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (755, 36),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "todo-notify@",
                       position: (755, 47),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "domain",
                        position: (755, 61),
                       },
                      },
                     ],
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "todo.sr.ht::mail",
                        position: (756, 10),
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "posting-domain",
                     position: (756, 28),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (756, 45),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "todo.",
                       position: (756, 56),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "domain",
                        position: (756, 63),
                       },
                      },
                     ],
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (750, 37),
               },
              ),
             ],
             recursive: false,
             position: (747, 5),
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (759, 6),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (759, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "postgresql",
                  position: (759, 15),
                 },
                 Raw {
                  content: "enable",
                  position: (759, 26),
                 },
                ],
               },
               default: None,
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "assertions",
                    position: (760, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "assertion",
                         position: (761, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "postgresql",
                        position: (761, 23),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "enable",
                          position: (761, 34),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "message",
                         position: (762, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "postgresql must be enabled and configured",
                         position: (762, 22),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (761, 9),
                   },
                  ],
                  position: (760, 20),
                 },
                ),
               ],
               recursive: false,
               position: (759, 33),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (766, 6),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (766, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "postfix",
                  position: (766, 15),
                 },
                 Raw {
                  content: "enable",
                  position: (766, 23),
                 },
                ],
               },
               default: None,
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "assertions",
                    position: (767, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "assertion",
                         position: (768, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "postfix",
                        position: (768, 23),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "enable",
                          position: (768, 31),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "message",
                         position: (769, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "postfix must be enabled and configured",
                         position: (769, 22),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (768, 9),
                   },
                  ],
                  position: (767, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "systemd",
                    position: (773, 7),
                   },
                   Raw {
                    content: "services",
                    position: (773, 15),
                   },
                   Raw {
                    content: "postfix",
                    position: (773, 24),
                   },
                   Raw {
                    content: "serviceConfig",
                    position: (773, 32),
                   },
                   Raw {
                    content: "PrivateTmp",
                    position: (773, 46),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (773, 59),
                 },
                ),
               ],
               recursive: false,
               position: (766, 30),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (775, 6),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (775, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "redis",
                  position: (775, 15),
                 },
                 Raw {
                  content: "enable",
                  position: (775, 21),
                 },
                ],
               },
               default: None,
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "services",
                    position: (776, 7),
                   },
                   Raw {
                    content: "redis",
                    position: (776, 16),
                   },
                   Raw {
                    content: "vmOverCommit",
                    position: (776, 22),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkDefault",
                   position: (776, 37),
                  },
                  arguments: [
                   Variable {
                    identifier: "true",
                    position: (776, 47),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (775, 28),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (778, 6),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (778, 11),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "nginx",
                  position: (778, 15),
                 },
                 Raw {
                  content: "enable",
                  position: (778, 21),
                 },
                ],
               },
               default: None,
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "assertions",
                    position: (779, 7),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "assertion",
                         position: (780, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "nginx",
                        position: (780, 23),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "enable",
                          position: (780, 29),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "message",
                         position: (781, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "nginx must be enabled and configured",
                         position: (781, 22),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (780, 9),
                   },
                  ],
                  position: (779, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "services",
                    position: (785, 7),
                   },
                   Raw {
                    content: "nginx",
                    position: (785, 16),
                   },
                   Raw {
                    content: "recommendedProxySettings",
                    position: (785, 22),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkDefault",
                   position: (785, 49),
                  },
                  arguments: [
                   Variable {
                    identifier: "true",
                    position: (785, 59),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (778, 28),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkIf",
              position: (787, 6),
             },
             arguments: [
              BinaryOperation {
               operator: LogicalOr,
               operands: [
                BinaryOperation {
                 operator: LogicalOr,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (787, 12),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "builds",
                      position: (787, 16),
                     },
                     Raw {
                      content: "enable",
                      position: (787, 23),
                     },
                    ],
                   },
                   default: None,
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (787, 33),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "git",
                      position: (787, 37),
                     },
                     Raw {
                      content: "enable",
                      position: (787, 41),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (787, 30),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (787, 51),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "hg",
                    position: (787, 55),
                   },
                   Raw {
                    content: "enable",
                    position: (787, 58),
                   },
                  ],
                 },
                 default: None,
                },
               ],
               position: (787, 48),
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "services",
                    position: (788, 7),
                   },
                   Raw {
                    content: "openssh",
                    position: (788, 16),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "authorizedKeysCommand",
                       position: (796, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/etc/ssh/sourcehut/subdir/srht-dispatch \"%u\" \"%h\" \"%t\" \"%k\"",
                       position: (796, 35),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "authorizedKeysCommandUser",
                       position: (798, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "root",
                       position: (798, 38),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "extraConfig",
                       position: (799, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "PermitUserEnvironment SRHT_*\n",
                       position: (800, 1),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (788, 26),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "environment",
                    position: (803, 7),
                   },
                   Raw {
                    content: "etc",
                    position: (803, 19),
                   },
                   Expression {
                    expression: String {
                     parts: [
                      Raw {
                       content: "ssh/sourcehut/config.ini",
                       position: (803, 24),
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "source",
                    position: (803, 50),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "settingsFormat",
                    position: (804, 9),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "generate",
                      position: (804, 24),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "sourcehut-dispatch-config.ini",
                      position: (804, 34),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "filterAttrs",
                     position: (805, 12),
                    },
                    arguments: [
                     Function {
                      argument: Some(
                       "k",
                      ),
                      arguments: FunctionArguments {
                       arguments: [],
                       ellipsis: false,
                      },
                      definition: Function {
                       argument: Some(
                        "v",
                       ),
                       arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                       },
                       definition: BinaryOperation {
                        operator: EqualTo,
                        operands: [
                         Variable {
                          identifier: "k",
                          position: (805, 31),
                         },
                         String {
                          parts: [
                           Raw {
                            content: "git.sr.ht::dispatch",
                            position: (805, 37),
                           },
                          ],
                         },
                        ],
                        position: (805, 33),
                       },
                       position: (805, 28),
                      },
                      position: (805, 25),
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (806, 11),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "settings",
                         position: (806, 15),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "environment",
                    position: (807, 7),
                   },
                   Raw {
                    content: "etc",
                    position: (807, 19),
                   },
                   Expression {
                    expression: String {
                     parts: [
                      Raw {
                       content: "ssh/sourcehut/subdir/srht-dispatch",
                       position: (807, 24),
                      },
                     ],
                    },
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "mode",
                       position: (809, 9),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "0755",
                       position: (809, 17),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "source",
                       position: (810, 9),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (810, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "writeShellScript",
                         position: (810, 23),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "srht-dispatch",
                         position: (810, 41),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "set -e\ncd /etc/ssh/sourcehut/subdir\n",
                         position: (811, 1),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (813, 13),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "python",
                             position: (813, 17),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/gitsrht-dispatch \"$@\"\n",
                         position: (813, 24),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (807, 62),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "systemd",
                    position: (816, 7),
                   },
                   Raw {
                    content: "services",
                    position: (816, 15),
                   },
                   Raw {
                    content: "sshd",
                    position: (816, 24),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "serviceConfig",
                       position: (818, 9),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "BindReadOnlyPaths",
                          position: (819, 11),
                         },
                        ],
                       },
                       BinaryOperation {
                        operator: Concatenation,
                        operands: [
                         FunctionApplication {
                          function: Variable {
                           identifier: "optionals",
                           position: (827, 13),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (827, 23),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "builds",
                               position: (827, 27),
                              },
                              Raw {
                               content: "enable",
                               position: (827, 34),
                              },
                             ],
                            },
                            default: None,
                           },
                           List {
                            elements: [
                             String {
                              parts: [
                               Expression {
                                expression: FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "pkgs",
                                   position: (828, 18),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "writeShellScript",
                                     position: (828, 23),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  String {
                                   parts: [
                                    Raw {
                                     content: "buildsrht-keys-wrapper",
                                     position: (828, 41),
                                    },
                                   ],
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "set -e\ncd /run/sourcehut/buildsrht/subdir\nset -x\nexec -a \"$0\" ",
                                     position: (829, 1),
                                    },
                                    Expression {
                                     expression: PropertyAccess {
                                      expression: Variable {
                                       identifier: "pkgs",
                                       position: (832, 32),
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "sourcehut",
                                         position: (832, 37),
                                        },
                                        Raw {
                                         content: "buildsrht",
                                         position: (832, 47),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                    },
                                    Raw {
                                     content: "/bin/buildsrht-keys \"$@\"\n",
                                     position: (832, 57),
                                    },
                                   ],
                                  },
                                 ],
                                },
                               },
                               Raw {
                                content: ":/usr/bin/buildsrht-keys",
                                position: (833, 18),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "pkgs",
                                  position: (834, 18),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "sourcehut",
                                    position: (834, 23),
                                   },
                                   Raw {
                                    content: "buildsrht",
                                    position: (834, 33),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "/bin/master-shell:/usr/bin/master-shell",
                                position: (834, 43),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "pkgs",
                                  position: (835, 18),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "sourcehut",
                                    position: (835, 23),
                                   },
                                   Raw {
                                    content: "buildsrht",
                                    position: (835, 33),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "/bin/runner-shell:/usr/bin/runner-shell",
                                position: (835, 43),
                               },
                              ],
                             },
                            ],
                            position: (827, 41),
                           },
                          ],
                         },
                         BinaryOperation {
                          operator: Concatenation,
                          operands: [
                           FunctionApplication {
                            function: Variable {
                             identifier: "optionals",
                             position: (837, 13),
                            },
                            arguments: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (837, 23),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "git",
                                 position: (837, 27),
                                },
                                Raw {
                                 content: "enable",
                                 position: (837, 31),
                                },
                               ],
                              },
                              default: None,
                             },
                             List {
                              elements: [
                               String {
                                parts: [
                                 Expression {
                                  expression: FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "pkgs",
                                     position: (840, 18),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "writeShellScript",
                                       position: (840, 23),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    String {
                                     parts: [
                                      Raw {
                                       content: "gitsrht-keys-wrapper",
                                       position: (840, 41),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "set -e\ncd /run/sourcehut/gitsrht/subdir\nset -x\nexec -a \"$0\" ",
                                       position: (841, 1),
                                      },
                                      Expression {
                                       expression: PropertyAccess {
                                        expression: Variable {
                                         identifier: "pkgs",
                                         position: (844, 32),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "sourcehut",
                                           position: (844, 37),
                                          },
                                          Raw {
                                           content: "gitsrht",
                                           position: (844, 47),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      },
                                      Raw {
                                       content: "/bin/gitsrht-keys \"$@\"\n",
                                       position: (844, 55),
                                      },
                                     ],
                                    },
                                   ],
                                  },
                                 },
                                 Raw {
                                  content: ":/usr/bin/gitsrht-keys",
                                  position: (845, 18),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Expression {
                                  expression: FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "pkgs",
                                     position: (846, 18),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "writeShellScript",
                                       position: (846, 23),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    String {
                                     parts: [
                                      Raw {
                                       content: "gitsrht-shell-wrapper",
                                       position: (846, 41),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "set -e\ncd /run/sourcehut/gitsrht/subdir\nset -x\nexec -a \"$0\" ",
                                       position: (847, 1),
                                      },
                                      Expression {
                                       expression: PropertyAccess {
                                        expression: Variable {
                                         identifier: "pkgs",
                                         position: (850, 32),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "sourcehut",
                                           position: (850, 37),
                                          },
                                          Raw {
                                           content: "gitsrht",
                                           position: (850, 47),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      },
                                      Raw {
                                       content: "/bin/gitsrht-shell \"$@\"\n",
                                       position: (850, 55),
                                      },
                                     ],
                                    },
                                   ],
                                  },
                                 },
                                 Raw {
                                  content: ":/usr/bin/gitsrht-shell",
                                  position: (851, 18),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Expression {
                                  expression: FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "pkgs",
                                     position: (852, 18),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "writeShellScript",
                                       position: (852, 23),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    String {
                                     parts: [
                                      Raw {
                                       content: "gitsrht-update-hook",
                                       position: (852, 41),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "set -e\ntest -e \"",
                                       position: (853, 1),
                                      },
                                      Raw {
                                       content: "$",
                                       position: (854, 26),
                                      },
                                      Raw {
                                       content: "{PWD%/*}\"/config.ini ||\n# Git hooks are run relative to their repository's directory,\n# but gitsrht-update-hook looks up ../config.ini\nln -s /run/sourcehut/gitsrht/config.ini \"",
                                       position: (854, 29),
                                      },
                                      Raw {
                                       content: "$",
                                       position: (857, 58),
                                      },
                                      Raw {
                                       content: "{PWD%/*}\"/config.ini\n# hooks/post-update calls /usr/bin/gitsrht-update-hook as hooks/stage-3\n# but this wrapper being a bash script, it overrides $0 with /usr/bin/gitsrht-update-hook\n# hence this hack to put hooks/stage-3 back into gitsrht-update-hook's $0\nif test \"",
                                       position: (857, 61),
                                      },
                                      Raw {
                                       content: "$",
                                       position: (861, 26),
                                      },
                                      Raw {
                                       content: "{STAGE3:+set}\"\nthen\n  set -x\n  exec -a hooks/stage-3 ",
                                       position: (861, 29),
                                      },
                                      Expression {
                                       expression: PropertyAccess {
                                        expression: Variable {
                                         identifier: "pkgs",
                                         position: (864, 43),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "sourcehut",
                                           position: (864, 48),
                                          },
                                          Raw {
                                           content: "gitsrht",
                                           position: (864, 58),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      },
                                      Raw {
                                       content: "/bin/gitsrht-update-hook \"$@\"\nelse\n  export STAGE3=set\n  set -x\n  exec -a \"$0\" ",
                                       position: (864, 66),
                                      },
                                      Expression {
                                       expression: PropertyAccess {
                                        expression: Variable {
                                         identifier: "pkgs",
                                         position: (868, 34),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "sourcehut",
                                           position: (868, 39),
                                          },
                                          Raw {
                                           content: "gitsrht",
                                           position: (868, 49),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      },
                                      Raw {
                                       content: "/bin/gitsrht-update-hook \"$@\"\nfi\n",
                                       position: (868, 57),
                                      },
                                     ],
                                    },
                                   ],
                                  },
                                 },
                                 Raw {
                                  content: ":/usr/bin/gitsrht-update-hook",
                                  position: (870, 18),
                                 },
                                ],
                               },
                              ],
                              position: (837, 38),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "optionals",
                             position: (872, 13),
                            },
                            arguments: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (872, 23),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "hg",
                                 position: (872, 27),
                                },
                                Raw {
                                 content: "enable",
                                 position: (872, 30),
                                },
                               ],
                              },
                              default: None,
                             },
                             List {
                              elements: [
                               String {
                                parts: [
                                 Expression {
                                  expression: FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "pkgs",
                                     position: (875, 18),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "writeShellScript",
                                       position: (875, 23),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    String {
                                     parts: [
                                      Raw {
                                       content: "hgsrht-keys-wrapper",
                                       position: (875, 41),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "set -e\ncd /run/sourcehut/hgsrht/subdir\nset -x\nexec -a \"$0\" ",
                                       position: (876, 1),
                                      },
                                      Expression {
                                       expression: PropertyAccess {
                                        expression: Variable {
                                         identifier: "pkgs",
                                         position: (879, 32),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "sourcehut",
                                           position: (879, 37),
                                          },
                                          Raw {
                                           content: "hgsrht",
                                           position: (879, 47),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      },
                                      Raw {
                                       content: "/bin/hgsrht-keys \"$@\"\n",
                                       position: (879, 54),
                                      },
                                     ],
                                    },
                                   ],
                                  },
                                 },
                                 Raw {
                                  content: ":/usr/bin/hgsrht-keys",
                                  position: (880, 18),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Expression {
                                  expression: FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "pkgs",
                                     position: (881, 18),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "writeShellScript",
                                       position: (881, 23),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    String {
                                     parts: [
                                      Raw {
                                       content: "hgsrht-shell-wrapper",
                                       position: (881, 41),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "set -e\ncd /run/sourcehut/hgsrht/subdir\nset -x\nexec -a \"$0\" ",
                                       position: (882, 1),
                                      },
                                      Expression {
                                       expression: PropertyAccess {
                                        expression: Variable {
                                         identifier: "pkgs",
                                         position: (885, 32),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "sourcehut",
                                           position: (885, 37),
                                          },
                                          Raw {
                                           content: "hgsrht",
                                           position: (885, 47),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      },
                                      Raw {
                                       content: "/bin/hgsrht-shell \"$@\"\n",
                                       position: (885, 54),
                                      },
                                     ],
                                    },
                                   ],
                                  },
                                 },
                                 Raw {
                                  content: ":/usr/bin/hgsrht-shell",
                                  position: (886, 18),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Expression {
                                  expression: FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "pkgs",
                                     position: (889, 18),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "writeShellScript",
                                       position: (889, 23),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    String {
                                     parts: [
                                      Raw {
                                       content: "hgsrht-hook-changegroup",
                                       position: (889, 41),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "set -e\ntest -e \"",
                                       position: (890, 1),
                                      },
                                      Raw {
                                       content: "$",
                                       position: (891, 26),
                                      },
                                      Raw {
                                       content: "PWD\"/config.ini ||\nln -s /run/sourcehut/hgsrht/config.ini \"",
                                       position: (891, 29),
                                      },
                                      Raw {
                                       content: "$",
                                       position: (892, 57),
                                      },
                                      Raw {
                                       content: "PWD\"/config.ini\nset -x\nexec -a \"$0\" ",
                                       position: (892, 60),
                                      },
                                      Expression {
                                       expression: PropertyAccess {
                                        expression: Variable {
                                         identifier: "cfg",
                                         position: (894, 32),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "python",
                                           position: (894, 36),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      },
                                      Raw {
                                       content: "/bin/hgsrht-hook-changegroup \"$@\"\n",
                                       position: (894, 43),
                                      },
                                     ],
                                    },
                                   ],
                                  },
                                 },
                                 Raw {
                                  content: ":/usr/bin/hgsrht-hook-changegroup",
                                  position: (895, 18),
                                 },
                                ],
                               },
                              ],
                              position: (872, 37),
                             },
                            ],
                           },
                          ],
                          position: (871, 15),
                         },
                        ],
                        position: (836, 15),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (818, 25),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (816, 31),
                 },
                ),
               ],
               recursive: false,
               position: (787, 66),
              },
             ],
            },
           ],
           position: (746, 37),
          },
         ],
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (902, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "import",
          position: (904, 6),
         },
         arguments: [
          Path {
           parts: [
            Raw {
             content: "./service.nix",
             position: (904, 13),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "builds",
             position: (904, 28),
            },
           ],
          },
          Map {
           bindings: [
            Inherit(
             None,
             [
              Raw {
               content: "configIniOfService",
               position: (905, 15),
              },
             ],
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "srvsrht",
                position: (906, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "buildsrht",
                position: (906, 18),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (907, 7),
               },
              ],
             },
             Int {
              value: 5002,
              position: (907, 14),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "extraServices",
                position: (909, 7),
               },
               Raw {
                content: "buildsrht-worker",
                position: (909, 21),
               },
              ],
             },
             LetIn {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "qemuPackage",
                   position: (910, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (910, 23),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "qemu_kvm",
                    position: (910, 28),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceName",
                   position: (911, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "buildsrht-worker",
                   position: (911, 24),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "statePath",
                   position: (912, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "/var/lib/sourcehut/",
                   position: (912, 22),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "serviceName",
                    position: (912, 43),
                   },
                  },
                 ],
                },
               ),
              ],
              target: FunctionApplication {
               function: Variable {
                identifier: "mkIf",
                position: (913, 12),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (913, 17),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "builds",
                    position: (913, 21),
                   },
                   Raw {
                    content: "enableWorker",
                    position: (913, 28),
                   },
                  ],
                 },
                 default: None,
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "path",
                      position: (914, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (914, 18),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "openssh",
                         position: (914, 23),
                        },
                       ],
                      },
                      default: None,
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (914, 31),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "docker",
                         position: (914, 36),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (914, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "preStart",
                      position: (915, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "set -x\nif test -z \"$(docker images -q qemu:latest 2>/dev/null)\" \\\n|| test \"$(cat ",
                      position: (916, 1),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "statePath",
                       position: (918, 28),
                      },
                     },
                     Raw {
                      content: "/docker-image-qemu)\" != \"",
                      position: (918, 38),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "qemuPackage",
                        position: (918, 65),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "version",
                          position: (918, 77),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "\"\nthen\n  # Create and import qemu:latest image for docker\n  ",
                      position: (918, 85),
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (921, 15),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "dockerTools",
                           position: (921, 20),
                          },
                          Raw {
                           content: "streamLayeredImage",
                           position: (921, 32),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "name",
                              position: (922, 15),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "qemu",
                              position: (922, 23),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "tag",
                              position: (923, 15),
                             },
                            ],
                           },
                           String {
                            parts: [
                             Raw {
                              content: "latest",
                              position: (923, 22),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "contents",
                              position: (924, 15),
                             },
                            ],
                           },
                           List {
                            elements: [
                             Variable {
                              identifier: "qemuPackage",
                              position: (924, 28),
                             },
                            ],
                            position: (924, 26),
                           },
                          ),
                         ],
                         recursive: false,
                         position: (921, 51),
                        },
                       ],
                      },
                     },
                     Raw {
                      content: " | docker load\n  # Mark down current package version\n  echo ",
                      position: (925, 15),
                     },
                     Raw {
                      content: "'",
                      position: (927, 18),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "qemuPackage",
                        position: (927, 21),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "version",
                          position: (927, 33),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "' >",
                      position: (927, 41),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "statePath",
                       position: (927, 46),
                      },
                     },
                     Raw {
                      content: "/docker-image-qemu\nfi\n",
                      position: (927, 56),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "serviceConfig",
                      position: (930, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "ExecStart",
                         position: (931, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (931, 26),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "sourcehut",
                             position: (931, 31),
                            },
                            Raw {
                             content: "buildsrht",
                             position: (931, 41),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/builds.sr.ht-worker",
                         position: (931, 51),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "BindPaths",
                         position: (932, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (932, 25),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "settings",
                            position: (932, 29),
                           },
                           Expression {
                            expression: String {
                             parts: [
                              Raw {
                               content: "builds.sr.ht::worker",
                               position: (932, 39),
                              },
                             ],
                            },
                           },
                           Raw {
                            content: "buildlogs",
                            position: (932, 61),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                       position: (932, 23),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "LogsDirectory",
                         position: (933, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "sourcehut/",
                           position: (933, 30),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "serviceName",
                            position: (933, 42),
                           },
                          },
                         ],
                        },
                       ],
                       position: (933, 27),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "RuntimeDirectory",
                         position: (934, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "sourcehut/",
                           position: (934, 33),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "serviceName",
                            position: (934, 45),
                           },
                          },
                          Raw {
                           content: "/subdir",
                           position: (934, 57),
                          },
                         ],
                        },
                       ],
                       position: (934, 30),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "StateDirectory",
                         position: (935, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "sourcehut/",
                           position: (935, 31),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "serviceName",
                            position: (935, 43),
                           },
                          },
                         ],
                        },
                       ],
                       position: (935, 28),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "TimeoutStartSec",
                         position: (936, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "1800s",
                         position: (936, 30),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "WorkingDirectory",
                         position: (938, 11),
                        },
                       ],
                      },
                      BinaryOperation {
                       operator: Addition,
                       operands: [
                        String {
                         parts: [
                          Raw {
                           content: "-",
                           position: (938, 31),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "/run/sourcehut/",
                           position: (938, 35),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "serviceName",
                            position: (938, 52),
                           },
                          },
                          Raw {
                           content: "/subdir",
                           position: (938, 64),
                          },
                         ],
                        },
                       ],
                       position: (938, 33),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (930, 25),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (913, 41),
                },
               ],
              },
              position: (909, 40),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "extraConfig",
                position: (941, 7),
               },
              ],
             },
             LetIn {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "image_dirs",
                   position: (942, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "flatten",
                  position: (942, 22),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "mapAttrsToList",
                    position: (943, 11),
                   },
                   arguments: [
                    Function {
                     argument: Some(
                      "distro",
                     ),
                     arguments: FunctionArguments {
                      arguments: [],
                      ellipsis: false,
                     },
                     definition: Function {
                      argument: Some(
                       "revs",
                      ),
                      arguments: FunctionArguments {
                       arguments: [],
                       ellipsis: false,
                      },
                      definition: FunctionApplication {
                       function: Variable {
                        identifier: "mapAttrsToList",
                        position: (944, 13),
                       },
                       arguments: [
                        Function {
                         argument: Some(
                          "rev",
                         ),
                         arguments: FunctionArguments {
                          arguments: [],
                          ellipsis: false,
                         },
                         definition: Function {
                          argument: Some(
                           "archs",
                          ),
                          arguments: FunctionArguments {
                           arguments: [],
                           ellipsis: false,
                          },
                          definition: FunctionApplication {
                           function: Variable {
                            identifier: "mapAttrsToList",
                            position: (945, 15),
                           },
                           arguments: [
                            Function {
                             argument: Some(
                              "arch",
                             ),
                             arguments: FunctionArguments {
                              arguments: [],
                              ellipsis: false,
                             },
                             definition: Function {
                              argument: Some(
                               "image",
                              ),
                              arguments: FunctionArguments {
                               arguments: [],
                               ellipsis: false,
                              },
                              definition: FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "pkgs",
                                 position: (946, 17),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "runCommand",
                                   position: (946, 22),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "buildsrht-images",
                                   position: (946, 34),
                                  },
                                 ],
                                },
                                Map {
                                 bindings: [],
                                 recursive: false,
                                 position: (946, 52),
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "mkdir -p $out/",
                                   position: (947, 1),
                                  },
                                  Expression {
                                   expression: Variable {
                                    identifier: "distro",
                                    position: (947, 35),
                                   },
                                  },
                                  Raw {
                                   content: "/",
                                   position: (947, 42),
                                  },
                                  Expression {
                                   expression: Variable {
                                    identifier: "rev",
                                    position: (947, 45),
                                   },
                                  },
                                  Raw {
                                   content: "/",
                                   position: (947, 49),
                                  },
                                  Expression {
                                   expression: Variable {
                                    identifier: "arch",
                                    position: (947, 52),
                                   },
                                  },
                                  Raw {
                                   content: "\nln -s ",
                                   position: (947, 57),
                                  },
                                  Expression {
                                   expression: Variable {
                                    identifier: "image",
                                    position: (948, 27),
                                   },
                                  },
                                  Raw {
                                   content: "/*.qcow2 $out/",
                                   position: (948, 33),
                                  },
                                  Expression {
                                   expression: Variable {
                                    identifier: "distro",
                                    position: (948, 49),
                                   },
                                  },
                                  Raw {
                                   content: "/",
                                   position: (948, 56),
                                  },
                                  Expression {
                                   expression: Variable {
                                    identifier: "rev",
                                    position: (948, 59),
                                   },
                                  },
                                  Raw {
                                   content: "/",
                                   position: (948, 63),
                                  },
                                  Expression {
                                   expression: Variable {
                                    identifier: "arch",
                                    position: (948, 66),
                                   },
                                  },
                                  Raw {
                                   content: "/root.img.qcow2\n",
                                   position: (948, 71),
                                  },
                                 ],
                                },
                               ],
                              },
                              position: (945, 37),
                             },
                             position: (945, 31),
                            },
                            Variable {
                             identifier: "archs",
                             position: (950, 17),
                            },
                           ],
                          },
                          position: (944, 34),
                         },
                         position: (944, 29),
                        },
                        Variable {
                         identifier: "revs",
                         position: (951, 15),
                        },
                       ],
                      },
                      position: (943, 35),
                     },
                     position: (943, 27),
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (952, 13),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "builds",
                        position: (952, 17),
                       },
                       Raw {
                        content: "images",
                        position: (952, 24),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "image_dir_pre",
                   position: (954, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (954, 25),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "symlinkJoin",
                     position: (954, 30),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "name",
                        position: (955, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "builds.sr.ht-worker-images-pre",
                        position: (955, 19),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "paths",
                        position: (956, 11),
                       },
                      ],
                     },
                     Variable {
                      identifier: "image_dirs",
                      position: (956, 19),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (954, 42),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "image_dir",
                   position: (960, 9),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (960, 21),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "runCommand",
                     position: (960, 26),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "builds.sr.ht-worker-images",
                     position: (960, 38),
                    },
                   ],
                  },
                  Map {
                   bindings: [],
                   recursive: false,
                   position: (960, 66),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "mkdir -p $out/images\ncp -Lr ",
                     position: (961, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "image_dir_pre",
                      position: (962, 20),
                     },
                    },
                    Raw {
                     content: "/* $out/images\n",
                     position: (962, 34),
                    },
                   ],
                  },
                 ],
                },
               ),
              ],
              target: FunctionApplication {
               function: Variable {
                identifier: "mkMerge",
                position: (964, 12),
               },
               arguments: [
                List {
                 elements: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "users",
                        position: (966, 11),
                       },
                       Raw {
                        content: "users",
                        position: (966, 17),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (966, 25),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "builds",
                            position: (966, 29),
                           },
                           Raw {
                            content: "user",
                            position: (966, 36),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "shell",
                        position: (966, 42),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (966, 50),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "bash",
                         position: (966, 55),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "virtualisation",
                        position: (968, 11),
                       },
                       Raw {
                        content: "docker",
                        position: (968, 26),
                       },
                       Raw {
                        content: "enable",
                        position: (968, 33),
                       },
                      ],
                     },
                     Variable {
                      identifier: "true",
                      position: (968, 42),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "services",
                        position: (970, 11),
                       },
                       Raw {
                        content: "sourcehut",
                        position: (970, 20),
                       },
                       Raw {
                        content: "settings",
                        position: (970, 30),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "mkMerge",
                       position: (970, 41),
                      },
                      arguments: [
                       List {
                        elements: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Expression {
                               expression: String {
                                parts: [
                                 Raw {
                                  content: "git.sr.ht::dispatch",
                                  position: (973, 16),
                                 },
                                ],
                               },
                              },
                              Expression {
                               expression: String {
                                parts: [
                                 Raw {
                                  content: "/usr/bin/buildsrht-keys",
                                  position: (973, 38),
                                 },
                                ],
                               },
                              },
                             ],
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "mkDefault",
                              position: (974, 17),
                             },
                             arguments: [
                              String {
                               parts: [
                                Expression {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "cfg",
                                   position: (974, 30),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "builds",
                                     position: (974, 34),
                                    },
                                    Raw {
                                     content: "user",
                                     position: (974, 41),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                                Raw {
                                 content: ":",
                                 position: (974, 46),
                                },
                                Expression {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "cfg",
                                   position: (974, 49),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "builds",
                                     position: (974, 53),
                                    },
                                    Raw {
                                     content: "group",
                                     position: (974, 60),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                               ],
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (971, 13),
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkIf",
                           position: (976, 14),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (976, 19),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "builds",
                               position: (976, 23),
                              },
                              Raw {
                               content: "enableWorker",
                               position: (976, 30),
                              },
                             ],
                            },
                            default: None,
                           },
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Expression {
                                 expression: String {
                                  parts: [
                                   Raw {
                                    content: "builds.sr.ht::worker",
                                    position: (977, 16),
                                   },
                                  ],
                                 },
                                },
                                Raw {
                                 content: "shell",
                                 position: (977, 38),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "/usr/bin/runner-shell",
                                 position: (977, 47),
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Expression {
                                 expression: String {
                                  parts: [
                                   Raw {
                                    content: "builds.sr.ht::worker",
                                    position: (978, 16),
                                   },
                                  ],
                                 },
                                },
                                Raw {
                                 content: "images",
                                 position: (978, 38),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: Variable {
                                identifier: "mkDefault",
                                position: (978, 47),
                               },
                               arguments: [
                                String {
                                 parts: [
                                  Expression {
                                   expression: Variable {
                                    identifier: "image_dir",
                                    position: (978, 60),
                                   },
                                  },
                                  Raw {
                                   content: "/images",
                                   position: (978, 70),
                                  },
                                 ],
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Expression {
                                 expression: String {
                                  parts: [
                                   Raw {
                                    content: "builds.sr.ht::worker",
                                    position: (979, 16),
                                   },
                                  ],
                                 },
                                },
                                Raw {
                                 content: "controlcmd",
                                 position: (979, 38),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: Variable {
                                identifier: "mkDefault",
                                position: (979, 51),
                               },
                               arguments: [
                                String {
                                 parts: [
                                  Expression {
                                   expression: Variable {
                                    identifier: "image_dir",
                                    position: (979, 64),
                                   },
                                  },
                                  Raw {
                                   content: "/images/control",
                                   position: (979, 74),
                                  },
                                 ],
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (976, 43),
                           },
                          ],
                         },
                        ],
                        position: (970, 49),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (965, 9),
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkIf",
                    position: (983, 10),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (983, 15),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "builds",
                        position: (983, 19),
                       },
                       Raw {
                        content: "enableWorker",
                        position: (983, 26),
                       },
                      ],
                     },
                     default: None,
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "users",
                          position: (984, 11),
                         },
                         Raw {
                          content: "groups",
                          position: (984, 17),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "docker",
                             position: (985, 13),
                            },
                            Raw {
                             content: "members",
                             position: (985, 20),
                            },
                           ],
                          },
                          List {
                           elements: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (985, 32),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "builds",
                                position: (985, 36),
                               },
                               Raw {
                                content: "user",
                                position: (985, 43),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                           position: (985, 30),
                          },
                         ),
                        ],
                        recursive: false,
                        position: (984, 26),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (983, 39),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkIf",
                    position: (988, 10),
                   },
                   arguments: [
                    BinaryOperation {
                     operator: LogicalAnd,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (988, 16),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "builds",
                          position: (988, 20),
                         },
                         Raw {
                          content: "enableWorker",
                          position: (988, 27),
                         },
                        ],
                       },
                       default: None,
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (988, 43),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "nginx",
                          position: (988, 47),
                         },
                         Raw {
                          content: "enable",
                          position: (988, 53),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                     position: (988, 40),
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "users",
                          position: (990, 11),
                         },
                         Raw {
                          content: "users",
                          position: (990, 17),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "nginx",
                            position: (990, 25),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "user",
                              position: (990, 31),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "extraGroups",
                          position: (990, 37),
                         },
                        ],
                       },
                       List {
                        elements: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (990, 53),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "builds",
                             position: (990, 57),
                            },
                            Raw {
                             content: "group",
                             position: (990, 64),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                        position: (990, 51),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "systemd",
                          position: (991, 11),
                         },
                         Raw {
                          content: "services",
                          position: (991, 19),
                         },
                         Raw {
                          content: "nginx",
                          position: (991, 28),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "serviceConfig",
                             position: (992, 13),
                            },
                            Raw {
                             content: "BindReadOnlyPaths",
                             position: (992, 27),
                            },
                           ],
                          },
                          List {
                           elements: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (992, 49),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "settings",
                                position: (992, 53),
                               },
                               Expression {
                                expression: String {
                                 parts: [
                                  Raw {
                                   content: "builds.sr.ht::worker",
                                   position: (992, 63),
                                  },
                                 ],
                                },
                               },
                               Raw {
                                content: "buildlogs",
                                position: (992, 85),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                           position: (992, 47),
                          },
                         ),
                        ],
                        recursive: false,
                        position: (991, 36),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "services",
                          position: (994, 11),
                         },
                         Raw {
                          content: "nginx",
                          position: (994, 20),
                         },
                         Raw {
                          content: "virtualHosts",
                          position: (994, 26),
                         },
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "logs.",
                             position: (994, 40),
                            },
                            Expression {
                             expression: Variable {
                              identifier: "domain",
                              position: (994, 47),
                             },
                            },
                           ],
                          },
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkMerge",
                         position: (994, 58),
                        },
                        arguments: [
                         List {
                          elements: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "locations",
                                 position: (1001, 13),
                                },
                                Expression {
                                 expression: String {
                                  parts: [
                                   Raw {
                                    content: "/logs/",
                                    position: (1001, 24),
                                   },
                                  ],
                                 },
                                },
                                Raw {
                                 content: "alias",
                                 position: (1001, 32),
                                },
                               ],
                              },
                              BinaryOperation {
                               operator: Addition,
                               operands: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (1001, 40),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "settings",
                                    position: (1001, 44),
                                   },
                                   Expression {
                                    expression: String {
                                     parts: [
                                      Raw {
                                       content: "builds.sr.ht::worker",
                                       position: (1001, 54),
                                      },
                                     ],
                                    },
                                   },
                                   Raw {
                                    content: "buildlogs",
                                    position: (1001, 76),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "/",
                                   position: (1001, 89),
                                  },
                                 ],
                                },
                               ],
                               position: (1001, 86),
                              },
                             ),
                            ],
                            recursive: false,
                            position: (994, 68),
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1002, 13),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "nginx",
                               position: (1002, 17),
                              },
                              Raw {
                               content: "virtualHost",
                               position: (1002, 23),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                          position: (994, 66),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (988, 61),
                    },
                   ],
                  },
                 ],
                 position: (964, 20),
                },
               ],
              },
              position: (941, 21),
             },
            ),
           ],
           recursive: false,
           position: (904, 36),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "import",
          position: (1007, 6),
         },
         arguments: [
          Path {
           parts: [
            Raw {
             content: "./service.nix",
             position: (1007, 13),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "dispatch",
             position: (1007, 28),
            },
           ],
          },
          Map {
           bindings: [
            Inherit(
             None,
             [
              Raw {
               content: "configIniOfService",
               position: (1008, 15),
              },
             ],
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (1009, 7),
               },
              ],
             },
             Int {
              value: 5005,
              position: (1009, 14),
             },
            ),
           ],
           recursive: false,
           position: (1007, 38),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "import",
          position: (1012, 6),
         },
         arguments: [
          Path {
           parts: [
            Raw {
             content: "./service.nix",
             position: (1012, 13),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "git",
             position: (1012, 28),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "baseService",
                position: (1013, 7),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (1014, 9),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (1014, 18),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "git",
                      position: (1014, 22),
                     },
                     Raw {
                      content: "package",
                      position: (1014, 26),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (1014, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1015, 9),
                  },
                  Raw {
                   content: "BindPaths",
                   position: (1015, 23),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (1015, 40),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "settings",
                         position: (1015, 44),
                        },
                        Expression {
                         expression: String {
                          parts: [
                           Raw {
                            content: "git.sr.ht",
                            position: (1015, 54),
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "repos",
                         position: (1015, 65),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: ":/var/lib/sourcehut/gitsrht/repos",
                     position: (1015, 71),
                    },
                   ],
                  },
                 ],
                 position: (1015, 35),
                },
               ),
              ],
              recursive: false,
              position: (1013, 21),
             },
            ),
           ],
           target: Map {
            bindings: [
             Inherit(
              None,
              [
               Raw {
                content: "configIniOfService",
                position: (1018, 15),
               },
              ],
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "mainService",
                 position: (1019, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkMerge",
                position: (1019, 21),
               },
               arguments: [
                List {
                 elements: [
                  Variable {
                   identifier: "baseService",
                   position: (1019, 31),
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "serviceConfig",
                        position: (1020, 9),
                       },
                       Raw {
                        content: "StateDirectory",
                        position: (1020, 23),
                       },
                      ],
                     },
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "sourcehut/gitsrht",
                          position: (1020, 43),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "sourcehut/gitsrht/repos",
                          position: (1020, 63),
                         },
                        ],
                       },
                      ],
                      position: (1020, 40),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "preStart",
                        position: (1021, 9),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "mkIf",
                       position: (1021, 20),
                      },
                      arguments: [
                       UnaryOperation {
                        operator: Not,
                        operand: FunctionApplication {
                         function: Variable {
                          identifier: "versionAtLeast",
                          position: (1021, 27),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "config",
                            position: (1021, 42),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "system",
                              position: (1021, 49),
                             },
                             Raw {
                              content: "stateVersion",
                              position: (1021, 56),
                             },
                            ],
                           },
                           default: None,
                          },
                          String {
                           parts: [
                            Raw {
                             content: "22.05",
                             position: (1021, 70),
                            },
                           ],
                          },
                         ],
                        },
                        position: (1021, 26),
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "mkBefore",
                         position: (1021, 79),
                        },
                        arguments: [
                         String {
                          parts: [
                           Raw {
                            content: "# Fix Git hooks of repositories pre-dating https://github.com/NixOS/nixpkgs/pull/133984\n(\nset +f\nshopt -s nullglob\nfor h in /var/lib/sourcehut/gitsrht/repos/~*/*/hooks/{pre-receive,update,post-update}\ndo ln -fnsv /usr/bin/gitsrht-update-hook \"$h\"; done\n)\n",
                            position: (1022, 1),
                           },
                          ],
                         },
                        ],
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (1019, 43),
                  },
                 ],
                 position: (1019, 29),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "port",
                 position: (1031, 7),
                },
               ],
              },
              Int {
               value: 5001,
               position: (1031, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "webhooks",
                 position: (1032, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (1032, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "extraTimers",
                 position: (1033, 7),
                },
                Raw {
                 content: "gitsrht-periodic",
                 position: (1033, 19),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "service",
                    position: (1034, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "baseService",
                  position: (1034, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "timerConfig",
                    position: (1035, 9),
                   },
                   Raw {
                    content: "OnCalendar",
                    position: (1035, 21),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "*:0/20",
                      position: (1035, 36),
                     },
                    ],
                   },
                  ],
                  position: (1035, 34),
                 },
                ),
               ],
               recursive: false,
               position: (1033, 38),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "extraConfig",
                 position: (1037, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkMerge",
                position: (1037, 21),
               },
               arguments: [
                List {
                 elements: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "users",
                        position: (1041, 11),
                       },
                       Raw {
                        content: "users",
                        position: (1041, 17),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1041, 25),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "git",
                            position: (1041, 29),
                           },
                           Raw {
                            content: "user",
                            position: (1041, 33),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "shell",
                        position: (1041, 39),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (1041, 47),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "bash",
                         position: (1041, 52),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "services",
                        position: (1042, 11),
                       },
                       Raw {
                        content: "sourcehut",
                        position: (1042, 20),
                       },
                       Raw {
                        content: "settings",
                        position: (1042, 30),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Expression {
                           expression: String {
                            parts: [
                             Raw {
                              content: "git.sr.ht::dispatch",
                              position: (1043, 14),
                             },
                            ],
                           },
                          },
                          Expression {
                           expression: String {
                            parts: [
                             Raw {
                              content: "/usr/bin/gitsrht-keys",
                              position: (1043, 36),
                             },
                            ],
                           },
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkDefault",
                          position: (1044, 15),
                         },
                         arguments: [
                          String {
                           parts: [
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (1044, 28),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "git",
                                 position: (1044, 32),
                                },
                                Raw {
                                 content: "user",
                                 position: (1044, 36),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: ":",
                             position: (1044, 41),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (1044, 44),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "git",
                                 position: (1044, 48),
                                },
                                Raw {
                                 content: "group",
                                 position: (1044, 52),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                           ],
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (1042, 41),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "systemd",
                        position: (1046, 11),
                       },
                       Raw {
                        content: "services",
                        position: (1046, 19),
                       },
                       Raw {
                        content: "sshd",
                        position: (1046, 28),
                       },
                      ],
                     },
                     Variable {
                      identifier: "baseService",
                      position: (1046, 35),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (1038, 9),
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkIf",
                    position: (1048, 10),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1048, 15),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "nginx",
                        position: (1048, 19),
                       },
                       Raw {
                        content: "enable",
                        position: (1048, 25),
                       },
                      ],
                     },
                     default: None,
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "services",
                          position: (1049, 11),
                         },
                         Raw {
                          content: "nginx",
                          position: (1049, 20),
                         },
                         Raw {
                          content: "virtualHosts",
                          position: (1049, 26),
                         },
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "git.",
                             position: (1049, 40),
                            },
                            Expression {
                             expression: Variable {
                              identifier: "domain",
                              position: (1049, 46),
                             },
                            },
                           ],
                          },
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "locations",
                             position: (1050, 13),
                            },
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "/authorize",
                                position: (1050, 24),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "proxyPass",
                                position: (1051, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "http://",
                                position: (1051, 28),
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (1051, 37),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "listenAddress",
                                    position: (1051, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: ":",
                                position: (1051, 55),
                               },
                               Expression {
                                expression: FunctionApplication {
                                 function: Variable {
                                  identifier: "toString",
                                  position: (1051, 58),
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "cfg",
                                    position: (1051, 67),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "git",
                                      position: (1051, 71),
                                     },
                                     Raw {
                                      content: "port",
                                      position: (1051, 75),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "extraConfig",
                                position: (1052, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "proxy_pass_request_body off;\nproxy_set_header Content-Length \"\";\nproxy_set_header X-Original-URI $request_uri;\n",
                                position: (1053, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (1050, 38),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "locations",
                             position: (1058, 13),
                            },
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "~ ^/([^/]+)/([^/]+)/(HEAD|info/refs|objects/info/.*|git-upload-pack).*$",
                                position: (1058, 24),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "root",
                                position: (1059, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "/var/lib/sourcehut/gitsrht/repos",
                                position: (1059, 23),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "fastcgiParams",
                                position: (1060, 15),
                               },
                              ],
                             },
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "GIT_HTTP_EXPORT_ALL",
                                   position: (1061, 17),
                                  },
                                 ],
                                },
                                String {
                                 parts: [],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "GIT_PROJECT_ROOT",
                                   position: (1062, 17),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "$document_root",
                                   position: (1062, 37),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "PATH_INFO",
                                   position: (1063, 17),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "$uri",
                                   position: (1063, 30),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "SCRIPT_FILENAME",
                                   position: (1064, 17),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Expression {
                                   expression: PropertyAccess {
                                    expression: Variable {
                                     identifier: "cfg",
                                     position: (1064, 38),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "git",
                                       position: (1064, 42),
                                      },
                                      Raw {
                                       content: "package",
                                       position: (1064, 46),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                  Raw {
                                   content: "/bin/git-http-backend",
                                   position: (1064, 54),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (1060, 31),
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "extraConfig",
                                position: (1066, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "auth_request /authorize;\nfastcgi_read_timeout 500s;\nfastcgi_pass unix:/run/gitsrht-fcgiwrap.sock;\ngzip off;\n",
                                position: (1067, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (1058, 99),
                          },
                         ),
                        ],
                        recursive: false,
                        position: (1049, 57),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "systemd",
                          position: (1074, 11),
                         },
                         Raw {
                          content: "sockets",
                          position: (1074, 19),
                         },
                         Raw {
                          content: "gitsrht-fcgiwrap",
                          position: (1074, 27),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "before",
                             position: (1075, 13),
                            },
                           ],
                          },
                          List {
                           elements: [
                            String {
                             parts: [
                              Raw {
                               content: "nginx.service",
                               position: (1075, 25),
                              },
                             ],
                            },
                           ],
                           position: (1075, 22),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "wantedBy",
                             position: (1076, 13),
                            },
                           ],
                          },
                          List {
                           elements: [
                            String {
                             parts: [
                              Raw {
                               content: "sockets.target",
                               position: (1076, 27),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "gitsrht.service",
                               position: (1076, 44),
                              },
                             ],
                            },
                           ],
                           position: (1076, 24),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "socketConfig",
                             position: (1078, 13),
                            },
                            Raw {
                             content: "ListenStream",
                             position: (1078, 26),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "/run/gitsrht-fcgiwrap.sock",
                             position: (1078, 42),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "socketConfig",
                             position: (1079, 13),
                            },
                            Raw {
                             content: "SocketUser",
                             position: (1079, 26),
                            },
                           ],
                          },
                          PropertyAccess {
                           expression: Variable {
                            identifier: "nginx",
                            position: (1079, 39),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "user",
                              position: (1079, 45),
                             },
                            ],
                           },
                           default: None,
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "socketConfig",
                             position: (1080, 13),
                            },
                            Raw {
                             content: "SocketMode",
                             position: (1080, 26),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "600",
                             position: (1080, 40),
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (1074, 46),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (1048, 32),
                    },
                   ],
                  },
                 ],
                 position: (1037, 29),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "extraServices",
                 position: (1084, 7),
                },
                Raw {
                 content: "gitsrht-fcgiwrap",
                 position: (1084, 21),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkIf",
                position: (1084, 40),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1084, 45),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "nginx",
                    position: (1084, 49),
                   },
                   Raw {
                    content: "enable",
                    position: (1084, 55),
                   },
                  ],
                 },
                 default: None,
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "serviceConfig",
                      position: (1085, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "ExecStart",
                         position: (1087, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (1087, 26),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "fcgiwrap",
                             position: (1087, 31),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/sbin/fcgiwrap -c ",
                         position: (1087, 40),
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "toString",
                           position: (1087, 60),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1087, 69),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "git",
                               position: (1087, 73),
                              },
                              Raw {
                               content: "fcgiwrap",
                               position: (1087, 77),
                              },
                              Raw {
                               content: "preforkProcess",
                               position: (1087, 86),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "ExecStartPre",
                         position: (1089, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkForce",
                        position: (1089, 26),
                       },
                       arguments: [
                        List {
                         elements: [],
                         position: (1089, 34),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "User",
                         position: (1090, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "null",
                       position: (1090, 18),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "DynamicUser",
                         position: (1091, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "true",
                       position: (1091, 25),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "BindReadOnlyPaths",
                         position: (1092, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1092, 36),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "settings",
                               position: (1092, 40),
                              },
                              Expression {
                               expression: String {
                                parts: [
                                 Raw {
                                  content: "git.sr.ht",
                                  position: (1092, 50),
                                 },
                                ],
                               },
                              },
                              Raw {
                               content: "repos",
                               position: (1092, 61),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: ":/var/lib/sourcehut/gitsrht/repos",
                           position: (1092, 67),
                          },
                         ],
                        },
                       ],
                       position: (1092, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "IPAddressDeny",
                         position: (1093, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "any",
                         position: (1093, 28),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "InaccessiblePaths",
                         position: (1094, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "-+/run/postgresql",
                           position: (1094, 34),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "-+/run/redis-sourcehut",
                           position: (1094, 54),
                          },
                         ],
                        },
                       ],
                       position: (1094, 31),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "PrivateNetwork",
                         position: (1095, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "true",
                       position: (1095, 28),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "RestrictAddressFamilies",
                         position: (1096, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkForce",
                        position: (1096, 37),
                       },
                       arguments: [
                        List {
                         elements: [
                          String {
                           parts: [
                            Raw {
                             content: "none",
                             position: (1096, 48),
                            },
                           ],
                          },
                         ],
                         position: (1096, 45),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "SystemCallFilter",
                         position: (1097, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "mkForce",
                        position: (1097, 30),
                       },
                       arguments: [
                        List {
                         elements: [
                          String {
                           parts: [
                            Raw {
                             content: "@system-service",
                             position: (1098, 14),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "~@aio",
                             position: (1099, 14),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "~@keyring",
                             position: (1099, 22),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "~@memlock",
                             position: (1099, 34),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "~@privileged",
                             position: (1099, 46),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "~@resources",
                             position: (1099, 61),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "~@setuid",
                             position: (1099, 75),
                            },
                           ],
                          },
                         ],
                         position: (1097, 38),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (1085, 25),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1084, 62),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (1017, 10),
           },
           position: (1012, 34),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "import",
          position: (1106, 6),
         },
         arguments: [
          Path {
           parts: [
            Raw {
             content: "./service.nix",
             position: (1106, 13),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "hg",
             position: (1106, 28),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "baseService",
                position: (1107, 7),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "path",
                   position: (1108, 9),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (1108, 18),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "hg",
                      position: (1108, 22),
                     },
                     Raw {
                      content: "package",
                      position: (1108, 25),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (1108, 16),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1109, 9),
                  },
                  Raw {
                   content: "BindPaths",
                   position: (1109, 23),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (1109, 40),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "settings",
                         position: (1109, 44),
                        },
                        Expression {
                         expression: String {
                          parts: [
                           Raw {
                            content: "hg.sr.ht",
                            position: (1109, 54),
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "repos",
                         position: (1109, 64),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: ":/var/lib/sourcehut/hgsrht/repos",
                     position: (1109, 70),
                    },
                   ],
                  },
                 ],
                 position: (1109, 35),
                },
               ),
              ],
              recursive: false,
              position: (1107, 21),
             },
            ),
           ],
           target: Map {
            bindings: [
             Inherit(
              None,
              [
               Raw {
                content: "configIniOfService",
                position: (1112, 15),
               },
              ],
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "mainService",
                 position: (1113, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkMerge",
                position: (1113, 21),
               },
               arguments: [
                List {
                 elements: [
                  Variable {
                   identifier: "baseService",
                   position: (1113, 31),
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "serviceConfig",
                        position: (1114, 9),
                       },
                       Raw {
                        content: "StateDirectory",
                        position: (1114, 23),
                       },
                      ],
                     },
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "sourcehut/hgsrht",
                          position: (1114, 43),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "sourcehut/hgsrht/repos",
                          position: (1114, 62),
                         },
                        ],
                       },
                      ],
                      position: (1114, 40),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (1113, 43),
                  },
                 ],
                 position: (1113, 29),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "port",
                 position: (1116, 7),
                },
               ],
              },
              Int {
               value: 5010,
               position: (1116, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "webhooks",
                 position: (1117, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (1117, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "extraTimers",
                 position: (1118, 7),
                },
                Raw {
                 content: "hgsrht-periodic",
                 position: (1118, 19),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "service",
                    position: (1119, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "baseService",
                  position: (1119, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "timerConfig",
                    position: (1120, 9),
                   },
                   Raw {
                    content: "OnCalendar",
                    position: (1120, 21),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "*:0/20",
                      position: (1120, 36),
                     },
                    ],
                   },
                  ],
                  position: (1120, 34),
                 },
                ),
               ],
               recursive: false,
               position: (1118, 37),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "extraTimers",
                 position: (1122, 7),
                },
                Raw {
                 content: "hgsrht-clonebundles",
                 position: (1122, 19),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkIf",
                position: (1122, 41),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1122, 46),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "hg",
                    position: (1122, 50),
                   },
                   Raw {
                    content: "cloneBundles",
                    position: (1122, 53),
                   },
                  ],
                 },
                 default: None,
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "service",
                      position: (1123, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "baseService",
                    position: (1123, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "timerConfig",
                      position: (1124, 9),
                     },
                     Raw {
                      content: "OnCalendar",
                      position: (1124, 21),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "daily",
                        position: (1124, 36),
                       },
                      ],
                     },
                    ],
                    position: (1124, 34),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "timerConfig",
                      position: (1125, 9),
                     },
                     Raw {
                      content: "AccuracySec",
                      position: (1125, 21),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "1h",
                      position: (1125, 36),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1122, 66),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "extraConfig",
                 position: (1127, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkMerge",
                position: (1127, 21),
               },
               arguments: [
                List {
                 elements: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "users",
                        position: (1129, 11),
                       },
                       Raw {
                        content: "users",
                        position: (1129, 17),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1129, 25),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "hg",
                            position: (1129, 29),
                           },
                           Raw {
                            content: "user",
                            position: (1129, 32),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "shell",
                        position: (1129, 38),
                       },
                      ],
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (1129, 46),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "bash",
                         position: (1129, 51),
                        },
                       ],
                      },
                      default: None,
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "services",
                        position: (1130, 11),
                       },
                       Raw {
                        content: "sourcehut",
                        position: (1130, 20),
                       },
                       Raw {
                        content: "settings",
                        position: (1130, 30),
                       },
                      ],
                     },
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Expression {
                           expression: String {
                            parts: [
                             Raw {
                              content: "git.sr.ht::dispatch",
                              position: (1133, 14),
                             },
                            ],
                           },
                          },
                          Expression {
                           expression: String {
                            parts: [
                             Raw {
                              content: "/usr/bin/hgsrht-keys",
                              position: (1133, 36),
                             },
                            ],
                           },
                          },
                         ],
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "mkDefault",
                          position: (1134, 15),
                         },
                         arguments: [
                          String {
                           parts: [
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (1134, 28),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "hg",
                                 position: (1134, 32),
                                },
                                Raw {
                                 content: "user",
                                 position: (1134, 35),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: ":",
                             position: (1134, 40),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "cfg",
                               position: (1134, 43),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "hg",
                                 position: (1134, 47),
                                },
                                Raw {
                                 content: "group",
                                 position: (1134, 50),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                           ],
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (1130, 41),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "systemd",
                        position: (1136, 11),
                       },
                       Raw {
                        content: "services",
                        position: (1136, 19),
                       },
                       Raw {
                        content: "sshd",
                        position: (1136, 28),
                       },
                      ],
                     },
                     Variable {
                      identifier: "baseService",
                      position: (1136, 35),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (1128, 9),
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkIf",
                    position: (1138, 10),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1138, 15),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "nginx",
                        position: (1138, 19),
                       },
                       Raw {
                        content: "enable",
                        position: (1138, 25),
                       },
                      ],
                     },
                     default: None,
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "users",
                          position: (1140, 11),
                         },
                         Raw {
                          content: "users",
                          position: (1140, 17),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "nginx",
                            position: (1140, 25),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "user",
                              position: (1140, 31),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "extraGroups",
                          position: (1140, 37),
                         },
                        ],
                       },
                       List {
                        elements: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (1140, 53),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "hg",
                             position: (1140, 57),
                            },
                            Raw {
                             content: "group",
                             position: (1140, 60),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                        position: (1140, 51),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "services",
                          position: (1141, 11),
                         },
                         Raw {
                          content: "nginx",
                          position: (1141, 20),
                         },
                         Raw {
                          content: "virtualHosts",
                          position: (1141, 26),
                         },
                         Expression {
                          expression: String {
                           parts: [
                            Raw {
                             content: "hg.",
                             position: (1141, 40),
                            },
                            Expression {
                             expression: Variable {
                              identifier: "domain",
                              position: (1141, 45),
                             },
                            },
                           ],
                          },
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "locations",
                             position: (1142, 13),
                            },
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "/authorize",
                                position: (1142, 24),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "proxyPass",
                                position: (1143, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "http://",
                                position: (1143, 28),
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (1143, 37),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "listenAddress",
                                    position: (1143, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: ":",
                                position: (1143, 55),
                               },
                               Expression {
                                expression: FunctionApplication {
                                 function: Variable {
                                  identifier: "toString",
                                  position: (1143, 58),
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "cfg",
                                    position: (1143, 67),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "hg",
                                      position: (1143, 71),
                                     },
                                     Raw {
                                      content: "port",
                                      position: (1143, 74),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "extraConfig",
                                position: (1144, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "proxy_pass_request_body off;\nproxy_set_header Content-Length \"\";\nproxy_set_header X-Original-URI $request_uri;\n",
                                position: (1145, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (1142, 38),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "locations",
                             position: (1154, 13),
                            },
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "~ ^/[~^][a-z0-9_]+/[a-zA-Z0-9_.-]+/\\.hg/bundles/.*$",
                                position: (1154, 24),
                               },
                              ],
                             },
                            },
                           ],
                          },
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "root",
                                position: (1155, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "/var/lib/nginx/hgsrht/repos",
                                position: (1155, 23),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "extraConfig",
                                position: (1156, 15),
                               },
                              ],
                             },
                             String {
                              parts: [
                               Raw {
                                content: "auth_request /authorize;\ngzip off;\n",
                                position: (1157, 1),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (1154, 80),
                          },
                         ),
                        ],
                        recursive: false,
                        position: (1141, 56),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "systemd",
                          position: (1162, 11),
                         },
                         Raw {
                          content: "services",
                          position: (1162, 19),
                         },
                         Raw {
                          content: "nginx",
                          position: (1162, 28),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "serviceConfig",
                             position: (1163, 13),
                            },
                            Raw {
                             content: "BindReadOnlyPaths",
                             position: (1163, 27),
                            },
                           ],
                          },
                          List {
                           elements: [
                            String {
                             parts: [
                              Expression {
                               expression: PropertyAccess {
                                expression: Variable {
                                 identifier: "cfg",
                                 position: (1163, 52),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "settings",
                                   position: (1163, 56),
                                  },
                                  Expression {
                                   expression: String {
                                    parts: [
                                     Raw {
                                      content: "hg.sr.ht",
                                      position: (1163, 66),
                                     },
                                    ],
                                   },
                                  },
                                  Raw {
                                   content: "repos",
                                   position: (1163, 76),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Raw {
                               content: ":/var/lib/nginx/hgsrht/repos",
                               position: (1163, 82),
                              },
                             ],
                            },
                           ],
                           position: (1163, 47),
                          },
                         ),
                        ],
                        recursive: false,
                        position: (1162, 36),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (1138, 32),
                    },
                   ],
                  },
                 ],
                 position: (1127, 29),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (1111, 10),
           },
           position: (1106, 33),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "import",
          position: (1169, 6),
         },
         arguments: [
          Path {
           parts: [
            Raw {
             content: "./service.nix",
             position: (1169, 13),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "hub",
             position: (1169, 28),
            },
           ],
          },
          Map {
           bindings: [
            Inherit(
             None,
             [
              Raw {
               content: "configIniOfService",
               position: (1170, 15),
              },
             ],
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (1171, 7),
               },
              ],
             },
             Int {
              value: 5014,
              position: (1171, 14),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "extraConfig",
                position: (1172, 7),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "services",
                   position: (1173, 9),
                  },
                  Raw {
                   content: "nginx",
                   position: (1173, 18),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (1173, 26),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (1173, 31),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nginx",
                      position: (1173, 35),
                     },
                     Raw {
                      content: "enable",
                      position: (1173, 41),
                     },
                    ],
                   },
                   default: None,
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "virtualHosts",
                        position: (1174, 11),
                       },
                       Expression {
                        expression: String {
                         parts: [
                          Raw {
                           content: "hub.",
                           position: (1174, 25),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "domain",
                            position: (1174, 31),
                           },
                          },
                         ],
                        },
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "mkMerge",
                       position: (1174, 42),
                      },
                      arguments: [
                       List {
                        elements: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "serverAliases",
                               position: (1175, 13),
                              },
                             ],
                            },
                            List {
                             elements: [
                              Variable {
                               identifier: "domain",
                               position: (1175, 31),
                              },
                             ],
                             position: (1175, 29),
                            },
                           ),
                          ],
                          recursive: false,
                          position: (1174, 52),
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (1176, 13),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "nginx",
                             position: (1176, 17),
                            },
                            Raw {
                             content: "virtualHost",
                             position: (1176, 23),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                        position: (1174, 50),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (1173, 48),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (1172, 21),
             },
            ),
           ],
           recursive: false,
           position: (1169, 33),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "import",
          position: (1181, 6),
         },
         arguments: [
          Path {
           parts: [
            Raw {
             content: "./service.nix",
             position: (1181, 13),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "lists",
             position: (1181, 28),
            },
           ],
          },
          LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "srvsrht",
                position: (1182, 7),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "listssrht",
                position: (1182, 18),
               },
              ],
             },
            ),
           ],
           target: Map {
            bindings: [
             Inherit(
              None,
              [
               Raw {
                content: "configIniOfService",
                position: (1184, 15),
               },
              ],
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "port",
                 position: (1185, 7),
                },
               ],
              },
              Int {
               value: 5006,
               position: (1185, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "webhooks",
                 position: (1186, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (1186, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "extraServices",
                 position: (1188, 7),
                },
                Raw {
                 content: "listssrht-lmtp",
                 position: (1188, 21),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "wants",
                    position: (1189, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "postfix.service",
                      position: (1189, 20),
                     },
                    ],
                   },
                  ],
                  position: (1189, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "unitConfig",
                    position: (1190, 9),
                   },
                   Raw {
                    content: "JoinsNamespaceOf",
                    position: (1190, 20),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "optional",
                   position: (1190, 39),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1190, 48),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "postfix",
                       position: (1190, 52),
                      },
                      Raw {
                       content: "enable",
                       position: (1190, 60),
                      },
                     ],
                    },
                    default: None,
                   },
                   String {
                    parts: [
                     Raw {
                      content: "postfix.service",
                      position: (1190, 68),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "serviceConfig",
                    position: (1191, 9),
                   },
                   Raw {
                    content: "ExecStart",
                    position: (1191, 23),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1191, 38),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "python",
                        position: (1191, 42),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "/bin/listssrht-lmtp",
                    position: (1191, 49),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "serviceConfig",
                    position: (1193, 9),
                   },
                   Raw {
                    content: "PrivateUsers",
                    position: (1193, 23),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkForce",
                   position: (1193, 38),
                  },
                  arguments: [
                   Variable {
                    identifier: "false",
                    position: (1193, 46),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (1188, 38),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "extraServices",
                 position: (1196, 7),
                },
                Raw {
                 content: "listssrht-process",
                 position: (1196, 21),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "serviceConfig",
                    position: (1197, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "preStart",
                       position: (1198, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "cp ",
                       position: (1199, 1),
                      },
                      Expression {
                       expression: FunctionApplication {
                        function: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (1199, 18),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "writeText",
                            position: (1199, 23),
                           },
                          ],
                         },
                         default: None,
                        },
                        arguments: [
                         String {
                          parts: [
                           Expression {
                            expression: Variable {
                             identifier: "srvsrht",
                             position: (1199, 36),
                            },
                           },
                           Raw {
                            content: "-webhooks-celeryconfig.py",
                            position: (1199, 44),
                           },
                          ],
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (1199, 71),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "lists",
                             position: (1199, 75),
                            },
                            Raw {
                             content: "process",
                             position: (1199, 81),
                            },
                            Raw {
                             content: "celeryConfig",
                             position: (1199, 89),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      },
                      Raw {
                       content: " \\\n   /run/sourcehut/",
                       position: (1199, 102),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "srvsrht",
                        position: (1200, 33),
                       },
                      },
                      Raw {
                       content: "-webhooks/celeryconfig.py\n",
                       position: (1200, 41),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ExecStart",
                       position: (1202, 11),
                      },
                     ],
                    },
                    BinaryOperation {
                     operator: Addition,
                     operands: [
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (1202, 26),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "python",
                             position: (1202, 30),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/celery --app listssrht.process worker --hostname listssrht-process@%%h ",
                         position: (1202, 37),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "concatStringsSep",
                        position: (1202, 117),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: " ",
                           position: (1202, 135),
                          },
                         ],
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1202, 138),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "lists",
                            position: (1202, 142),
                           },
                           Raw {
                            content: "process",
                            position: (1202, 148),
                           },
                           Raw {
                            content: "extraArgs",
                            position: (1202, 156),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     ],
                     position: (1202, 115),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ProcSubset",
                       position: (1204, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "mkForce",
                      position: (1204, 24),
                     },
                     arguments: [
                      String {
                       parts: [
                        Raw {
                         content: "all",
                         position: (1204, 33),
                        },
                       ],
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (1197, 25),
                 },
                ),
               ],
               recursive: false,
               position: (1196, 41),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "extraConfig",
                 position: (1207, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkIf",
                position: (1207, 21),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (1207, 26),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "postfix",
                    position: (1207, 30),
                   },
                   Raw {
                    content: "enable",
                    position: (1207, 38),
                   },
                  ],
                 },
                 default: None,
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "users",
                      position: (1208, 9),
                     },
                     Raw {
                      content: "groups",
                      position: (1208, 15),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "postfix",
                        position: (1208, 24),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "group",
                          position: (1208, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "members",
                      position: (1208, 39),
                     },
                    ],
                   },
                   List {
                    elements: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (1208, 51),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "lists",
                         position: (1208, 55),
                        },
                        Raw {
                         content: "user",
                         position: (1208, 61),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (1208, 49),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "services",
                      position: (1209, 9),
                     },
                     Raw {
                      content: "sourcehut",
                      position: (1209, 18),
                     },
                     Raw {
                      content: "settings",
                      position: (1209, 28),
                     },
                     Expression {
                      expression: String {
                       parts: [
                        Raw {
                         content: "lists.sr.ht::mail",
                         position: (1209, 38),
                        },
                       ],
                      },
                     },
                     Raw {
                      content: "sock-group",
                      position: (1209, 57),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "postfix",
                     position: (1209, 70),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (1209, 78),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "services",
                      position: (1210, 9),
                     },
                     Raw {
                      content: "postfix",
                      position: (1210, 18),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "destination",
                         position: (1211, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "lists.",
                           position: (1211, 28),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "domain",
                            position: (1211, 36),
                           },
                          },
                         ],
                        },
                       ],
                       position: (1211, 25),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "localRecipients",
                         position: (1218, 11),
                        },
                       ],
                      },
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "@lists.",
                           position: (1218, 32),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "domain",
                            position: (1218, 41),
                           },
                          },
                         ],
                        },
                       ],
                       position: (1218, 29),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "transport",
                         position: (1219, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "lists.",
                         position: (1220, 1),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "domain",
                          position: (1220, 21),
                         },
                        },
                        Raw {
                         content: " lmtp:unix:",
                         position: (1220, 28),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (1220, 41),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "settings",
                             position: (1220, 45),
                            },
                            Expression {
                             expression: String {
                              parts: [
                               Raw {
                                content: "lists.sr.ht::worker",
                                position: (1220, 55),
                               },
                              ],
                             },
                            },
                            Raw {
                             content: "sock",
                             position: (1220, 76),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "\n",
                         position: (1220, 81),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (1210, 28),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (1207, 45),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (1183, 10),
           },
           position: (1181, 36),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "import",
          position: (1226, 6),
         },
         arguments: [
          Path {
           parts: [
            Raw {
             content: "./service.nix",
             position: (1226, 13),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "man",
             position: (1226, 28),
            },
           ],
          },
          Map {
           bindings: [
            Inherit(
             None,
             [
              Raw {
               content: "configIniOfService",
               position: (1227, 15),
              },
             ],
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (1228, 7),
               },
              ],
             },
             Int {
              value: 5004,
              position: (1228, 14),
             },
            ),
           ],
           recursive: false,
           position: (1226, 33),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "import",
          position: (1231, 6),
         },
         arguments: [
          Path {
           parts: [
            Raw {
             content: "./service.nix",
             position: (1231, 13),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "meta",
             position: (1231, 28),
            },
           ],
          },
          Map {
           bindings: [
            Inherit(
             None,
             [
              Raw {
               content: "configIniOfService",
               position: (1232, 15),
              },
             ],
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (1233, 7),
               },
              ],
             },
             Int {
              value: 5000,
              position: (1233, 14),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "webhooks",
                position: (1234, 7),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (1234, 18),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "extraServices",
                position: (1235, 7),
               },
               Raw {
                content: "metasrht-api",
                position: (1235, 21),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1236, 9),
                  },
                  Raw {
                   content: "Restart",
                   position: (1236, 23),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "always",
                   position: (1236, 34),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1237, 9),
                  },
                  Raw {
                   content: "RestartSec",
                   position: (1237, 23),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "2s",
                   position: (1237, 37),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "preStart",
                   position: (1238, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  String {
                   parts: [
                    Raw {
                     content: "set -x\n",
                     position: (1238, 21),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "concatStringsSep",
                    position: (1238, 33),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "\n\n",
                       position: (1238, 51),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "attrValues",
                      position: (1238, 58),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "mapAttrs",
                        position: (1238, 70),
                       },
                       arguments: [
                        Function {
                         argument: Some(
                          "k",
                         ),
                         arguments: FunctionArguments {
                          arguments: [],
                          ellipsis: false,
                         },
                         definition: Function {
                          argument: Some(
                           "s",
                          ),
                          arguments: FunctionArguments {
                           arguments: [],
                           ellipsis: false,
                          },
                          definition: LetIn {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "srvMatch",
                                position: (1239, 15),
                               },
                              ],
                             },
                             FunctionApplication {
                              function: PropertyAccess {
                               expression: Variable {
                                identifier: "builtins",
                                position: (1239, 26),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "match",
                                  position: (1239, 35),
                                 },
                                ],
                               },
                               default: None,
                              },
                              arguments: [
                               String {
                                parts: [
                                 Raw {
                                  content: "^([a-z]*)\\.sr\\.ht$",
                                  position: (1239, 42),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "k",
                                position: (1239, 64),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "srv",
                                position: (1240, 15),
                               },
                              ],
                             },
                             FunctionApplication {
                              function: Variable {
                               identifier: "head",
                               position: (1240, 21),
                              },
                              arguments: [
                               Variable {
                                identifier: "srvMatch",
                                position: (1240, 26),
                               },
                              ],
                             },
                            ),
                           ],
                           target: FunctionApplication {
                            function: Variable {
                             identifier: "optionalString",
                             position: (1243, 11),
                            },
                            arguments: [
                             BinaryOperation {
                              operator: LogicalAnd,
                              operands: [
                               BinaryOperation {
                                operator: LogicalAnd,
                                operands: [
                                 BinaryOperation {
                                  operator: NotEqualTo,
                                  operands: [
                                   Variable {
                                    identifier: "srvMatch",
                                    position: (1243, 27),
                                   },
                                   Variable {
                                    identifier: "null",
                                    position: (1243, 39),
                                   },
                                  ],
                                  position: (1243, 36),
                                 },
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "cfg",
                                   position: (1243, 47),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Expression {
                                     expression: Variable {
                                      identifier: "srv",
                                      position: (1243, 53),
                                     },
                                    },
                                    Raw {
                                     content: "enable",
                                     position: (1243, 58),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                                position: (1243, 44),
                               },
                               BinaryOperation {
                                operator: NotEqualTo,
                                operands: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "s",
                                   position: (1243, 70),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "oauth-client-id",
                                     position: (1243, 72),
                                    },
                                   ],
                                  },
                                  default: Some(
                                   Variable {
                                    identifier: "null",
                                    position: (1243, 91),
                                   },
                                  ),
                                 },
                                 Variable {
                                  identifier: "null",
                                  position: (1243, 100),
                                 },
                                ],
                                position: (1243, 97),
                               },
                              ],
                              position: (1243, 65),
                             },
                             String {
                              parts: [
                               Raw {
                                content: "# Configure ",
                                position: (1244, 1),
                               },
                               Expression {
                                expression: Variable {
                                 identifier: "srv",
                                 position: (1244, 27),
                                },
                               },
                               Raw {
                                content: "'s OAuth client as \"preauthorized\"\n",
                                position: (1244, 31),
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "postgresql",
                                  position: (1245, 15),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "package",
                                    position: (1245, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "/bin/psql ",
                                position: (1245, 34),
                               },
                               Raw {
                                content: "'",
                                position: (1245, 44),
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (1245, 47),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "settings",
                                    position: (1245, 51),
                                   },
                                   Expression {
                                    expression: String {
                                     parts: [
                                      Raw {
                                       content: "meta.sr.ht",
                                       position: (1245, 61),
                                      },
                                     ],
                                    },
                                   },
                                   Raw {
                                    content: "connection-string",
                                    position: (1245, 73),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "' \\\n  -c \"UPDATE oauthclient SET preauthorized = true WHERE client_id = ",
                                position: (1245, 91),
                               },
                               Raw {
                                content: "'",
                                position: (1246, 81),
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "s",
                                  position: (1246, 84),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "oauth-client-id",
                                    position: (1246, 86),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                               Raw {
                                content: "'\"\n",
                                position: (1246, 102),
                               },
                              ],
                             },
                            ],
                           },
                           position: (1239, 11),
                          },
                          position: (1238, 83),
                         },
                         position: (1238, 80),
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1248, 13),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "settings",
                            position: (1248, 17),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     ],
                    },
                   ],
                  },
                 ],
                 position: (1238, 31),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1249, 9),
                  },
                  Raw {
                   content: "ExecStart",
                   position: (1249, 23),
                  },
                 ],
                },
                String {
                 parts: [
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (1249, 38),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "sourcehut",
                       position: (1249, 43),
                      },
                      Raw {
                       content: "metasrht",
                       position: (1249, 53),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/bin/metasrht-api -b ",
                   position: (1249, 62),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1249, 85),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "listenAddress",
                       position: (1249, 89),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: ":",
                   position: (1249, 103),
                  },
                  Expression {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "toString",
                     position: (1249, 106),
                    },
                    arguments: [
                     BinaryOperation {
                      operator: Addition,
                      operands: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1249, 116),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "meta",
                           position: (1249, 120),
                          },
                          Raw {
                           content: "port",
                           position: (1249, 125),
                          },
                         ],
                        },
                        default: None,
                       },
                       Int {
                        value: 100,
                        position: (1249, 132),
                       },
                      ],
                      position: (1249, 130),
                     },
                    ],
                   },
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (1235, 36),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "extraTimers",
                position: (1251, 7),
               },
               Raw {
                content: "metasrht-daily",
                position: (1251, 19),
               },
               Raw {
                content: "timerConfig",
                position: (1251, 34),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "OnCalendar",
                   position: (1252, 9),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "daily",
                     position: (1252, 24),
                    },
                   ],
                  },
                 ],
                 position: (1252, 22),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "AccuracySec",
                   position: (1253, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "1h",
                   position: (1253, 24),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (1251, 48),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "extraConfig",
                position: (1255, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkMerge",
               position: (1255, 21),
              },
              arguments: [
               List {
                elements: [
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "assertions",
                       position: (1257, 11),
                      },
                     ],
                    },
                    List {
                     elements: [
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "assertion",
                            position: (1258, 15),
                           },
                          ],
                         },
                         LetIn {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "s",
                               position: (1258, 31),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (1258, 35),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "settings",
                                position: (1258, 39),
                               },
                               Expression {
                                expression: String {
                                 parts: [
                                  Raw {
                                   content: "meta.sr.ht::billing",
                                   position: (1258, 49),
                                  },
                                 ],
                                },
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                          ],
                          target: BinaryOperation {
                           operator: Implication,
                           operands: [
                            BinaryOperation {
                             operator: EqualTo,
                             operands: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "s",
                                position: (1259, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "enabled",
                                  position: (1259, 29),
                                 },
                                ],
                               },
                               default: None,
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "yes",
                                 position: (1259, 41),
                                },
                               ],
                              },
                             ],
                             position: (1259, 37),
                            },
                            BinaryOperation {
                             operator: LogicalAnd,
                             operands: [
                              BinaryOperation {
                               operator: NotEqualTo,
                               operands: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "s",
                                  position: (1259, 50),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "stripe-public-key",
                                    position: (1259, 52),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                Variable {
                                 identifier: "null",
                                 position: (1259, 73),
                                },
                               ],
                               position: (1259, 70),
                              },
                              BinaryOperation {
                               operator: NotEqualTo,
                               operands: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "s",
                                  position: (1259, 81),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "stripe-secret-key",
                                    position: (1259, 83),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                Variable {
                                 identifier: "null",
                                 position: (1259, 104),
                                },
                               ],
                               position: (1259, 101),
                              },
                             ],
                             position: (1259, 78),
                            },
                           ],
                           position: (1259, 46),
                          },
                          position: (1258, 27),
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "message",
                            position: (1260, 15),
                           },
                          ],
                         },
                         String {
                          parts: [
                           Raw {
                            content: "If meta.sr.ht::billing is enabled, the keys must be defined.",
                            position: (1260, 26),
                           },
                          ],
                         },
                        ),
                       ],
                       recursive: false,
                       position: (1258, 13),
                      },
                     ],
                     position: (1257, 24),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "environment",
                       position: (1263, 11),
                      },
                      Raw {
                       content: "systemPackages",
                       position: (1263, 23),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "optional",
                      position: (1263, 40),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1263, 49),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "meta",
                          position: (1263, 53),
                         },
                         Raw {
                          content: "enable",
                          position: (1263, 58),
                         },
                        ],
                       },
                       default: None,
                      },
                      FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (1264, 14),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "writeShellScriptBin",
                           position: (1264, 19),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: "metasrht-manageuser",
                           position: (1264, 40),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "set -eux\nif test \"$(",
                           position: (1265, 1),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (1266, 28),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "coreutils",
                               position: (1266, 33),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/bin/id -n -u)\" != ",
                           position: (1266, 43),
                          },
                          Raw {
                           content: "'",
                           position: (1266, 62),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1266, 65),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "meta",
                               position: (1266, 69),
                              },
                              Raw {
                               content: "user",
                               position: (1266, 74),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "'\nthen exec sudo -u ",
                           position: (1266, 79),
                          },
                          Raw {
                           content: "'",
                           position: (1267, 33),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1267, 36),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "meta",
                               position: (1267, 40),
                              },
                              Raw {
                               content: "user",
                               position: (1267, 45),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "' \"$0\" \"$@\"\nelse\n  # In order to load config.ini\n  if cd /run/sourcehut/metasrht\n  then exec ",
                           position: (1267, 50),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1271, 29),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "python",
                               position: (1271, 33),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/bin/metasrht-manageuser \"$@\"\n  else cat <<EOF\n    Please run: sudo systemctl start metasrht\nEOF\n    exit 1\n  fi\nfi\n",
                           position: (1271, 40),
                          },
                         ],
                        },
                       ],
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (1256, 9),
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkIf",
                   position: (1280, 10),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1280, 15),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "nginx",
                       position: (1280, 19),
                      },
                      Raw {
                       content: "enable",
                       position: (1280, 25),
                      },
                     ],
                    },
                    default: None,
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "services",
                         position: (1281, 11),
                        },
                        Raw {
                         content: "nginx",
                         position: (1281, 20),
                        },
                        Raw {
                         content: "virtualHosts",
                         position: (1281, 26),
                        },
                        Expression {
                         expression: String {
                          parts: [
                           Raw {
                            content: "meta.",
                            position: (1281, 40),
                           },
                           Expression {
                            expression: Variable {
                             identifier: "domain",
                             position: (1281, 47),
                            },
                           },
                          ],
                         },
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "locations",
                            position: (1282, 13),
                           },
                           Expression {
                            expression: String {
                             parts: [
                              Raw {
                               content: "/query",
                               position: (1282, 24),
                              },
                             ],
                            },
                           },
                          ],
                         },
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "proxyPass",
                               position: (1283, 15),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (1283, 27),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "settings",
                                position: (1283, 31),
                               },
                               Expression {
                                expression: String {
                                 parts: [
                                  Raw {
                                   content: "meta.sr.ht",
                                   position: (1283, 41),
                                  },
                                 ],
                                },
                               },
                               Raw {
                                content: "api-origin",
                                position: (1283, 53),
                               },
                              ],
                             },
                             default: None,
                            },
                           ),
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "extraConfig",
                               position: (1284, 15),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "if ($request_method = 'OPTIONS') {\n  add_header 'Access-Control-Allow-Origin' '*';\n  add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';\n  add_header 'Access-Control-Allow-Headers' 'User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range';\n  add_header 'Access-Control-Max-Age' 1728000;\n  add_header 'Content-Type' 'text/plain; charset=utf-8';\n  add_header 'Content-Length' 0;\n  return 204;\n}\n\nadd_header 'Access-Control-Allow-Origin' '*';\nadd_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';\nadd_header 'Access-Control-Allow-Headers' 'User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range';\nadd_header 'Access-Control-Expose-Headers' 'Content-Length,Content-Range';\n",
                               position: (1285, 1),
                              },
                             ],
                            },
                           ),
                          ],
                          recursive: false,
                          position: (1282, 34),
                         },
                        ),
                       ],
                       recursive: false,
                       position: (1281, 58),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (1280, 32),
                   },
                  ],
                 },
                ],
                position: (1255, 29),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (1231, 34),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "import",
          position: (1306, 6),
         },
         arguments: [
          Path {
           parts: [
            Raw {
             content: "./service.nix",
             position: (1306, 13),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "pages",
             position: (1306, 28),
            },
           ],
          },
          Map {
           bindings: [
            Inherit(
             None,
             [
              Raw {
               content: "configIniOfService",
               position: (1307, 15),
              },
             ],
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (1308, 7),
               },
              ],
             },
             Int {
              value: 5112,
              position: (1308, 14),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "mainService",
                position: (1309, 7),
               },
              ],
             },
             LetIn {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "srvsrht",
                   position: (1310, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "pagessrht",
                   position: (1310, 20),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "version",
                   position: (1311, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (1311, 19),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "sourcehut",
                    position: (1311, 24),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "srvsrht",
                     position: (1311, 36),
                    },
                   },
                   Raw {
                    content: "version",
                    position: (1311, 45),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "stateDir",
                   position: (1312, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "/var/lib/sourcehut/",
                   position: (1312, 21),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "srvsrht",
                    position: (1312, 42),
                   },
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "iniKey",
                   position: (1313, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "pages.sr.ht",
                   position: (1313, 19),
                  },
                 ],
                },
               ),
              ],
              target: Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "preStart",
                    position: (1315, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkBefore",
                   position: (1315, 20),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "set -x\n# Use the /run/sourcehut/",
                      position: (1316, 1),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "srvsrht",
                       position: (1317, 38),
                      },
                     },
                     Raw {
                      content: "/config.ini\n# installed by a previous ExecStartPre= in baseService\ncd /run/sourcehut/",
                      position: (1317, 46),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "srvsrht",
                       position: (1319, 31),
                      },
                     },
                     Raw {
                      content: "\n\nif test ! -e ",
                      position: (1319, 39),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "stateDir",
                       position: (1321, 26),
                      },
                     },
                     Raw {
                      content: "/db; then\n  ",
                      position: (1321, 35),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "postgresql",
                        position: (1322, 15),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "package",
                          position: (1322, 26),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/bin/psql ",
                      position: (1322, 34),
                     },
                     Raw {
                      content: "'",
                      position: (1322, 44),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (1322, 47),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "settings",
                          position: (1322, 51),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "iniKey",
                           position: (1322, 62),
                          },
                         },
                         Raw {
                          content: "connection-string",
                          position: (1322, 70),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "' -f ",
                      position: (1322, 88),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "pkgs",
                        position: (1322, 95),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "sourcehut",
                          position: (1322, 100),
                         },
                         Raw {
                          content: "pagessrht",
                          position: (1322, 110),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/share/sql/schema.sql\n  echo ",
                      position: (1322, 120),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "version",
                       position: (1323, 20),
                      },
                     },
                     Raw {
                      content: " >",
                      position: (1323, 28),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "stateDir",
                       position: (1323, 32),
                      },
                     },
                     Raw {
                      content: "/db\nfi\n\n",
                      position: (1323, 41),
                     },
                     Expression {
                      expression: FunctionApplication {
                       function: Variable {
                        identifier: "optionalString",
                        position: (1326, 13),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1326, 28),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "settings",
                            position: (1326, 32),
                           },
                           Expression {
                            expression: Variable {
                             identifier: "iniKey",
                             position: (1326, 43),
                            },
                           },
                           Raw {
                            content: "migrate-on-upgrade",
                            position: (1326, 51),
                           },
                          ],
                         },
                         default: None,
                        },
                        String {
                         parts: [
                          Raw {
                           content: "# Just try all the migrations because they're not linked to the version\nfor sql in ",
                           position: (1327, 1),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (1328, 26),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "sourcehut",
                               position: (1328, 31),
                              },
                              Raw {
                               content: "pagessrht",
                               position: (1328, 41),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/share/sql/migrations/*.sql; do\n  ",
                           position: (1328, 51),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "postgresql",
                             position: (1329, 17),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "package",
                               position: (1329, 28),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/bin/psql ",
                           position: (1329, 36),
                          },
                          Raw {
                           content: "'",
                           position: (1329, 46),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1329, 49),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "settings",
                               position: (1329, 53),
                              },
                              Expression {
                               expression: Variable {
                                identifier: "iniKey",
                                position: (1329, 64),
                               },
                              },
                              Raw {
                               content: "connection-string",
                               position: (1329, 72),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "' -f \"$sql\" || true\ndone\n",
                           position: (1329, 90),
                          },
                         ],
                        },
                       ],
                      },
                     },
                     Raw {
                      content: "\n\n# Disable webhook\ntouch ",
                      position: (1331, 14),
                     },
                     Expression {
                      expression: Variable {
                       identifier: "stateDir",
                       position: (1334, 19),
                      },
                     },
                     Raw {
                      content: "/webhook\n",
                      position: (1334, 28),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "serviceConfig",
                    position: (1336, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "ExecStart",
                       position: (1337, 11),
                      },
                     ],
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "mkForce",
                      position: (1337, 23),
                     },
                     arguments: [
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (1337, 34),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "sourcehut",
                             position: (1337, 39),
                            },
                            Raw {
                             content: "pagessrht",
                             position: (1337, 49),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/pages.sr.ht -b ",
                         position: (1337, 59),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (1337, 81),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "listenAddress",
                             position: (1337, 85),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: ":",
                         position: (1337, 99),
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "toString",
                           position: (1337, 102),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1337, 111),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "pages",
                               position: (1337, 115),
                              },
                              Raw {
                               content: "port",
                               position: (1337, 121),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                        },
                       ],
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (1336, 25),
                 },
                ),
               ],
               recursive: false,
               position: (1314, 12),
              },
              position: (1309, 21),
             },
            ),
           ],
           recursive: false,
           position: (1306, 35),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "import",
          position: (1342, 6),
         },
         arguments: [
          Path {
           parts: [
            Raw {
             content: "./service.nix",
             position: (1342, 13),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "paste",
             position: (1342, 28),
            },
           ],
          },
          Map {
           bindings: [
            Inherit(
             None,
             [
              Raw {
               content: "configIniOfService",
               position: (1343, 15),
              },
             ],
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (1344, 7),
               },
              ],
             },
             Int {
              value: 5011,
              position: (1344, 14),
             },
            ),
           ],
           recursive: false,
           position: (1342, 35),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "import",
          position: (1347, 6),
         },
         arguments: [
          Path {
           parts: [
            Raw {
             content: "./service.nix",
             position: (1347, 13),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "todo",
             position: (1347, 28),
            },
           ],
          },
          Map {
           bindings: [
            Inherit(
             None,
             [
              Raw {
               content: "configIniOfService",
               position: (1348, 15),
              },
             ],
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "port",
                position: (1349, 7),
               },
              ],
             },
             Int {
              value: 5003,
              position: (1349, 14),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "webhooks",
                position: (1350, 7),
               },
              ],
             },
             Variable {
              identifier: "true",
              position: (1350, 18),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "extraServices",
                position: (1351, 7),
               },
               Raw {
                content: "todosrht-lmtp",
                position: (1351, 21),
               },
              ],
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "wants",
                   position: (1352, 9),
                  },
                 ],
                },
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "postfix.service",
                     position: (1352, 20),
                    },
                   ],
                  },
                 ],
                 position: (1352, 17),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "unitConfig",
                   position: (1353, 9),
                  },
                  Raw {
                   content: "JoinsNamespaceOf",
                   position: (1353, 20),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optional",
                  position: (1353, 39),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (1353, 48),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "postfix",
                      position: (1353, 52),
                     },
                     Raw {
                      content: "enable",
                      position: (1353, 60),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "postfix.service",
                     position: (1353, 68),
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1354, 9),
                  },
                  Raw {
                   content: "ExecStart",
                   position: (1354, 23),
                  },
                 ],
                },
                String {
                 parts: [
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1354, 38),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "python",
                       position: (1354, 42),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/bin/todosrht-lmtp",
                   position: (1354, 49),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "serviceConfig",
                   position: (1356, 9),
                  },
                  Raw {
                   content: "PrivateUsers",
                   position: (1356, 23),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkForce",
                  position: (1356, 38),
                 },
                 arguments: [
                  Variable {
                   identifier: "false",
                   position: (1356, 46),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (1351, 37),
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "extraConfig",
                position: (1358, 7),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkIf",
               position: (1358, 21),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (1358, 26),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "postfix",
                   position: (1358, 30),
                  },
                  Raw {
                   content: "enable",
                   position: (1358, 38),
                  },
                 ],
                },
                default: None,
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "users",
                     position: (1359, 9),
                    },
                    Raw {
                     content: "groups",
                     position: (1359, 15),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "postfix",
                       position: (1359, 24),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "group",
                         position: (1359, 32),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "members",
                     position: (1359, 39),
                    },
                   ],
                  },
                  List {
                   elements: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (1359, 51),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "todo",
                        position: (1359, 55),
                       },
                       Raw {
                        content: "user",
                        position: (1359, 60),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (1359, 49),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "services",
                     position: (1360, 9),
                    },
                    Raw {
                     content: "sourcehut",
                     position: (1360, 18),
                    },
                    Raw {
                     content: "settings",
                     position: (1360, 28),
                    },
                    Expression {
                     expression: String {
                      parts: [
                       Raw {
                        content: "todo.sr.ht::mail",
                        position: (1360, 38),
                       },
                      ],
                     },
                    },
                    Raw {
                     content: "sock-group",
                     position: (1360, 56),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "postfix",
                    position: (1360, 69),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "group",
                      position: (1360, 77),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "services",
                     position: (1361, 9),
                    },
                    Raw {
                     content: "postfix",
                     position: (1361, 18),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "destination",
                        position: (1362, 11),
                       },
                      ],
                     },
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "todo.",
                          position: (1362, 28),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "domain",
                           position: (1362, 35),
                          },
                         },
                        ],
                       },
                      ],
                      position: (1362, 25),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "localRecipients",
                        position: (1369, 11),
                       },
                      ],
                     },
                     List {
                      elements: [
                       String {
                        parts: [
                         Raw {
                          content: "@todo.",
                          position: (1369, 32),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "domain",
                           position: (1369, 40),
                          },
                         },
                        ],
                       },
                      ],
                      position: (1369, 29),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "transport",
                        position: (1370, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "todo.",
                        position: (1371, 1),
                       },
                       Expression {
                        expression: Variable {
                         identifier: "domain",
                         position: (1371, 20),
                        },
                       },
                       Raw {
                        content: " lmtp:unix:",
                        position: (1371, 27),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (1371, 40),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "settings",
                            position: (1371, 44),
                           },
                           Expression {
                            expression: String {
                             parts: [
                              Raw {
                               content: "todo.sr.ht::mail",
                               position: (1371, 54),
                              },
                             ],
                            },
                           },
                           Raw {
                            content: "sock",
                            position: (1371, 72),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "\n",
                        position: (1371, 77),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (1361, 28),
                  },
                 ),
                ],
                recursive: false,
                position: (1358, 45),
               },
              ],
             },
            ),
           ],
           recursive: false,
           position: (1347, 34),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRenamedOptionModule",
          position: (1377, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (1377, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "sourcehut",
               position: (1377, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "originBase",
               position: (1377, 54),
              },
             ],
            },
           ],
           position: (1377, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (1378, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "sourcehut",
               position: (1378, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "settings",
               position: (1378, 54),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "sr.ht",
               position: (1378, 65),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "global-domain",
               position: (1378, 73),
              },
             ],
            },
           ],
           position: (1378, 28),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRenamedOptionModule",
          position: (1379, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (1379, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "sourcehut",
               position: (1379, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "address",
               position: (1379, 54),
              },
             ],
            },
           ],
           position: (1379, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (1380, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "sourcehut",
               position: (1380, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "listenAddress",
               position: (1380, 54),
              },
             ],
            },
           ],
           position: (1380, 28),
          },
         ],
        },
       ],
       position: (902, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (1384, 3),
        },
        Raw {
         content: "doc",
         position: (1384, 8),
        },
       ],
      },
      Path {
       parts: [
        Raw {
         content: "./sourcehut.xml",
         position: (1384, 14),
        },
       ],
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "meta",
         position: (1385, 3),
        },
        Raw {
         content: "maintainers",
         position: (1385, 8),
        },
       ],
      },
      With {
       expression: Variable {
        identifier: "maintainers",
        position: (1385, 27),
       },
       target: List {
        elements: [
         Variable {
          identifier: "julm",
          position: (1385, 42),
         },
         Variable {
          identifier: "tomberek",
          position: (1385, 47),
         },
        ],
        position: (1385, 40),
       },
       position: (1385, 22),
      },
     ),
    ],
    recursive: false,
    position: (109, 1),
   },
   position: (3, 1),
  },
  position: (2, 1),
 },
 position: (1, 1),
}