@takodotid/circuit 0.34.2 → 0.35.0

package/dist/chunks/index-47debt16.js

@@ -1,956 +0,0 @@
-import {
-  familyOf2,
-  parse,
-  split,
-  isAddress2,
-  isCidr2,
-  network,
-  contains2,
-  formatAddress,
-  rangeOf,
-  prefixesBetween,
-  host2
-} from "./index-v8zgr7wm.js";
-
-// src/adapters/devices/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/adapters/devices/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/adapters/devices/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/adapters/devices/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}" }
-  }
-};
-
-// src/adapters/devices/vrp/models.ts
-var models5 = {
-  "CE6855-48S6Q-HI": { ports: { "10g": 48, "40g": 6 }, spelling: { "10g": "10GE1/0/{n}", "40g": "40GE1/0/{n}" } }
-};
-
-// src/adapters/devices/catalog.ts
-var catalog = { routeros: models4, vrp: models5, "raisecom-ros": models3, junos: models2, fortios: models };
-function portsOf(platform, model) {
-  const spec = catalog[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}`));
-}
-function spell(platform, model, port) {
-  const spec = catalog[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/graph.ts
-var LAYERS = ["l1", "l2", "l3", "bgp", "ospf", "tunnels"];
-var deviceId = (name) => `device:${name}`;
-function keyOf(address) {
-  if (!address || !isAddress2(address))
-    return;
-  return `${familyOf2(address)}:${parse(address)}`;
-}
-var isHostRoute = (cidr) => {
-  const { len, family } = split(cidr);
-  return len === (family === "ipv4" ? 32 : 128);
-};
-
-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;
-  }
-}
-function routedOf(device) {
-  const ports = Object.entries(device.ports ?? {}).flatMap(([name, port]) => port ? [[name, port]] : []);
-  const interfaces = Object.entries(device.interfaces ?? {});
-  return [...ports, ...interfaces];
-}
-function holdersOf(devices) {
-  return devices.flatMap((device) => routedOf(device).flatMap(([name, settings]) => (settings.addresses ?? []).flatMap((entry) => {
-    const address = typeof entry === "string" ? entry : entry.address;
-    if (!isCidr2(address))
-      return [];
-    const peer = typeof entry === "string" ? undefined : entry.peer;
-    return [{ device, name, address, peer, vrrp: settings.vrrp ?? [], vrf: settings.vrf }];
-  })));
-}
-function describeDevice(device) {
-  const addresses = 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
-  ];
-}
-function 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);
-}
-function 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`;
-}
-function 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 ? 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: 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 = carriedBy(device, carrier);
-      if (!vlans.length)
-        continue;
-      graph.edge({
-        layer: "l2",
-        from: deviceId(device.name),
-        to,
-        label: vlanLabel(vlans),
-        detail: [
-          `${device.name} ${lag ?? portName}`,
-          ...vlans.map((vlan) => `${vlan.name}, VLAN ${vlan.id}${vlan.untagged ? ", untagged" : ""}`)
-        ],
-        vlans,
-        ...linksBack ? {} : { oneSided: true }
-      });
-    }
-  }
-}
-function segments(holders, owners, graph) {
-  const bySegment = new Map;
-  const pairs = new Set;
-  for (const holder of holders) {
-    if (holder.peer) {
-      const far = owners.get(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: deviceId(holder.device.name),
-        to: deviceId(far.device.name),
-        label: `${host2(holder.address)} to ${host2(far.address)}`,
-        detail: [`${holder.device.name} ${holder.name} ${holder.address}`, `${far.device.name} ${far.name} ${far.address}`]
-      });
-      continue;
-    }
-    if (isHostRoute(holder.address))
-      continue;
-    const segment = network(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: deviceId(a.device.name),
-        to: 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: deviceId(member.device.name),
-        to: id,
-        label: `${member.name} ${host2(member.address)}`,
-        detail: [`${member.device.name} ${member.name} ${member.address}`]
-      });
-    }
-  }
-}
-function 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(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 && familyOf2(other.address) === familyOf2(session.address));
-      if (back)
-        paired.add(back);
-      graph.edge({
-        layer: "bgp",
-        from: deviceId(session.device.name),
-        to: 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: 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 } : {}
-    });
-  }
-}
-function 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 (!isCidr2(address) || isHostRoute(address))
-            continue;
-          const key = `${area} ${network(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: deviceId(a.device.name),
-          to: deviceId(b.device.name),
-          label: `area ${area}`,
-          detail: [a.line, b.line]
-        });
-      }
-    }
-  }
-}
-var endpointHost = (endpoint) => endpoint.replace(/:\d+$/, "").replace(/^\[(.*)\]$/, "$1");
-function 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) => keyOf(a) !== undefined && keyOf(a) === 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: deviceId(end.device.name),
-        to: deviceId(mirror.device.name),
-        label: `${kind} ${end.name} to ${mirror.name}`,
-        detail: [describe(end), describe(mirror)]
-      });
-      continue;
-    }
-    const owner = owners.get(keyOf(end.iface.remote) ?? "")?.device;
-    if (owner && owner !== end.device) {
-      graph.edge({
-        layer: "tunnels",
-        from: deviceId(end.device.name),
-        to: 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: deviceId(end.device.name),
-      to: outside,
-      label: `${kind} ${end.name}`,
-      detail: [describe(end)]
-    });
-  }
-  wireguard(devices, owners, graph);
-}
-function 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) => host2(typeof entry === "string" ? entry : entry.address));
-    const sendsFrom = tunnelAddresses.some((address) => isAddress2(address) && peer.allowed_addresses.some((allowed) => isCidr2(allowed) && contains2(allowed, address)));
-    const endpoint = peer.endpoint ? endpointHost(peer.endpoint) : undefined;
-    const isEndpoint = endpoint !== undefined && owners.get(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: deviceId(device.name),
-          to: 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 = endpointHost(peer.endpoint);
-      const outside = graph.node(`address:${endpoint}`, "outside", peer.name, [`WireGuard endpoint ${peer.endpoint}`]);
-      graph.edge({
-        layer: "tunnels",
-        from: 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: deviceId(device.name),
-      to: outside,
-      label: `WireGuard ${name}`,
-      detail: [`peers that dial in to ${device.name} ${name}`]
-    });
-  }
-}
-function graphOf(devices) {
-  const graph = new Builder;
-  for (const device of devices)
-    graph.node(deviceId(device.name), "device", device.name, describeDevice(device));
-  const holders = holdersOf(devices);
-  const owners = new Map;
-  for (const holder of holders) {
-    const key = keyOf(host2(holder.address));
-    if (!owners.has(key))
-      owners.set(key, holder);
-  }
-  cables(devices, graph);
-  segments(holders, owners, graph);
-  sessions(devices, owners, graph);
-  adjacencies(devices, graph);
-  tunnels(devices, owners, graph);
-  return { nodes: [...graph.nodes.values()], edges: graph.edges };
-}
-function only(graph, layers, deviceNames = []) {
-  const named = new Set(deviceNames.map(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/addresses.ts
-var bits = (family) => family === "ipv4" ? 32 : 128;
-var isHostRoute2 = (cidr) => split(cidr).len === bits(split(cidr).family);
-var numberOf = (address) => parse(address);
-function usable(prefix) {
-  const { first, last, family } = rangeOf(prefix);
-  const { len } = 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 };
-}
-function 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;
-}
-function gaps(within, taken) {
-  const result = [];
-  let cursor = within.first;
-  for (const range of 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;
-}
-function 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}`;
-}
-var byAddress = (a, b) => {
-  const first = (use) => numberOf(use.address.split("-")[0]);
-  return first(a) < first(b) ? -1 : first(a) > first(b) ? 1 : 0;
-};
-function comparePrefixes(a, b) {
-  const [ra, rb] = [rangeOf(a), rangeOf(b)];
-  if (ra.family !== rb.family)
-    return ra.family === "ipv4" ? -1 : 1;
-  return ra.first < rb.first ? -1 : ra.first > rb.first ? 1 : 0;
-}
-var byPrefix = (a, b) => comparePrefixes(a.prefix, b.prefix);
-function addressesOf(devices, within) {
-  const segments = new Map;
-  const blocks = [];
-  const segmentOf = (address) => [...segments.keys()].find((prefix) => contains2(prefix, address));
-  for (const holder of holdersOf(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 (isHostRoute2(holder.address) || holder.peer) {
-      blocks.push({ prefix: `${host2(holder.address)}/${bits(familyOf2(holder.address))}`, what });
-      continue;
-    }
-    const prefix = network(holder.address);
-    const segment = segments.get(prefix) ?? { uses: [], taken: [] };
-    const value = numberOf(host2(holder.address));
-    segment.uses.push({ address: host2(holder.address), what });
-    segment.taken.push({ first: value, last: value });
-    segments.set(prefix, segment);
-    for (const group of holder.vrrp) {
-      if (!isAddress2(group.address) || !contains2(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: numberOf(group.address), last: 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: numberOf(first), last: numberOf(last) });
-    return true;
-  };
-  for (const device of devices) {
-    for (const [name, server] of Object.entries(device.dhcp ?? {})) {
-      const [start, end] = server.pool;
-      if (isAddress2(start) && isAddress2(end))
-        take(`${start}-${end}`, `DHCP pool ${name} on ${device.name}`, start, end);
-      for (const reservation of server.reservations ?? []) {
-        if (isAddress2(reservation.address))
-          take(reservation.address, `reserved for ${reservation.description ?? reservation.mac} by ${device.name}`);
-      }
-    }
-    for (const route of device.routing?.static ?? []) {
-      if (route.via && isAddress2(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 (isAddress2(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 (!isCidr2(allowed))
-            continue;
-          const what = `WireGuard peer ${peer.name} on ${device.name} ${name}`;
-          if (isHostRoute2(allowed) && take(host2(allowed), what))
-            continue;
-          if (!segmentOf(host2(allowed)))
-            blocks.push({ prefix: network(allowed), what });
-        }
-      }
-    }
-  }
-  const owners = new Map;
-  for (const device of devices) {
-    for (const prefix of device.routing?.bgp?.networks ?? []) {
-      if (!isCidr2(prefix))
-        continue;
-      owners.set(network(prefix), [...owners.get(network(prefix)) ?? [], device.name]);
-    }
-  }
-  for (const device of devices) {
-    for (const route of device.routing?.static ?? []) {
-      if (!isCidr2(route.prefix) || split(route.prefix).len === 0)
-        continue;
-      const overlapsSegment = [...segments.keys()].some((prefix) => contains2(route.prefix, prefix) || contains2(prefix, route.prefix));
-      const coversOwned = [...owners.keys()].some((owned) => contains2(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: network(route.prefix), what: `${how} by ${device.name}` });
-    }
-  }
-  const asked = within ? network(within) : undefined;
-  const spacePrefixes = asked ? [asked] : [...owners.keys()];
-  const spaceOf = (prefix) => spacePrefixes.filter((space) => contains2(space, prefix)).sort((a, b) => split(b).len - split(a).len)[0];
-  const toSegment = (prefix) => {
-    const { uses, taken } = segments.get(prefix);
-    const free = gaps(usable(prefix), taken);
-    const total = free.reduce((sum, range) => sum + range.last - range.first + 1n, 0n);
-    const family = familyOf2(prefix);
-    return {
-      prefix,
-      uses: uses.sort(byAddress),
-      free: count(total),
-      ...free[0] ? { next: formatAddress(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(comparePrefixes).map((space) => {
-    const inside = (prefix) => spaceOf(prefix) === space;
-    const spaceSegments = [...segments.keys()].filter(inside).sort(comparePrefixes);
-    const spaceBlocks = uniqueBlocks.filter((block) => inside(block.prefix)).sort(byPrefix);
-    const nested = spacePrefixes.filter((other) => other !== space && contains2(space, other));
-    const taken = [...spaceSegments, ...spaceBlocks.map((block) => block.prefix), ...nested].map((prefix) => rangeOf(prefix));
-    const family = familyOf2(space);
-    return {
-      prefix: space,
-      owner: asked && !owners.has(space) ? "asked for" : `originated by ${(owners.get(space) ?? []).join(", ")}`,
-      segments: spaceSegments.map(toSegment),
-      blocks: spaceBlocks,
-      free: gaps(rangeOf(space), taken).flatMap((range) => prefixesBetween(range.first, range.last, family))
-    };
-  });
-  const outside = (prefix) => !spaceOf(prefix);
-  return {
-    spaces,
-    elsewhere: asked ? { segments: [], blocks: [] } : {
-      segments: [...segments.keys()].filter(outside).sort(comparePrefixes).map(toSegment),
-      blocks: uniqueBlocks.filter((block) => outside(block.prefix)).sort(byPrefix)
-    }
-  };
-}
-function freeOfLength(free, length, limit) {
-  const prefixes = [];
-  let total = 0n;
-  for (const prefix of free) {
-    const { len, family } = split(prefix);
-    if (len > length || length > bits(family))
-      continue;
-    const { first } = rangeOf(prefix);
-    const step = 1n << BigInt(bits(family) - length);
-    const fits = 1n << BigInt(length - len);
-    total += fits;
-    for (let index = 0n;index < fits && prefixes.length < limit; index++) {
-      prefixes.push(`${formatAddress(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
-var SCHEMA_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"]
-];
-function commentText(lines) {
-  return lines.map((line) => line.replace(/^\s*\/\*\*\s?|\s*\*\/\s*$|^\s*\*\s?/g, "").trim()).filter(Boolean).join(" ");
-}
-var PARAMETER_MEANING = { Pl: "platform", M: "model" };
-function 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, (parameter) => PARAMETER_MEANING[parameter] ?? "name").replace(/\bname(?: \| name)+\b/g, "name").replace(/\(name\)/g, "name");
-}
-function parse2(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("{")) {
-      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: 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: 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;
-}
-function schemaTypes(sources) {
-  const generics = new Set;
-  const parsed = sources.map((source) => parse2(source, generics));
-  for (const types of parsed) {
-    for (const type of types) {
-      if (type.definition)
-        type.definition = withoutGenerics(type.definition, generics);
-      if (type.includes)
-        type.includes = type.includes.map((name) => withoutGenerics(name, generics));
-      for (const field of type.fields)
-        field.type = withoutGenerics(field.type, generics);
-    }
-  }
-  return parsed;
-}
-
-// src/studio/data.ts
-function 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(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 && familyOf2(other.address) === familyOf2(session.address));
-      return { ...session, far: far.name, ...back ? {} : { oneSided: true } };
-    }
-    return { ...session, ...session.remoteAs ? { far: `AS${session.remoteAs}` } : {} };
-  });
-}
-function 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;
-}
-function 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;
-  }
-}
-function schemaDocs() {
-  const root = packageRoot();
-  if (!root)
-    return {};
-  const sources = SCHEMA_FILES.map(([file]) => readFileSync(join(root, "src", "schema", file), "utf8"));
-  const docs = {};
-  for (const type of schemaTypes(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;
-}
-function studioData(devices, graph, texts) {
-  const owners = new Map;
-  for (const holder of holdersOf(devices)) {
-    const key = keyOf(host2(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(() => portsOf(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: addressesOf(devices),
-    sessions: sessionsOf(devices, owners),
-    cables: cablesOf(devices),
-    docs: schemaDocs()
-  };
-}
-
-export { portsOf, spell, LAYERS, deviceId, keyOf, holdersOf, graphOf, only, addressesOf, freeOfLength, packageRoot, studioData };