@takodotid/circuit 0.34.3 → 0.36.0

package/dist/chunks/index-2r4bbhac.js

@@ -0,0 +1,977 @@
+import {
+  Address2
+} from "./index-n7w3tg5y.js";
+
+// src/platforms/fortios/models.ts
+var models = {
+  "FG-3700D": {
+    ports: { "40g": 4, "10g": 28, "1g": 2 },
+    spelling: { "40g": "port{n}", "10g": "port{n+4}", "1g": "mgmt{n}" }
+  }
+};
+
+// src/platforms/junos/models.ts
+var models2 = {
+  "QFX5100-48S-6Q": {
+    ports: { "40g": 6, "10g": 48, "1g": 2 },
+    spelling: { "40g": "et-0/0/{n+47}", "10g": "xe-0/0/{n-1}", "1g": "em{n-1}" }
+  }
+};
+
+// src/platforms/raisecom-ros/models.ts
+var models3 = {
+  "RAX721-C-6C48": {
+    ports: { "100g": 6, "25g": 24, "10g": 24 },
+    spelling: { "100g": "hundredgige 1/1/{n}", "25g": "twenty-fivegige 1/2/{n}", "10g": "tengigabitethernet 1/3/{n}" }
+  }
+};
+
+// src/platforms/routeros/models.ts
+var models4 = {
+  "CCR2216-1G-12XS-2XQ": {
+    ports: { "100g": 2, "25g": 12, "1g": 1 },
+    spelling: { "100g": "qsfp28-{n}-1", "25g": "sfp28-{n}", "1g": "ether{n}" },
+    limits: { lag_members: 8, switch_port_ranges: 5 }
+  }
+};
+
+// src/platforms/vrp/models.ts
+var models5 = {
+  "CE6855-48S6Q-HI": { ports: { "10g": 48, "40g": 6 }, spelling: { "10g": "10GE1/0/{n}", "40g": "40GE1/0/{n}" } }
+};
+
+// src/platforms/catalog.ts
+class Catalog {
+  static MODELS = { routeros: models4, vrp: models5, "raisecom-ros": models3, junos: models2, fortios: models };
+  static ports(platform, model) {
+    const spec = Catalog.MODELS[platform]?.[model];
+    if (!spec)
+      throw new Error(`${platform} has no model ${model}`);
+    return Object.entries(spec.ports).flatMap(([speed, count]) => Array.from({ length: count }, (_, i) => `${speed}-${i + 1}`));
+  }
+  static limits(platform, model) {
+    const spec = Catalog.MODELS[platform]?.[model];
+    return spec?.limits ?? {};
+  }
+  static spell(platform, model, port) {
+    const spec = Catalog.MODELS[platform]?.[model];
+    const parts = /^(\d+[gm])-(\d+)$/.exec(port);
+    const template = parts && spec?.spelling[parts[1]];
+    if (!template)
+      throw new Error(`${model} has no port ${port}`);
+    return template.replace(/\{n([+-]\d+)?\}/, (_, shift) => String(Number(parts[2]) + Number(shift ?? 0)));
+  }
+}
+
+// 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 cableLine = `${here} to ${there}`;
+        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`;
+          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}`,
+          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 } : {},
+          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 { Catalog, Topology, AddressSpace, StudioModel };