@takodotid/circuit 0.43.0 → 1.0.0-rc.1

package/dist/chunks/index-yzw86rc8.js

@@ -1,921 +0,0 @@
-import {
-  Catalog
-} from "./index-6wb41q67.js";
-import {
-  Address2
-} from "./index-n7w3tg5y.js";
-
-// src/core/topology.ts
-class Builder {
-  nodes = new Map;
-  edges = [];
-  node(id, kind, label, detail = []) {
-    const existing = this.nodes.get(id);
-    if (!existing)
-      this.nodes.set(id, { id, kind, label, detail: [...detail] });
-    else
-      for (const line of detail)
-        if (!existing.detail.includes(line))
-          existing.detail.push(line);
-    return id;
-  }
-  edge(edge) {
-    this.edges.push(edge);
-    return edge;
-  }
-}
-
-class Topology {
-  static LAYERS = ["l1", "l2", "l3", "bgp", "ospf", "tunnels"];
-  static deviceId(name) {
-    return `device:${name}`;
-  }
-  static keyOf(address) {
-    if (!address || !Address2.isValid(address))
-      return;
-    return `${Address2.family(address)}:${Address2.toNumber(address)}`;
-  }
-  static isHostRoute(cidr) {
-    const { len, family } = Address2.split(cidr);
-    return len === Address2.bits(family);
-  }
-  static routedOf(device) {
-    const ports = Object.entries(device.ports ?? {}).flatMap(([name, port]) => port ? [[name, port]] : []);
-    const interfaces = Object.entries(device.interfaces ?? {});
-    return [...ports, ...interfaces];
-  }
-  static holders(devices) {
-    return devices.flatMap((device) => Topology.routedOf(device).flatMap(([name, settings]) => (settings.addresses ?? []).flatMap((entry) => {
-      const address = typeof entry === "string" ? entry : entry.address;
-      if (!Address2.isCidr(address))
-        return [];
-      const peer = typeof entry === "string" ? undefined : entry.peer;
-      return [{ device, name, address, peer, vrrp: settings.vrrp ?? [], vrf: settings.vrf }];
-    })));
-  }
-  static describeDevice(device) {
-    const addresses = Topology.routedOf(device).filter(([, settings]) => settings.addresses?.length).map(([name, settings]) => {
-      const list = (settings.addresses ?? []).map((entry) => typeof entry === "string" ? entry : `${entry.address} to ${entry.peer}`);
-      const vrf = settings.vrf ? `, VRF ${settings.vrf}` : "";
-      return `${name}: ${list.join(", ")}${vrf}`;
-    });
-    return [
-      `${device.platform} ${device.model}`,
-      device.connection.host ? `reached at ${device.connection.host}` : "reached through its console",
-      ...addresses
-    ];
-  }
-  static carriedBy(device, settings) {
-    const vlan = (name, untagged) => {
-      const id = name ? device.vlans?.[name]?.id : undefined;
-      return name && id !== undefined ? [{ name, id, untagged }] : [];
-    };
-    const trunk = (settings?.trunk_vlans ?? []).filter((name) => name !== settings?.native_vlan);
-    return [
-      ...vlan(settings?.access_vlan, true),
-      ...vlan(settings?.native_vlan, true),
-      ...trunk.flatMap((name) => vlan(name, false))
-    ].sort((a, b) => a.id - b.id);
-  }
-  static vlanLabel(vlans) {
-    if (vlans.length === 1)
-      return `${vlans[0].name}${vlans[0].untagged ? ", untagged" : ""}`;
-    if (vlans.length <= 3)
-      return vlans.map((vlan) => vlan.name).join(", ");
-    return `${vlans.length} VLANs`;
-  }
-  static cables(devices, graph) {
-    const byName = new Map(devices.map((device) => [device.name, device]));
-    const drawn = new Set;
-    const bundles = new Map;
-    for (const device of devices) {
-      for (const [portName, port] of Object.entries(device.ports ?? {})) {
-        const link = port?.link;
-        if (!port || !link)
-          continue;
-        const here = `${device.name} ${portName}`;
-        const there = `${link.device} ${link.port}`;
-        if (drawn.has(`${there}|${here}`))
-          continue;
-        drawn.add(`${here}|${there}`);
-        const far = byName.get(link.device);
-        const farPort = far?.ports?.[link.port];
-        const linksBack = farPort?.link?.device === device.name && farPort.link.port === portName;
-        const to = far ? Topology.deviceId(far.name) : graph.node(`missing:${link.device}`, "outside", link.device, ["named by a link, and not in the network"]);
-        const through = link.through ? `, through ${link.through}` : "";
-        const cableLine = `${here} to ${there}${through}`;
-        const lag = port.lag;
-        const farLag = farPort?.lag;
-        const bundleKey = `${device.name} ${lag}|${link.device} ${farLag}`;
-        const bundle = lag && farLag && linksBack ? bundles.get(bundleKey) : undefined;
-        if (bundle) {
-          bundle.members++;
-          bundle.cable.detail.push(cableLine);
-          bundle.cable.label = `${lag} to ${farLag}, ${bundle.members} cables${through}`;
-          continue;
-        }
-        const isBundle = Boolean(lag && farLag && linksBack);
-        const cable = graph.edge({
-          layer: "l1",
-          from: Topology.deviceId(device.name),
-          to,
-          label: `${isBundle ? `${lag} to ${farLag}` : `${portName} to ${link.port}`}${through}`,
-          detail: [cableLine],
-          ...linksBack ? {} : { oneSided: true }
-        });
-        if (isBundle)
-          bundles.set(bundleKey, { cable, members: 1 });
-        const lagSettings = lag ? device.interfaces?.[lag] : undefined;
-        const carrier = lagSettings?.type === "lag" ? lagSettings : lag ? undefined : port;
-        const vlans = Topology.carriedBy(device, carrier);
-        if (!vlans.length)
-          continue;
-        graph.edge({
-          layer: "l2",
-          from: Topology.deviceId(device.name),
-          to,
-          label: Topology.vlanLabel(vlans),
-          detail: [
-            `${device.name} ${lag ?? portName}`,
-            ...vlans.map((vlan) => `${vlan.name}, VLAN ${vlan.id}${vlan.untagged ? ", untagged" : ""}`)
-          ],
-          vlans,
-          ...linksBack ? {} : { oneSided: true }
-        });
-      }
-    }
-  }
-  static segments(holders, owners, graph) {
-    const bySegment = new Map;
-    const pairs = new Set;
-    for (const holder of holders) {
-      if (holder.peer) {
-        const far = owners.get(Topology.keyOf(holder.peer) ?? "");
-        if (!far || far.device === holder.device)
-          continue;
-        const ends = [`${holder.device.name} ${holder.name}`, `${far.device.name} ${far.name}`].sort().join("|");
-        if (pairs.has(ends))
-          continue;
-        pairs.add(ends);
-        graph.edge({
-          layer: "l3",
-          from: Topology.deviceId(holder.device.name),
-          to: Topology.deviceId(far.device.name),
-          label: `${Address2.host(holder.address)} to ${Address2.host(far.address)}`,
-          detail: [`${holder.device.name} ${holder.name} ${holder.address}`, `${far.device.name} ${far.name} ${far.address}`]
-        });
-        continue;
-      }
-      if (Topology.isHostRoute(holder.address))
-        continue;
-      const segment = Address2.prefixOf(holder.address);
-      bySegment.set(segment, [...bySegment.get(segment) ?? [], holder]);
-    }
-    for (const [segment, members] of bySegment) {
-      if (new Set(members.map((member) => member.device.name)).size < 2)
-        continue;
-      const memberLines = members.map((member) => `${member.device.name} ${member.name} ${member.address}`);
-      const vrrpLines = members.flatMap((member) => member.vrrp.map((group) => `VRRP ${group.id} ${group.address} on ${member.device.name}, priority ${group.priority ?? 100}`));
-      if (members.length === 2) {
-        const [a, b] = members;
-        graph.edge({
-          layer: "l3",
-          from: Topology.deviceId(a.device.name),
-          to: Topology.deviceId(b.device.name),
-          label: segment,
-          detail: [...memberLines, ...vrrpLines]
-        });
-        continue;
-      }
-      const id = graph.node(`segment:${segment}`, "segment", segment, [...memberLines, ...vrrpLines]);
-      for (const member of members) {
-        graph.edge({
-          layer: "l3",
-          from: Topology.deviceId(member.device.name),
-          to: id,
-          label: `${member.name} ${Address2.host(member.address)}`,
-          detail: [`${member.device.name} ${member.name} ${member.address}`]
-        });
-      }
-    }
-  }
-  static sessions(devices, owners, graph) {
-    const all = devices.flatMap((device) => {
-      const bgp = device.routing?.bgp;
-      return Object.entries(bgp?.neighbors ?? {}).map(([name, neighbor]) => {
-        const group = neighbor.group ? bgp?.groups?.[neighbor.group] : undefined;
-        return {
-          device,
-          name,
-          address: neighbor.address,
-          ownAs: bgp.asn,
-          remoteAs: neighbor.remote_as ?? group?.remote_as,
-          role: neighbor.role ?? group?.role,
-          description: neighbor.description ?? group?.description,
-          import: neighbor.import ?? group?.import,
-          export: neighbor.export ?? group?.export
-        };
-      });
-    });
-    const describe = (session) => {
-      const parts = [
-        session.address,
-        session.remoteAs ? `AS${session.remoteAs}` : "no remote AS",
-        session.role,
-        session.import ? `import ${session.import}` : "imports nothing",
-        session.export ? `export ${session.export}` : "exports nothing"
-      ];
-      return `${session.device.name} ${session.name}: ${parts.filter(Boolean).join(", ")}`;
-    };
-    const ownerOf = (session) => owners.get(Topology.keyOf(session.address) ?? "")?.device;
-    const paired = new Set;
-    for (const session of all) {
-      if (paired.has(session))
-        continue;
-      const far = ownerOf(session);
-      if (far && far !== session.device) {
-        const back = all.find((other) => other.device === far && !paired.has(other) && ownerOf(other) === session.device && Address2.family(other.address) === Address2.family(session.address));
-        if (back)
-          paired.add(back);
-        graph.edge({
-          layer: "bgp",
-          from: Topology.deviceId(session.device.name),
-          to: Topology.deviceId(far.name),
-          label: session.remoteAs === session.ownAs ? "iBGP" : "eBGP",
-          detail: [describe(session), ...back ? [describe(back)] : [`${far.name} has no session back`]],
-          ...back ? {} : { oneSided: true }
-        });
-        continue;
-      }
-      const outside = session.remoteAs ? graph.node(`as:${session.remoteAs}`, "outside", `AS${session.remoteAs}`, session.description ? [session.description] : []) : graph.node(`address:${session.address}`, "outside", session.address, ["a BGP neighbor without a remote AS"]);
-      const internal = session.remoteAs === session.ownAs;
-      graph.edge({
-        layer: "bgp",
-        from: Topology.deviceId(session.device.name),
-        to: outside,
-        label: [session.name, session.role].filter(Boolean).join(", "),
-        detail: [describe(session), ...internal ? ["internal, and no device in the network holds the address"] : []],
-        ...internal ? { oneSided: true } : {}
-      });
-    }
-  }
-  static adjacencies(devices, graph) {
-    const byKey = new Map;
-    for (const device of devices) {
-      for (const [area, { interfaces }] of Object.entries(device.routing?.ospf?.areas ?? {})) {
-        for (const [name, settings] of Object.entries(interfaces)) {
-          if (settings?.passive)
-            continue;
-          const routed = device.ports?.[name] ?? device.interfaces?.[name];
-          const cost = settings?.cost ? `, cost ${settings.cost}` : "";
-          for (const entry of routed?.addresses ?? []) {
-            const address = typeof entry === "string" ? entry : entry.address;
-            if (!Address2.isCidr(address) || Topology.isHostRoute(address))
-              continue;
-            const key = `${area} ${Address2.prefixOf(address)}`;
-            const member = { device, name, line: `${device.name} ${name} ${address}${cost}` };
-            byKey.set(key, [...byKey.get(key) ?? [], member]);
-          }
-        }
-      }
-    }
-    for (const [key, members] of byKey) {
-      const [area] = key.split(" ");
-      for (const [index, a] of members.entries()) {
-        for (const b of members.slice(index + 1)) {
-          if (a.device === b.device)
-            continue;
-          graph.edge({
-            layer: "ospf",
-            from: Topology.deviceId(a.device.name),
-            to: Topology.deviceId(b.device.name),
-            label: `area ${area}`,
-            detail: [a.line, b.line]
-          });
-        }
-      }
-    }
-  }
-  static endpointHost(endpoint) {
-    return endpoint.replace(/:\d+$/, "").replace(/^\[(.*)\]$/, "$1");
-  }
-  static tunnels(devices, owners, graph) {
-    const ends = devices.flatMap((device) => Object.entries(device.interfaces ?? {}).flatMap(([name, iface]) => iface.type === "gre" || iface.type === "vxlan" ? [{ device, name, iface }] : []));
-    const same = (a, b) => Topology.keyOf(a) !== undefined && Topology.keyOf(a) === Topology.keyOf(b);
-    const mirrors = (a, b) => a.device !== b.device && a.iface.type === b.iface.type && same(a.iface.local, b.iface.remote) && same(a.iface.remote, b.iface.local) && (a.iface.type !== "vxlan" || b.iface.type === "vxlan" && a.iface.vni === b.iface.vni);
-    const describe = (end) => {
-      const vni = end.iface.type === "vxlan" ? `, VNI ${end.iface.vni}` : "";
-      return `${end.device.name} ${end.name}: ${end.iface.local} to ${end.iface.remote}${vni}`;
-    };
-    const paired = new Set;
-    for (const end of ends) {
-      if (paired.has(end))
-        continue;
-      const kind = end.iface.type === "gre" ? "GRE" : "VXLAN";
-      const mirror = ends.find((other) => !paired.has(other) && mirrors(end, other));
-      if (mirror) {
-        paired.add(mirror);
-        graph.edge({
-          layer: "tunnels",
-          from: Topology.deviceId(end.device.name),
-          to: Topology.deviceId(mirror.device.name),
-          label: `${kind} ${end.name} to ${mirror.name}`,
-          detail: [describe(end), describe(mirror)]
-        });
-        continue;
-      }
-      const owner = owners.get(Topology.keyOf(end.iface.remote) ?? "")?.device;
-      if (owner && owner !== end.device) {
-        graph.edge({
-          layer: "tunnels",
-          from: Topology.deviceId(end.device.name),
-          to: Topology.deviceId(owner.name),
-          label: `${kind} ${end.name}`,
-          detail: [describe(end), `${owner.name} declares no tunnel back`],
-          oneSided: true
-        });
-        continue;
-      }
-      const outside = graph.node(`address:${end.iface.remote}`, "outside", end.iface.remote, end.iface.description ? [end.iface.description] : []);
-      graph.edge({
-        layer: "tunnels",
-        from: Topology.deviceId(end.device.name),
-        to: outside,
-        label: `${kind} ${end.name}`,
-        detail: [describe(end)]
-      });
-    }
-    Topology.wireguard(devices, owners, graph);
-  }
-  static wireguard(devices, owners, graph) {
-    const interfaces = devices.flatMap((device) => Object.entries(device.interfaces ?? {}).flatMap(([name, iface]) => iface.type === "wireguard" ? [{ device, name, iface }] : []));
-    const farEndOf = (device, peer) => interfaces.find(({ device: other, iface }) => {
-      if (other === device)
-        return false;
-      const tunnelAddresses = (iface.addresses ?? []).map((entry) => Address2.host(typeof entry === "string" ? entry : entry.address));
-      const sendsFrom = tunnelAddresses.some((address) => Address2.isValid(address) && peer.allowed_addresses.some((allowed) => Address2.isCidr(allowed) && Address2.contains(allowed, address)));
-      const endpoint = peer.endpoint ? Topology.endpointHost(peer.endpoint) : undefined;
-      const isEndpoint = endpoint !== undefined && owners.get(Topology.keyOf(endpoint) ?? "")?.device === other;
-      return sendsFrom || isEndpoint;
-    });
-    const drawn = new Set;
-    for (const { device, name, iface } of interfaces) {
-      const clients = [];
-      for (const peer of iface.peers ?? []) {
-        const far = farEndOf(device, peer);
-        if (far) {
-          const ends = [`${device.name} ${name}`, `${far.device.name} ${far.name}`].sort().join("|");
-          if (drawn.has(ends))
-            continue;
-          drawn.add(ends);
-          graph.edge({
-            layer: "tunnels",
-            from: Topology.deviceId(device.name),
-            to: Topology.deviceId(far.device.name),
-            label: `WireGuard ${name} to ${far.name}`,
-            detail: [`${device.name} ${name} peer ${peer.name}`]
-          });
-          continue;
-        }
-        if (!peer.endpoint) {
-          clients.push(peer);
-          continue;
-        }
-        const endpoint = Topology.endpointHost(peer.endpoint);
-        const outside = graph.node(`address:${endpoint}`, "outside", peer.name, [`WireGuard endpoint ${peer.endpoint}`]);
-        graph.edge({
-          layer: "tunnels",
-          from: Topology.deviceId(device.name),
-          to: outside,
-          label: `WireGuard ${name}`,
-          detail: [`${device.name} ${name} peer ${peer.name}, allowed ${peer.allowed_addresses.join(", ")}`]
-        });
-      }
-      if (!clients.length)
-        continue;
-      const outside = graph.node(`clients:${device.name}:${name}`, "outside", `${clients.length} ${clients.length === 1 ? "client" : "clients"}`, clients.map((peer) => `${peer.name}: ${peer.allowed_addresses.join(", ")}`));
-      graph.edge({
-        layer: "tunnels",
-        from: Topology.deviceId(device.name),
-        to: outside,
-        label: `WireGuard ${name}`,
-        detail: [`peers that dial in to ${device.name} ${name}`]
-      });
-    }
-  }
-  static of(devices) {
-    const graph = new Builder;
-    for (const device of devices)
-      graph.node(Topology.deviceId(device.name), "device", device.name, Topology.describeDevice(device));
-    const holders = Topology.holders(devices);
-    const owners = new Map;
-    for (const holder of holders) {
-      const key = Topology.keyOf(Address2.host(holder.address));
-      if (!owners.has(key))
-        owners.set(key, holder);
-    }
-    Topology.cables(devices, graph);
-    Topology.segments(holders, owners, graph);
-    Topology.sessions(devices, owners, graph);
-    Topology.adjacencies(devices, graph);
-    Topology.tunnels(devices, owners, graph);
-    return { nodes: [...graph.nodes.values()], edges: graph.edges };
-  }
-  static only(graph, layers, deviceNames = []) {
-    const named = new Set(deviceNames.map(Topology.deviceId));
-    const touches = (edge) => !named.size || named.has(edge.from) || named.has(edge.to);
-    const edges = graph.edges.filter((edge) => layers.includes(edge.layer) && touches(edge));
-    const ends = new Set(edges.flatMap((edge) => [edge.from, edge.to]));
-    const nodes = graph.nodes.filter((node) => (named.size ? named.has(node.id) : node.kind === "device") || ends.has(node.id));
-    return { nodes, edges };
-  }
-}
-
-// src/core/address-space.ts
-class AddressSpace {
-  static isHostRoute(cidr) {
-    return Address2.split(cidr).len === Address2.bits(Address2.split(cidr).family);
-  }
-  static numberOf(address) {
-    return Address2.toNumber(address);
-  }
-  static usable(prefix) {
-    const { first, last, family } = Address2.range(prefix);
-    const { len } = Address2.split(prefix);
-    if (family === "ipv4" && len <= 30)
-      return { first: first + 1n, last: last - 1n };
-    if (family === "ipv6" && len < 127)
-      return { first: first + 1n, last };
-    return { first, last };
-  }
-  static merged(ranges) {
-    const sorted = [...ranges].sort((a, b) => a.first < b.first ? -1 : a.first > b.first ? 1 : 0);
-    const result = [];
-    for (const range of sorted) {
-      const previous = result.at(-1);
-      if (previous && range.first <= previous.last + 1n)
-        previous.last = range.last > previous.last ? range.last : previous.last;
-      else
-        result.push({ ...range });
-    }
-    return result;
-  }
-  static gaps(within, taken) {
-    const result = [];
-    let cursor = within.first;
-    for (const range of AddressSpace.merged(taken)) {
-      if (range.last < within.first || range.first > within.last)
-        continue;
-      if (range.first > cursor)
-        result.push({ first: cursor, last: range.first - 1n });
-      if (range.last + 1n > cursor)
-        cursor = range.last + 1n;
-    }
-    if (cursor <= within.last)
-      result.push({ first: cursor, last: within.last });
-    return result;
-  }
-  static count(value) {
-    if (value <= 1n << 20n)
-      return String(value);
-    const power = value.toString(2).length - 1;
-    const nearer = value - (1n << BigInt(power)) >= 1n << BigInt(power - 1) ? power + 1 : power;
-    return `about 2^${nearer}`;
-  }
-  static byAddress(a, b) {
-    const first = (use) => AddressSpace.numberOf(use.address.split("-")[0]);
-    return first(a) < first(b) ? -1 : first(a) > first(b) ? 1 : 0;
-  }
-  static comparePrefixes(a, b) {
-    const [ra, rb] = [Address2.range(a), Address2.range(b)];
-    if (ra.family !== rb.family)
-      return ra.family === "ipv4" ? -1 : 1;
-    return ra.first < rb.first ? -1 : ra.first > rb.first ? 1 : 0;
-  }
-  static byPrefix(a, b) {
-    return AddressSpace.comparePrefixes(a.prefix, b.prefix);
-  }
-  static report(devices, within) {
-    const segments = new Map;
-    const blocks = [];
-    const segmentOf = (address) => [...segments.keys()].find((prefix) => Address2.contains(prefix, address));
-    for (const holder of Topology.holders(devices)) {
-      const vrf = holder.device.ports?.[holder.name]?.vrf ?? holder.device.interfaces?.[holder.name]?.vrf;
-      const what = `${holder.device.name} ${holder.name}${vrf ? `, VRF ${vrf}` : ""}`;
-      if (AddressSpace.isHostRoute(holder.address) || holder.peer) {
-        blocks.push({ prefix: `${Address2.host(holder.address)}/${Address2.bits(Address2.family(holder.address))}`, what });
-        continue;
-      }
-      const prefix = Address2.prefixOf(holder.address);
-      const segment = segments.get(prefix) ?? { uses: [], taken: [] };
-      const value = AddressSpace.numberOf(Address2.host(holder.address));
-      segment.uses.push({ address: Address2.host(holder.address), what });
-      segment.taken.push({ first: value, last: value });
-      segments.set(prefix, segment);
-      for (const group of holder.vrrp) {
-        if (!Address2.isValid(group.address) || !Address2.contains(prefix, group.address))
-          continue;
-        if (segment.uses.some((use) => use.address === group.address))
-          continue;
-        const holders = devices.filter((device) => Object.values({ ...device.ports, ...device.interfaces }).some((settings) => settings?.vrrp?.some((other) => other.id === group.id && other.address === group.address)));
-        segment.uses.push({
-          address: group.address,
-          what: `VRRP ${group.id} on ${holders.map((device) => device.name).join(", ")}`
-        });
-        segment.taken.push({ first: AddressSpace.numberOf(group.address), last: AddressSpace.numberOf(group.address) });
-      }
-    }
-    const take = (address, what, first = address, last = address) => {
-      const prefix = segmentOf(first);
-      if (!prefix)
-        return false;
-      const segment = segments.get(prefix);
-      if (segment.uses.some((use) => use.address === address))
-        return true;
-      segment.uses.push({ address, what });
-      segment.taken.push({ first: AddressSpace.numberOf(first), last: AddressSpace.numberOf(last) });
-      return true;
-    };
-    for (const device of devices) {
-      for (const [name, server] of Object.entries(device.dhcp ?? {})) {
-        const [start, end] = server.pool;
-        if (Address2.isValid(start) && Address2.isValid(end))
-          take(`${start}-${end}`, `DHCP pool ${name} on ${device.name}`, start, end);
-        for (const reservation of server.reservations ?? []) {
-          if (Address2.isValid(reservation.address))
-            take(reservation.address, `reserved for ${reservation.description ?? reservation.mac} by ${device.name}`);
-        }
-      }
-      for (const route of device.routing?.static ?? []) {
-        if (route.via && Address2.isValid(route.via))
-          take(route.via, `next hop for ${route.prefix} on ${device.name}`);
-      }
-      for (const [name, neighbor] of Object.entries(device.routing?.bgp?.neighbors ?? {})) {
-        if (Address2.isValid(neighbor.address))
-          take(neighbor.address, `BGP neighbor ${name} of ${device.name}`);
-      }
-      for (const [name, iface] of Object.entries(device.interfaces ?? {})) {
-        if (iface.type !== "wireguard")
-          continue;
-        for (const peer of iface.peers ?? []) {
-          for (const allowed of peer.allowed_addresses) {
-            if (!Address2.isCidr(allowed))
-              continue;
-            const what = `WireGuard peer ${peer.name} on ${device.name} ${name}`;
-            if (AddressSpace.isHostRoute(allowed) && take(Address2.host(allowed), what))
-              continue;
-            if (!segmentOf(Address2.host(allowed)))
-              blocks.push({ prefix: Address2.prefixOf(allowed), what });
-          }
-        }
-      }
-    }
-    const owners = new Map;
-    for (const device of devices) {
-      for (const prefix of device.routing?.bgp?.networks ?? []) {
-        if (!Address2.isCidr(prefix))
-          continue;
-        owners.set(Address2.prefixOf(prefix), [...owners.get(Address2.prefixOf(prefix)) ?? [], device.name]);
-      }
-    }
-    for (const device of devices) {
-      for (const route of device.routing?.static ?? []) {
-        if (!Address2.isCidr(route.prefix) || Address2.split(route.prefix).len === 0)
-          continue;
-        const overlapsSegment = [...segments.keys()].some((prefix) => Address2.contains(route.prefix, prefix) || Address2.contains(prefix, route.prefix));
-        const coversOwned = [...owners.keys()].some((owned) => Address2.contains(route.prefix, owned));
-        if (overlapsSegment || coversOwned)
-          continue;
-        const how = route.blackhole ? "discarded" : route.via ? `routed via ${route.via}` : `routed out ${route.interface}`;
-        blocks.push({ prefix: Address2.prefixOf(route.prefix), what: `${how} by ${device.name}` });
-      }
-    }
-    const asked = within ? Address2.prefixOf(within) : undefined;
-    const spacePrefixes = asked ? [asked] : [...owners.keys()];
-    const spaceOf = (prefix) => spacePrefixes.filter((space) => Address2.contains(space, prefix)).sort((a, b) => Address2.split(b).len - Address2.split(a).len)[0];
-    const toSegment = (prefix) => {
-      const { uses, taken } = segments.get(prefix);
-      const free = AddressSpace.gaps(AddressSpace.usable(prefix), taken);
-      const total = free.reduce((sum, range) => sum + range.last - range.first + 1n, 0n);
-      const family = Address2.family(prefix);
-      return {
-        prefix,
-        uses: uses.sort(AddressSpace.byAddress),
-        free: AddressSpace.count(total),
-        ...free[0] ? { next: Address2.fromNumber(free[0].first, family) } : {}
-      };
-    };
-    const uniqueBlocks = blocks.filter((block, index) => blocks.findIndex((other) => other.prefix === block.prefix && other.what === block.what) === index);
-    const spaces = spacePrefixes.sort(AddressSpace.comparePrefixes).map((space) => {
-      const inside = (prefix) => spaceOf(prefix) === space;
-      const spaceSegments = [...segments.keys()].filter(inside).sort(AddressSpace.comparePrefixes);
-      const spaceBlocks = uniqueBlocks.filter((block) => inside(block.prefix)).sort(AddressSpace.byPrefix);
-      const nested = spacePrefixes.filter((other) => other !== space && Address2.contains(space, other));
-      const taken = [...spaceSegments, ...spaceBlocks.map((block) => block.prefix), ...nested].map((prefix) => Address2.range(prefix));
-      const family = Address2.family(space);
-      return {
-        prefix: space,
-        owner: asked && !owners.has(space) ? "asked for" : `originated by ${(owners.get(space) ?? []).join(", ")}`,
-        segments: spaceSegments.map(toSegment),
-        blocks: spaceBlocks,
-        free: AddressSpace.gaps(Address2.range(space), taken).flatMap((range) => Address2.prefixesBetween(range.first, range.last, family))
-      };
-    });
-    const outside = (prefix) => !spaceOf(prefix);
-    return {
-      spaces,
-      elsewhere: asked ? { segments: [], blocks: [] } : {
-        segments: [...segments.keys()].filter(outside).sort(AddressSpace.comparePrefixes).map(toSegment),
-        blocks: uniqueBlocks.filter((block) => outside(block.prefix)).sort(AddressSpace.byPrefix)
-      }
-    };
-  }
-  static freeOfLength(free, length, limit) {
-    const prefixes = [];
-    let total = 0n;
-    for (const prefix of free) {
-      const { len, family } = Address2.split(prefix);
-      if (len > length || length > Address2.bits(family))
-        continue;
-      const { first } = Address2.range(prefix);
-      const step = 1n << BigInt(Address2.bits(family) - length);
-      const fits = 1n << BigInt(length - len);
-      total += fits;
-      for (let index = 0n;index < fits && prefixes.length < limit; index++) {
-        prefixes.push(`${Address2.fromNumber(first + index * step, family)}/${length}`);
-      }
-    }
-    return { prefixes, total };
-  }
-}
-
-// src/studio/data.ts
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-// src/core/schema-docs.ts
-class SchemaDocs {
-  static FILES = [
-    ["device.ts", "Device"],
-    ["interfaces.ts", "Ports and interfaces"],
-    ["routing.ts", "Routing"],
-    ["policy.ts", "Route policies"],
-    ["firewall.ts", "Firewall and ACLs"],
-    ["system.ts", "System and management"],
-    ["common.ts", "Common values"]
-  ];
-  static commentText(lines) {
-    return lines.map((line) => line.replace(/^\s*\/\*\*\s?|\s*\*\/\s*$|^\s*\*\s?/g, "").trim()).filter(Boolean).join(" ");
-  }
-  static PARAMETER_MEANING = { Pl: "platform", M: "model" };
-  static withoutGenerics(type, generics) {
-    let result = type;
-    while (/NoInfer<([^<>]*)>/.test(result)) {
-      result = result.replace(/NoInfer<([^<>]*)>/g, (_, inner) => inner.includes("|") ? `(${inner})` : inner);
-    }
-    for (const name of generics) {
-      result = result.replace(new RegExp(`\\b${name}<[^<>]*(?:<[^<>]*>[^<>]*)*>`, "g"), name);
-    }
-    return result.replace(/"[^"]*"|\b(Pl|M|N|V|I|P|S|G|A|AS|U|F|C|L|K)\b/g, (found, parameter) => parameter ? SchemaDocs.PARAMETER_MEANING[parameter] ?? "name" : found).replace(/\bname(?: \| name)+\b/g, "name").replace(/\(name\)/g, "name");
-  }
-  static parse(source, generics) {
-    const lines = source.split(`
-`);
-    const types = [];
-    let comment = [];
-    let inComment = false;
-    let current;
-    let depth = 0;
-    const parents = [];
-    let header;
-    function finishHeader() {
-      const text = header;
-      header = undefined;
-      const body = text.slice(text.indexOf("> =") >= 0 ? text.indexOf("> =") + 3 : text.indexOf("=") + 1).trim();
-      if (!body.includes("{") || body.startsWith("`")) {
-        current.definition = body.replace(/;$/, "").replace(/^\|\s*/, "");
-      } else {
-        const before = body.slice(0, body.indexOf("{"));
-        const included = before.split("&").map((part) => part.trim()).filter((part) => /^\w/.test(part));
-        if (included.length)
-          current.includes = included;
-      }
-      depth = (text.match(/{/g) ?? []).length - (text.match(/}/g) ?? []).length;
-    }
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith("/**")) {
-        comment = [trimmed];
-        inComment = !trimmed.endsWith("*/");
-        continue;
-      }
-      if (inComment) {
-        comment.push(trimmed);
-        if (trimmed.endsWith("*/"))
-          inComment = false;
-        continue;
-      }
-      if (header !== undefined) {
-        header += ` ${trimmed}`;
-        if (trimmed.endsWith("{") || trimmed.endsWith(";"))
-          finishHeader();
-        continue;
-      }
-      const declaration = /^(?:export )?type (\w+)(<)?/.exec(trimmed);
-      if (declaration && depth === 0) {
-        if (declaration[2])
-          generics.add(declaration[1]);
-        current = { name: declaration[1], description: SchemaDocs.commentText(comment), fields: [] };
-        types.push(current);
-        comment = [];
-        header = trimmed;
-        if (trimmed.endsWith("{") || trimmed.endsWith(";"))
-          finishHeader();
-        continue;
-      }
-      if (!current)
-        continue;
-      const field = /^(?:readonly\s+)?("?[\w-]+"?)(\?)?:\s*(.*)$/.exec(trimmed);
-      if (field && depth >= 1) {
-        const [, name, optional, rest] = field;
-        const path = [...parents, name.replace(/"/g, "")].join(".");
-        const opensObject = rest.trim().endsWith("{");
-        const type = opensObject ? "object" : rest.replace(/;$/, "").trim();
-        current.fields.push({ path: `${path}${optional ? "?" : ""}`, type, description: SchemaDocs.commentText(comment) });
-        comment = [];
-        if (opensObject) {
-          parents.push(name.replace(/"/g, ""));
-          depth++;
-        }
-        continue;
-      }
-      const opens = (trimmed.match(/{/g) ?? []).length;
-      const closes = (trimmed.match(/}/g) ?? []).length;
-      for (let index = 0;index < closes - opens; index++) {
-        if (parents.length >= depth - 1 && parents.length > 0)
-          parents.pop();
-      }
-      depth += opens - closes;
-      if (depth <= 0) {
-        depth = 0;
-        parents.length = 0;
-      }
-      comment = [];
-    }
-    return types;
-  }
-  static read(sources) {
-    const generics = new Set;
-    const parsed = sources.map((source) => SchemaDocs.parse(source, generics));
-    for (const types of parsed) {
-      for (const type of types) {
-        if (type.definition)
-          type.definition = SchemaDocs.withoutGenerics(type.definition, generics);
-        if (type.includes)
-          type.includes = type.includes.map((name) => SchemaDocs.withoutGenerics(name, generics));
-        for (const field of type.fields)
-          field.type = SchemaDocs.withoutGenerics(field.type, generics);
-      }
-    }
-    return parsed;
-  }
-}
-
-// src/studio/data.ts
-class StudioModel {
-  static build(devices, graph, texts) {
-    const owners = new Map;
-    for (const holder of Topology.holders(devices)) {
-      const key = Topology.keyOf(Address2.host(holder.address));
-      if (!owners.has(key))
-        owners.set(key, holder);
-    }
-    const attempt = (work, otherwise) => {
-      try {
-        return work();
-      } catch (error) {
-        return otherwise(error);
-      }
-    };
-    return {
-      graph,
-      devices,
-      ports: Object.fromEntries(devices.map((device) => [
-        device.name,
-        attempt(() => Catalog.ports(device.platform, device.model), () => [])
-      ])),
-      rendered: Object.fromEntries(devices.map((device) => [
-        device.name,
-        attempt(() => texts.render(device), (error) => `Cannot be rendered: ${error.message}`)
-      ])),
-      snapshots: Object.fromEntries(devices.flatMap((device) => {
-        const text = texts.snapshot(device);
-        return text === undefined ? [] : [[device.name, text]];
-      })),
-      files: Object.fromEntries(devices.map((device) => [device.name, texts.files(device)])),
-      addresses: AddressSpace.report(devices),
-      sessions: StudioModel.sessionsOf(devices, owners),
-      cables: StudioModel.cablesOf(devices),
-      docs: StudioModel.schemaDocs()
-    };
-  }
-  static packageRoot() {
-    let directory = dirname(fileURLToPath(import.meta.url));
-    while (true) {
-      const manifest = join(directory, "package.json");
-      if (existsSync(manifest) && JSON.parse(readFileSync(manifest, "utf8")).name === "@takodotid/circuit")
-        return directory;
-      const parent = dirname(directory);
-      if (parent === directory)
-        return;
-      directory = parent;
-    }
-  }
-  static sessionsOf(devices, owners) {
-    const all = devices.flatMap((device) => {
-      const bgp = device.routing?.bgp;
-      return Object.entries(bgp?.neighbors ?? {}).map(([name, neighbor]) => {
-        const group = neighbor.group ? bgp?.groups?.[neighbor.group] : undefined;
-        const settings = { ...group, ...neighbor };
-        return {
-          deviceObject: device,
-          device: device.name,
-          name,
-          address: neighbor.address,
-          group: neighbor.group,
-          remoteAs: settings.remote_as,
-          role: settings.role,
-          import: settings.import,
-          export: settings.export,
-          description: settings.description
-        };
-      });
-    });
-    const ownerOf = (address) => owners.get(Topology.keyOf(address) ?? "")?.device;
-    return all.map(({ deviceObject, ...session }) => {
-      const far = ownerOf(session.address);
-      if (far && far !== deviceObject) {
-        const back = all.some((other) => other.deviceObject === far && ownerOf(other.address) === deviceObject && Address2.family(other.address) === Address2.family(session.address));
-        return { ...session, far: far.name, ...back ? {} : { oneSided: true } };
-      }
-      return { ...session, ...session.remoteAs ? { far: `AS${session.remoteAs}` } : {} };
-    });
-  }
-  static cablesOf(devices) {
-    const byName = new Map(devices.map((device) => [device.name, device]));
-    const drawn = new Set;
-    const cables = [];
-    const vlansOf = (device, portName) => {
-      const port = device.ports?.[portName];
-      const lag = port?.lag ? device.interfaces?.[port.lag] : undefined;
-      const carrier = lag?.type === "lag" ? lag : port;
-      const names = [carrier?.access_vlan, carrier?.native_vlan, ...carrier?.trunk_vlans ?? []].filter((name) => name !== undefined);
-      return [...new Set(names)].map((name) => `${name} (${device.vlans?.[name]?.id ?? "?"})`);
-    };
-    for (const device of devices) {
-      for (const [portName, port] of Object.entries(device.ports ?? {})) {
-        const link = port?.link;
-        if (!port || !link)
-          continue;
-        const here = `${device.name} ${portName}`;
-        const there = `${link.device} ${link.port}`;
-        if (drawn.has(`${there}|${here}`))
-          continue;
-        drawn.add(`${here}|${there}`);
-        const farPort = byName.get(link.device)?.ports?.[link.port];
-        const linksBack = farPort?.link?.device === device.name && farPort.link.port === portName;
-        cables.push({
-          device: device.name,
-          port: portName,
-          farDevice: link.device,
-          farPort: link.port,
-          ...port.lag ? { lag: port.lag } : {},
-          ...farPort?.lag ? { farLag: farPort.lag } : {},
-          ...port.description ? { description: port.description } : {},
-          ...link.through ? { through: link.through } : {},
-          vlans: vlansOf(device, portName),
-          ...linksBack ? {} : { oneSided: true }
-        });
-      }
-    }
-    return cables;
-  }
-  static schemaDocs() {
-    const root = StudioModel.packageRoot();
-    if (!root)
-      return {};
-    const sources = SchemaDocs.FILES.map(([file]) => readFileSync(join(root, "src", "schema", file), "utf8"));
-    const docs = {};
-    for (const type of SchemaDocs.read(sources).flat()) {
-      docs[type.name] = {
-        description: type.description,
-        includes: (type.includes ?? []).map((name) => name.replace(/<.*$/, "")),
-        fields: Object.fromEntries(type.fields.map((field) => [field.path.replace(/\?$/, ""), { type: field.type, description: field.description }]))
-      };
-    }
-    return docs;
-  }
-}
-
-export { Topology, AddressSpace, StudioModel };