pmcf 2.69.0 → 2.70.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "2.69.0",
+  "version": "2.70.1",
   "publishConfig": {
     "access": "public"
   },
@@ -12,19 +12,19 @@
   "description": "Poor mans configuration management",
   "keywords": [
     "bind",
+    "chrony",
     "config",
     "config management",
     "dhcp",
     "dns",
+    "influxdb",
     "iwd",
     "kea",
     "keepalived",
+    "mosquitto",
     "openldap",
-    "systemd",
-    "chrony",
-    "influxdb",
     "openldap",
-    "mosquitto"
+    "systemd"
   ],
   "contributors": [
     {
@@ -57,7 +57,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.15.30",
-    "ava": "^6.3.0",
+    "ava": "^6.4.0",
     "c8": "^10.1.3",
     "documentation": "^14.0.3",
     "semantic-release": "^24.2.5",

package/src/endpoint.mjs

@@ -38,6 +38,10 @@ class PortEndpoint extends BaseEndpoint {
     return this._port ?? this.service.port;
   }
 
+  get socketAddress() {
+    return `${this.address}:${this.port}`;
+  }
+
   toString() {
     return `${this.type}:${this.family}/${this.address}[${this.port}]`;
   }
@@ -49,9 +53,10 @@ export class Endpoint extends PortEndpoint {
     this.networkAddress = networkAddress;
   }
 
+  /*
   get socketAddress() {
     return `${this.address}:${this.port}`;
-  }
+  }*/
 
   get hostName() {
     return this.networkAddress.networkInterface.hostName;
@@ -84,13 +89,16 @@ export class DomainNameEndpoint extends PortEndpoint {
     return {};
   }
 
+  get family() {
+    return "dns"; // TODO
+  }
+
   get address() {
     return this.domainName;
   }
 
-  get isPool()
-  {
-    return this.domainName.indexOf('pool') >= 0; // TODO
+  get isPool() {
+    return this.domainName.indexOf("pool") >= 0; // TODO
   }
 }
 

package/src/network-address.mjs

@@ -66,3 +66,7 @@ export function addresses(sources, options) {
 export function cidrAddresses(networkAddresses) {
   return [...networkAddresses].map(na => na.cidrAddress);
 }
+
+export function sortByFamilyAndAddress(a, b) {
+  return a.family.localeCompare(b.family) ?? a.address.localeCompare(b.address);
+}

package/src/service-types.mjs

@@ -2,44 +2,116 @@ export const ServiceTypes = {
   "pacman-repo": {
     extends: ["https"]
   },
-  mqtt: { endpoints: [{ protocol: "tcp", port: 1883, tls: false }] },
-  "secure-mqtt": { endpoints: [{ protocol: "tcp", port: 8883, tls: true }] },
-  ntp: { endpoints: [{ protocol: "udp", port: 123, tls: false }] },
-  dns: { endpoints: [{ protocol: "udp", port: 53, tls: false }] },
-  ldap: { endpoints: [{ protocol: "tcp", port: 389, tls: false }] },
-  ldaps: { endpoints: [{ protocol: "tcp", port: 636, tls: true }] },
-  http: { endpoints: [{ protocol: "tcp", port: 80, tls: false }] },
+  mqtt: {
+    endpoints: [
+      { family: "IPv4", protocol: "tcp", port: 1883, tls: false },
+      { family: "IPv6", protocol: "tcp", port: 1883, tls: false }
+    ]
+  },
+  "secure-mqtt": {
+    endpoints: [
+      { family: "IPv4", protocol: "tcp", port: 8883, tls: true },
+      { family: "IPv6", protocol: "tcp", port: 8883, tls: true }
+    ]
+  },
+  ntp: {
+    endpoints: [
+      { family: "IPv4", protocol: "udp", port: 123, tls: false },
+      { family: "IPv6", protocol: "udp", port: 123, tls: false }
+    ]
+  },
+  dns: {
+    endpoints: [
+      { family: "IPv4", protocol: "udp", port: 53, tls: false },
+      { family: "IPv6", protocol: "udp", port: 53, tls: false }
+    ]
+  },
+  ldap: {
+    endpoints: [
+      { family: "IPv4", protocol: "tcp", port: 389, tls: false },
+      { family: "IPv6", protocol: "tcp", port: 389, tls: false }
+    ]
+  },
+  ldaps: {
+    endpoints: [
+      { family: "IPv4", protocol: "tcp", port: 636, tls: true },
+      { family: "IPv6", protocol: "tcp", port: 636, tls: true }
+    ]
+  },
+  http: {
+    endpoints: [
+      { family: "IPv4", protocol: "tcp", port: 80, tls: false },
+      { family: "IPv6", protocol: "tcp", port: 80, tls: false }
+    ]
+  },
   https: {
-    endpoints: [{ protocol: "tcp", port: 443, tls: true }],
+    endpoints: [
+      { family: "IPv4", protocol: "tcp", port: 443, tls: true },
+      { family: "IPv6", protocol: "tcp", port: 443, tls: true }
+    ],
     dnsRecord: { type: "HTTPS", parameters: { alpn: "h2" } }
   },
   http3: {
-    endpoints: [{ protocol: "udp", port: 443, tls: false }],
+    endpoints: [
+      { family: "IPv4", protocol: "udp", port: 443, tls: true },
+      { family: "IPv6", protocol: "udp", port: 443, tls: true }
+    ],
     dnsRecord: {
       type: "HTTPS",
       parameters: { "no-default-alpn": undefined, alpn: "h3" }
     }
   },
-  rtsp: { endpoints: [{ protocol: "tcp", port: 554, tls: false }] },
+  rtsp: {
+    endpoints: [
+      { family: "IPv4", protocol: "tcp", port: 554, tls: false },
+      { family: "IPv6", protocol: "tcp", port: 554, tls: false }
+    ]
+  },
   smtp: {
-    endpoints: [{ protocol: "tcp", port: 25, tls: false }],
+    endpoints: [
+      { family: "IPv4", protocol: "tcp", port: 25, tls: false },
+      { family: "IPv6", protocol: "tcp", port: 25, tls: false }
+    ],
     dnsRecord: { type: "MX" }
   },
-  ssh: { endpoints: [{ protocol: "tcp", port: 22, tls: false }] },
-  imap: { endpoints: [{ protocol: "tcp", port: 143, tls: false }] },
-  imaps: { endpoints: [{ protocol: "tcp", port: 993, tls: true }] },
-  dhcp: { endpoints: [{ protocol: "udp", port: 547, tls: false }] },
+  ssh: {
+    endpoints: [
+      { family: "IPv4", protocol: "tcp", port: 22, tls: false },
+      { family: "IPv6", protocol: "tcp", port: 22, tls: false }
+    ]
+  },
+  imap: {
+    endpoints: [
+      { family: "IPv4", protocol: "tcp", port: 143, tls: false },
+      { family: "IPv6", protocol: "tcp", port: 143, tls: false }
+    ]
+  },
+  imaps: {
+    endpoints: [
+      { family: "IPv4", protocol: "tcp", port: 993, tls: true },
+      { family: "IPv6", protocol: "tcp", port: 993, tls: true }
+    ]
+  },
+  dhcp: {
+    endpoints: [
+      { family: "IPv4", protocol: "udp", port: 547, tls: false },
+      { family: "IPv6", protocol: "udp", port: 547, tls: false }
+    ]
+  },
   "dhcpv6-client": {
     endpoints: [
-      { protocol: "tcp", port: 546, tls: false },
-      { protocol: "udp", port: 546, tls: false }
+      { family: "IPv6", protocol: "tcp", port: 546, tls: false },
+      { family: "IPv6", protocol: "udp", port: 546, tls: false }
     ]
   },
-  "dhcpv6-server": { endpoints: [{ port: 547, tls: false }] },
+  "dhcpv6-server": { endpoints: [{ family: "IPv6", port: 547, tls: false }] },
   smb: { endpoints: [{ protocol: "tcp", port: 445, tls: false }] },
   timemachine: {
     extends: ["smb"],
-    endpoints: [{ protocol: "tcp", port: 445, tls: false }],
+    endpoints: [
+      { family: "IPv4", protocol: "tcp", port: 445, tls: false },
+      { family: "IPv6", protocol: "tcp", port: 445, tls: false }
+    ],
     dnsRecord: {
       type: "TXT",
       parameters: {
@@ -52,26 +124,51 @@ export const ServiceTypes = {
   }
 };
 
+function prepareEndPoints(type, td) {
+  if (td.endpoints) {
+    td.endpoints.forEach(e => (e.type = type));
+  }
+}
+
+Object.entries(ServiceTypes).forEach(([type, td]) =>
+  prepareEndPoints(type, td)
+);
+
 export function addServiceTypes(st) {
-  Object.assign(ServiceTypes, st);
+  for (const [type, td] of Object.entries(st)) {
+    ServiceTypes[type] = td;
+    prepareEndPoints(type, td);
+
+    if (td.services) {
+      addServiceTypes(td.services);
+    }
+  }
 }
 
 export function serviceTypeEndpoints(type) {
-  let st = ServiceTypes[type];
-  if (st) {
-    if (st.extends) {
-      return st.extends.reduce(
-        (a, c) => [...a, ...(ServiceTypes[c]?.endpoints || [])],
-        st.endpoints || []
+  let td = ServiceTypes[type];
+  if (td) {
+    const all = td.services
+      ? Object.keys(td.services)
+          .map(type => serviceTypeEndpoints(type))
+          .flat()
+      : [];
+
+    if (td.extends) {
+      all.push(
+        td.extends.reduce(
+          (a, c) => [...a, ...(ServiceTypes[c]?.endpoints || [])],
+          []
+        )
       );
     }
 
-    return st.endpoints;
+    if (td.endpoints) {
+      all.push(td.endpoints);
+    }
+
+    return all.flat();
   }
 
-  return [
-    {
-      tls: false
-    }
-  ];
+  return [];
 }

package/src/service.mjs

@@ -1,4 +1,11 @@
-import { Base, Host, Endpoint, DomainNameEndpoint } from "pmcf";
+import {
+  Base,
+  Host,
+  Endpoint,
+  DomainNameEndpoint,
+  HTTPEndpoint,
+  UnixEndpoint
+} from "pmcf";
 import { addType } from "./types.mjs";
 import { asArray } from "./utils.mjs";
 import { networkAddressProperties } from "./network-support.mjs";
@@ -131,18 +138,59 @@ export class Service extends Base {
     if (!data) {
       return [];
     }
-    const l = this._port === undefined ? {} : { port: this._port };
-    let result = [...this.host.networkAddresses()]
-      .map(na => data.map(d => new Endpoint(this, na, { ...d, ...l })))
-      .flat();
-
-    if (result.length === 0) {
-      result = data.map(
-        d => new DomainNameEndpoint(this, this.domainName, { ...d, ...l })
-      );
+
+    const result = [];
+
+    const domainNames = new Set([undefined]);
+
+    for (const e of data) {
+      switch (e.family) {
+        case "unix":
+          result.push(new UnixEndpoint(this, e.path, e));
+          break;
+
+        case undefined:
+        case "dns":
+        case "IPv4":
+        case "IPv6":
+          const options =
+            this._port === undefined ? { ...e } : { ...e, port: this._port };
+          delete options.kind;
+
+          for (const na of this.host.networkAddresses()) {
+            if (e.kind && e.kind !== na.networkInterface.kind) {
+              continue;
+            }
+
+            if (e.pathname) {
+              result.push(new HTTPEndpoint(this, na, options));
+            } else {
+              if (e.family === na.family) {
+                result.push(new Endpoint(this, na, options));
+              } else {
+                if (!domainNames.has(this.domainName)) {
+                  domainNames.add(this.domainName);
+                  result.push(
+                    new DomainNameEndpoint(this, this.domainName, options)
+                  );
+                }
+              }
+            }
+          }
+          break;
+      }
     }
 
-    return filter ? result.filter(filter) : result;
+    switch (typeof filter) {
+      case "string":
+        return result.filter(endpoint => endpoint.type === filter);
+
+      case "undefined":
+        return result;
+
+      default:
+        return result.filter(filter);
+    }
   }
 
   endpoint(filter) {
@@ -230,6 +278,7 @@ export class Service extends Base {
             dnsFullName(this.domainName)
           )
         );
+        break; // TODO only one ?
       }
     }
 

package/src/services/bind.mjs

@@ -22,21 +22,6 @@ import { addHook } from "../hooks.mjs";
 
 const address_types = ["network", "host", "network_interface"];
 
-const BindServiceTypes = {
-  "bind-statistics": {
-    endpoints: [
-      {
-        port: 19521,
-        protocol: "tcp",
-        tls: false
-      }
-    ]
-  },
-  rdnc: {
-    endpoints: [{ type: "rdnc", port: 953, protocol: "tcp", tls: false }]
-  }
-};
-
 const BindServiceTypeDefinition = {
   name: "bind",
   specializationOf: ServiceTypeDefinition,
@@ -104,14 +89,34 @@ const BindServiceTypeDefinition = {
   },
 
   service: {
-    extends: ["dns"]
-  },
-  services: BindServiceTypes
+    extends: ["dns"],
+    services: {
+      "bind-statistics": {
+        endpoints: [
+          {
+            family: "IPv4",
+            port: 19521,
+            protocol: "tcp",
+            tls: false,
+            kind: "loopback"
+          }
+        ]
+      },
+      "bind-rdnc": {
+        endpoints: [
+          {
+            family: "IPv4",
+            port: 953,
+            protocol: "tcp",
+            tls: false,
+            kind: "loopback"
+          }
+        ]
+      }
+    }
+  }
 };
 
-const rdncEndpoint = BindServiceTypes.rdnc.endpoints[0];
-const statisticsEndpoint = BindServiceTypes["bind-statistics"].endpoints[0];
-
 function addressesStatement(prefix, objects, generateEmpty = false) {
   const body = asArray(objects).map(name => `  ${name};`);
 
@@ -172,21 +177,6 @@ export class BindService extends ExtraSourceService {
     return BindServiceTypeDefinition.name;
   }
 
-  endpoints(filter) {
-    const endpoints = super.endpoints(filter);
-
-    for (const na of this.owner.networkAddresses(
-      na => na.networkInterface.kind === "loopback"
-    )) {
-      endpoints.push(
-        new Endpoint(this, na, rdncEndpoint),
-        new Endpoint(this, na, statisticsEndpoint)
-      );
-    }
-
-    return filter ? endpoints.filter(filter) : endpoints;
-  }
-
   get soaUpdates() {
     return [this.serial, this.refresh, this.retry, this.expire, this.minimum];
   }

package/src/services/chrony.mjs

@@ -16,7 +16,29 @@ const ChronyServiceTypeDefinition = {
   priority: 0.1,
   properties: {},
   service: {
-    extends: ["ntp"]
+    extends: ["ntp"],
+    services: {
+      "chrony-cmd": {
+        endpoints: [
+          {
+            family: "IPv4",
+            port: 323,
+            protocol: "tcp",
+            tls: false
+          },
+          {
+            family: "IPv6",
+            port: 323,
+            protocol: "tcp",
+            tls: false
+          },
+          {
+            family: "unux",
+            path: "/var/run/chrony/chronyd.sock"
+          }
+        ]
+      }
+    }
   }
 };
 

package/src/services/influxdb.mjs

@@ -14,6 +14,13 @@ const InfluxdbServiceTypeDefinition = {
   service: {
     endpoints: [
       {
+        family: "IPv4",
+        port: 8086,
+        protocol: "tcp",
+        tls: false
+      },
+      {
+        family: "IPv6",
         port: 8086,
         protocol: "tcp",
         tls: false

package/src/services/kea.mjs

@@ -5,9 +5,6 @@ import {
   Service,
   sortDescendingByPriority,
   ServiceTypeDefinition,
-  Endpoint,
-  UnixEndpoint,
-  HTTPEndpoint,
   serviceEndpoints,
   SUBNET_LOCALHOST_IPV4,
   SUBNET_LOCALHOST_IPV6
@@ -15,55 +12,6 @@ import {
 import { addType } from "../types.mjs";
 import { writeLines } from "../utils.mjs";
 
-const ddnsEndpoint = {
-  type: "kea-ddns",
-  port: 53001,
-  protocol: "tcp",
-  tls: false
-};
-
-const controlAgentEndpoint = {
-  type: "kea-control-agent",
-  port: 53002,
-  pathname: "/",
-  protocol: "tcp",
-  tls: false
-};
-
-const ha4Endpoint = {
-  type: "kea-ha-4",
-  port: 53003,
-  pathname: "/",
-  protocol: "tcp",
-  tls: false
-};
-
-const ha6Endpoint = {
-  type: "kea-ha-6",
-  port: 53004,
-  pathname: "/",
-  protocol: "tcp",
-  tls: false
-};
-
-const control4Endpoint = {
-  type: "kea-control-dhcp4",
-  family: "unix",
-  path: "/run/kea/4-ctrl-socket"
-};
-
-const control6Endpoint = {
-  type: "kea-control-dhcp6",
-  family: "unix",
-  path: "/run/kea/6-ctrl-socket"
-};
-
-const controlDDNSEndpoint = {
-  type: "kea-control-ddns",
-  family: "unix",
-  path: "/run/kea/ddns-ctrl-socket"
-};
-
 const KeaServiceTypeDefinition = {
   name: "kea",
   specializationOf: ServiceTypeDefinition,
@@ -72,29 +20,76 @@ const KeaServiceTypeDefinition = {
   priority: 0.1,
   properties: {},
   service: {
-    extends: ["dhcp"]
-  },
-  services: {
-    "kea-ddns": {
-      endpoints: [ddnsEndpoint]
-    },
-    "kea-control-agent": {
-      endpoints: [controlAgentEndpoint]
-    },
-    "kea-ha-4": {
-      endpoints: [ha4Endpoint]
-    },
-    "kea-ha-6": {
-      endpoints: [ha6Endpoint]
-    },
-    "kea-control-dhcp4": {
-      endpoints: [control4Endpoint]
-    },
-    "kea-control-dhcp6": {
-      endpoints: [control6Endpoint]
-    },
-    "kea-control-ddns": {
-      endpoints: [controlDDNSEndpoint]
+    extends: ["dhcp"],
+    services: {
+      "kea-ddns": {
+        endpoints: [
+          {
+            family: "IPv4",
+            port: 53001,
+            protocol: "tcp",
+            tls: false
+          }
+        ]
+      },
+      "kea-control-agent": {
+        endpoints: [
+          {
+            family: "IPv4",
+            port: 53002,
+            pathname: "/",
+            protocol: "tcp",
+            tls: false
+          }
+        ]
+      },
+      /*
+      "kea-ha-4": {
+        endpoints: [
+          {
+            family: "IPv4",
+            port: 53003,
+            pathname: "/",
+            protocol: "tcp",
+            tls: false
+          }
+        ]
+      },
+      "kea-ha-6": {
+        endpoints: [
+          {
+            family: "IPv6",
+            port: 53004,
+            pathname: "/",
+            protocol: "tcp",
+            tls: false
+          }
+        ]
+      },*/
+      "kea-control-dhcp4": {
+        endpoints: [
+          {
+            family: "unix",
+            path: "/run/kea/4-ctrl-socket"
+          }
+        ]
+      },
+      "kea-control-dhcp6": {
+        endpoints: [
+          {
+            family: "unix",
+            path: "/run/kea/6-ctrl-socket"
+          }
+        ]
+      },
+      "kea-control-ddns": {
+        endpoints: [
+          {
+            family: "unix",
+            path: "/run/kea/ddns-ctrl-socket"
+          }
+        ]
+      }
     }
   }
 };
@@ -117,43 +112,11 @@ export class KeaService extends Service {
   }
 
   get type() {
-    return "dhcp"; //KeaServiceTypeDefinition.name;
-  }
-
-  endpoints(filter) {
-    const endpoints = super.endpoints(filter);
-
-    for (const na of this.host.networkAddresses()) {
-      endpoints.push(new HTTPEndpoint(this, na, controlAgentEndpoint));
-
-      if (fetureHasHTTPEndpoints) {
-        endpoints.push(
-          new HTTPEndpoint(
-            this,
-            na,
-            na.family === "IPv4" ? ha4Endpoint : ha6Endpoint
-          )
-        );
-      }
-
-      if (na.networkInterface.kind === "loopback") {
-        endpoints.push(new Endpoint(this, na, ddnsEndpoint));
-      }
-    }
-
-    endpoints.push(
-      new UnixEndpoint(this, control4Endpoint.path, control4Endpoint),
-      new UnixEndpoint(this, control6Endpoint.path, control6Endpoint),
-      new UnixEndpoint(this, controlDDNSEndpoint.path, controlDDNSEndpoint)
-    );
-
-    return filter ? endpoints.filter(filter) : endpoints;
+    return KeaServiceTypeDefinition.name;
   }
 
   async *preparePackages(dir) {
-    const ctrlAgentEndpoint = this.endpoint(
-      e => e.type === "kea-control-agent"
-    );
+    const ctrlAgentEndpoint = this.endpoint("kea-control-agent");
 
     if (!ctrlAgentEndpoint) {
       return;
@@ -189,7 +152,7 @@ export class KeaService extends Service {
       (
         await Array.fromAsync(
           network.findServices({
-            type: "dhcp",
+            type: "kea",
             priority: ">=" + (this.priority < 100 ? this.priority : 100)
           })
         )
@@ -197,11 +160,7 @@ export class KeaService extends Service {
         .sort(sortDescendingByPriority)
         .map((dhcp, i) => {
           const ctrlAgentEndpoint = dhcp.endpoint(
-            e =>
-              e.type ===
-              (fetureHasHTTPEndpoints
-                ? `kea-ha-${family}`
-                : "kea-control-agent")
+            fetureHasHTTPEndpoints ? `kea-ha-${family}` : "kea-control-agent"
           );
 
           if (ctrlAgentEndpoint) {
@@ -232,9 +191,7 @@ export class KeaService extends Service {
         "interfaces-config": {
           interfaces: listenInterfaces(`IPv${family}`)
         },
-        "control-socket": toUnix(
-          this.endpoint(e => e.type === `kea-control-dhcp${family}`)
-        ),
+        "control-socket": toUnix(this.endpoint(`kea-control-dhcp${family}`)),
         "lease-database": {
           type: "memfile",
           "lfc-interval": 3600
@@ -313,9 +270,9 @@ export class KeaService extends Service {
         "http-host": ctrlAgentEndpoint.hostname,
         "http-port": ctrlAgentEndpoint.port,
         "control-sockets": {
-          dhcp4: toUnix(this.endpoint(e => e.type === "kea-control-dhcp4")),
-          dhcp6: toUnix(this.endpoint(e => e.type === "kea-control-dhcp6")),
-          d2: toUnix(this.endpoint(e => e.type === "kea-control-ddns"))
+          dhcp4: toUnix(this.endpoint("kea-control-dhcp4")),
+          dhcp6: toUnix(this.endpoint("kea-control-dhcp6")),
+          d2: toUnix(this.endpoint("kea-control-ddns"))
         },
         loggers
       }
@@ -333,7 +290,7 @@ export class KeaService extends Service {
         };
       });
 
-    const ddnsEndpoint = this.endpoint(e => e.type === "kea-ddns");
+    const ddnsEndpoint = this.endpoint("kea-ddns");
 
     const subnetPrefixes = new Set(
       [...this.subnets]

package/src/services/systemd-journal-remote.mjs

@@ -9,9 +9,15 @@ const SystemdJournalRemoteServiceTypeDefinition = {
   priority: 0.1,
   properties: {},
   services: {
-    extends: ["http"],
     endpoints: [
       {
+        family: "IPv4",
+        port: 19532,
+        protocol: "tcp",
+        tls: false
+      },
+      {
+        family: "IPv6",
         port: 19532,
         protocol: "tcp",
         tls: false

package/src/services/systemd-resolved.mjs

@@ -41,7 +41,8 @@ export class SystemdResolvedService extends ExtraSourceService {
     const options = (priority, limit) => {
       return {
         services: { types: "dns", priority },
-        endpoints: e => e.networkInterface.kind !== "loopback",
+        endpoints: e =>
+          e.networkInterface.kind !== "loopback" && e.family !== "dns",
         select: endpoint => endpoint.address,
         join: " ",
         limit

package/src/services/systemd-timesyncd.mjs

@@ -46,7 +46,7 @@ export class SystemdTimesyncdService extends ExtraSourceService {
         {
           NTP: serviceEndpoints(this, {
             services: {
-              type: "ntp",
+              types: "ntp",
               priority: "[200:399]"
             },
             endpoints: endpoint =>

package/src/types.mjs

@@ -14,10 +14,6 @@ export function addType(clazz) {
     addServiceTypes({ [type.name]: type.service });
   }
 
-  if (type.services) {
-    addServiceTypes(type.services);
-  }
-
   types[type.name] = type;
 
   type.clazz = clazz;

package/types/endpoint.d.mts

@@ -1,7 +1,6 @@
 export class Endpoint extends PortEndpoint {
     constructor(service: any, networkAddress: any, data: any);
     networkAddress: any;
-    get socketAddress(): string;
     get hostName(): any;
     get domainName(): any;
     get address(): any;
@@ -12,6 +11,7 @@ export class DomainNameEndpoint extends PortEndpoint {
     constructor(service: any, domainName: any, data: any);
     domainName: any;
     get networkInterface(): {};
+    get family(): string;
     get address(): any;
     get isPool(): boolean;
 }
@@ -38,6 +38,7 @@ declare class PortEndpoint extends BaseEndpoint {
     protocol: any;
     tls: any;
     get port(): any;
+    get socketAddress(): string;
 }
 declare class BaseEndpoint {
     constructor(service: any, data: any);

package/types/network-address.d.mts

@@ -11,6 +11,7 @@ export function addresses(sources: Iterable<Owner | string>, options: {
     filter: any;
 }): Iterable<string>;
 export function cidrAddresses(networkAddresses: any): any[];
+export function sortByFamilyAndAddress(a: any, b: any): any;
 /**
  *
  */

package/types/service-types.d.mts

@@ -6,6 +6,7 @@ export const ServiceTypes: {
     };
     mqtt: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -13,6 +14,7 @@ export const ServiceTypes: {
     };
     "secure-mqtt": {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -20,6 +22,7 @@ export const ServiceTypes: {
     };
     ntp: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -27,6 +30,7 @@ export const ServiceTypes: {
     };
     dns: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -34,6 +38,7 @@ export const ServiceTypes: {
     };
     ldap: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -41,6 +46,7 @@ export const ServiceTypes: {
     };
     ldaps: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -48,6 +54,7 @@ export const ServiceTypes: {
     };
     http: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -55,6 +62,7 @@ export const ServiceTypes: {
     };
     https: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -68,6 +76,7 @@ export const ServiceTypes: {
     };
     http3: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -82,6 +91,7 @@ export const ServiceTypes: {
     };
     rtsp: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -89,6 +99,7 @@ export const ServiceTypes: {
     };
     smtp: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -99,6 +110,7 @@ export const ServiceTypes: {
     };
     ssh: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -106,6 +118,7 @@ export const ServiceTypes: {
     };
     imap: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -113,6 +126,7 @@ export const ServiceTypes: {
     };
     imaps: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -120,6 +134,7 @@ export const ServiceTypes: {
     };
     dhcp: {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -127,6 +142,7 @@ export const ServiceTypes: {
     };
     "dhcpv6-client": {
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;
@@ -134,6 +150,7 @@ export const ServiceTypes: {
     };
     "dhcpv6-server": {
         endpoints: {
+            family: string;
             port: number;
             tls: boolean;
         }[];
@@ -148,6 +165,7 @@ export const ServiceTypes: {
     timemachine: {
         extends: string[];
         endpoints: {
+            family: string;
             protocol: string;
             port: number;
             tls: boolean;

package/types/service.d.mts

@@ -334,8 +334,8 @@ export class Service extends Base {
     get networks(): Set<any>;
     get subnets(): Set<any>;
     get serviceTypeEndpoints(): any;
-    endpoints(filter: any): any[];
-    endpoint(filter: any): any;
+    endpoints(filter: any): (UnixEndpoint | HTTPEndpoint | Endpoint | DomainNameEndpoint)[];
+    endpoint(filter: any): UnixEndpoint | HTTPEndpoint | Endpoint | DomainNameEndpoint;
     address(options?: {
         endpoints: (e: any) => boolean;
         select: (e: any) => any;
@@ -363,3 +363,7 @@ export function sortAscendingByPriority(a: any, b: any): number;
 export function sortDescendingByPriority(a: any, b: any): number;
 import { Base } from "pmcf";
 import { Host } from "pmcf";
+import { UnixEndpoint } from "pmcf";
+import { HTTPEndpoint } from "pmcf";
+import { Endpoint } from "pmcf";
+import { DomainNameEndpoint } from "pmcf";

package/types/services/bind.d.mts

@@ -362,22 +362,25 @@ export class BindService extends ExtraSourceService {
         };
         service: {
             extends: string[];
-        };
-        services: {
-            "bind-statistics": {
-                endpoints: {
-                    port: number;
-                    protocol: string;
-                    tls: boolean;
-                }[];
-            };
-            rdnc: {
-                endpoints: {
-                    type: string;
-                    port: number;
-                    protocol: string;
-                    tls: boolean;
-                }[];
+            services: {
+                "bind-statistics": {
+                    endpoints: {
+                        family: string;
+                        port: number;
+                        protocol: string;
+                        tls: boolean;
+                        kind: string;
+                    }[];
+                };
+                "bind-rdnc": {
+                    endpoints: {
+                        family: string;
+                        port: number;
+                        protocol: string;
+                        tls: boolean;
+                        kind: string;
+                    }[];
+                };
             };
         };
     };

package/types/services/chrony.d.mts

@@ -266,6 +266,23 @@ export class ChronyService extends ExtraSourceService {
         properties: {};
         service: {
             extends: string[];
+            services: {
+                "chrony-cmd": {
+                    endpoints: ({
+                        family: string;
+                        port: number;
+                        protocol: string;
+                        tls: boolean;
+                        path?: undefined;
+                    } | {
+                        family: string;
+                        path: string;
+                        port?: undefined;
+                        protocol?: undefined;
+                        tls?: undefined;
+                    })[];
+                };
+            };
         };
     };
     preparePackages(dir: any): AsyncGenerator<{

package/types/services/influxdb.d.mts

@@ -254,6 +254,7 @@ export class InfluxdbService extends Service {
         properties: {};
         service: {
             endpoints: {
+                family: string;
                 port: number;
                 protocol: string;
                 tls: boolean;

package/types/services/kea.d.mts

@@ -255,63 +255,42 @@ export class KeaService extends Service {
         properties: {};
         service: {
             extends: string[];
-        };
-        services: {
-            "kea-ddns": {
-                endpoints: {
-                    type: string;
-                    port: number;
-                    protocol: string;
-                    tls: boolean;
-                }[];
-            };
-            "kea-control-agent": {
-                endpoints: {
-                    type: string;
-                    port: number;
-                    pathname: string;
-                    protocol: string;
-                    tls: boolean;
-                }[];
-            };
-            "kea-ha-4": {
-                endpoints: {
-                    type: string;
-                    port: number;
-                    pathname: string;
-                    protocol: string;
-                    tls: boolean;
-                }[];
-            };
-            "kea-ha-6": {
-                endpoints: {
-                    type: string;
-                    port: number;
-                    pathname: string;
-                    protocol: string;
-                    tls: boolean;
-                }[];
-            };
-            "kea-control-dhcp4": {
-                endpoints: {
-                    type: string;
-                    family: string;
-                    path: string;
-                }[];
-            };
-            "kea-control-dhcp6": {
-                endpoints: {
-                    type: string;
-                    family: string;
-                    path: string;
-                }[];
-            };
-            "kea-control-ddns": {
-                endpoints: {
-                    type: string;
-                    family: string;
-                    path: string;
-                }[];
+            services: {
+                "kea-ddns": {
+                    endpoints: {
+                        family: string;
+                        port: number;
+                        protocol: string;
+                        tls: boolean;
+                    }[];
+                };
+                "kea-control-agent": {
+                    endpoints: {
+                        family: string;
+                        port: number;
+                        pathname: string;
+                        protocol: string;
+                        tls: boolean;
+                    }[];
+                };
+                "kea-control-dhcp4": {
+                    endpoints: {
+                        family: string;
+                        path: string;
+                    }[];
+                };
+                "kea-control-dhcp6": {
+                    endpoints: {
+                        family: string;
+                        path: string;
+                    }[];
+                };
+                "kea-control-ddns": {
+                    endpoints: {
+                        family: string;
+                        path: string;
+                    }[];
+                };
             };
         };
     };

package/types/services/systemd-journal-remote.d.mts

@@ -253,8 +253,8 @@ export class SystemdJournalRemoteService extends Service {
         priority: number;
         properties: {};
         services: {
-            extends: string[];
             endpoints: {
+                family: string;
                 port: number;
                 protocol: string;
                 tls: boolean;