@takodotid/circuit 0.38.0 → 0.40.0

package/dist/chunks/{index-yzw86rc8.js → index-k38bby43.js}

@@ -1,10 +1,68 @@
-import {
-  Catalog
-} from "./index-6wb41q67.js";
 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;
@@ -918,4 +976,4 @@ class StudioModel {
   }
 }
 
-export { Topology, AddressSpace, StudioModel };
+export { Catalog, Topology, AddressSpace, StudioModel };

package/dist/chunks/{server-cxr9ynxc.js → server-ggertnce.js}

@@ -1,6 +1,6 @@
 import {
   StudioModel
-} from "./index-yzw86rc8.js";
+} from "./index-k38bby43.js";
 
 // src/studio/server.ts
 import { execFile as execFile2, spawn } from "node:child_process";

package/dist/cli/index.js

@@ -4,13 +4,11 @@ import {
   Secrets2
 } from "../chunks/index-20kcjxjg.js";
 import {
+  Catalog,
   Topology,
   AddressSpace,
   StudioModel
-} from "../chunks/index-yzw86rc8.js";
-import {
-  Catalog
-} from "../chunks/index-6wb41q67.js";
+} from "../chunks/index-k38bby43.js";
 import {
   Address2
 } from "../chunks/index-n7w3tg5y.js";
@@ -544,6 +542,8 @@ class Derive {
     const has = (feature) => proved.includes(feature);
     if (routing?.bfd && !has("bfd-timers"))
       found.push(`routing.bfd, BFD timers are ${unproved}`);
+    if (device.vdoms && !has("management-vdom"))
+      found.push(`vdoms, a management VDOM is ${unproved}`);
     for (const route of routing?.static ?? []) {
       if (route.bfd && !has("static-route-bfd"))
         found.push(`routing.static ${route.prefix} bfd, BFD on a static route is ${unproved}`);
@@ -909,6 +909,11 @@ class FortiOsFirewall {
     const state = rule.match?.state;
     return rule.action === "accept" && state !== undefined && state.length > 0 && state.every((one) => one === "established" || one === "related");
   }
+  static managementOnly(root, device) {
+    const localIns = { ipv4: 0, ipv6: 0 };
+    const localInEntry = (family) => root.block(family === "ipv4" ? "firewall local-in-policy" : "firewall local-in-policy6").entry(++localIns[family]);
+    FortiOsFirewall.management(localInEntry, new Objects(root, device), device);
+  }
   static render(root, device) {
     const fw = device.firewall;
     const objects = new Objects(root, device);
@@ -2168,6 +2173,155 @@ class FortiOsPlan {
   }
 }
 
+// src/platforms/fortios/vdoms.ts
+class FortiOsVdoms {
+  static ROOT = "root";
+  static GLOBAL = new Set([
+    "vpn certificate local",
+    "vpn certificate ca",
+    "system global",
+    'system replacemsg admin "pre_admin-disclaimer-text"',
+    "system accprofile",
+    "system admin",
+    "system interface",
+    "system dns",
+    "system ntp",
+    "system snmp sysinfo",
+    "system snmp community",
+    "system snmp user",
+    "log disk setting",
+    ...["", "2", "3", "4"].flatMap((number) => [`log syslogd${number} setting`, `log syslogd${number} filter`]),
+    "system sflow",
+    "system netflow",
+    "system session-helper"
+  ]);
+  static MANAGEMENT_SECTIONS = [
+    "firewall address",
+    "firewall address6",
+    "firewall addrgrp",
+    "firewall addrgrp6",
+    "firewall service custom",
+    "router static",
+    "router static6",
+    "firewall local-in-policy",
+    "firewall local-in-policy6"
+  ];
+  static managementOf(device) {
+    return device.vdoms?.management.name;
+  }
+  static vdomOf(device, name) {
+    const management = device.vdoms?.management;
+    if (!management)
+      return FortiOsVdoms.ROOT;
+    const lag = device.ports?.[name]?.lag;
+    const holder = lag ?? name;
+    return management.interfaces.includes(holder) ? management.name : FortiOsVdoms.ROOT;
+  }
+  static key(vdom, section) {
+    return `@${vdom} ${section}`;
+  }
+  static scopeOf(key) {
+    const named = /^@(\S+) (.+)$/.exec(key);
+    if (named)
+      return { scope: { kind: "vdom", vdom: named[1] }, section: named[2] };
+    return FortiOsVdoms.GLOBAL.has(key) ? { scope: { kind: "global" }, section: key } : { scope: { kind: "vdom", vdom: FortiOsVdoms.ROOT }, section: key };
+  }
+  static isMulti(tree) {
+    return tree.blocks.get("system global")?.settings.get("vdom-mode") === "multi-vdom";
+  }
+  static wrap(scope, lines) {
+    return scope.kind === "global" ? ["config global", ...lines, "end"] : ["config vdom", `edit ${scope.vdom}`, ...lines, "next", "end"];
+  }
+  static named(vdom, text) {
+    return text.replace(/^config /gm, `config @${vdom} `);
+  }
+  static listed(text) {
+    return [...text.matchAll(/^name=([^/\s]+)\//gm)].map((match) => match[1]);
+  }
+  static plan(desired, current, planOne) {
+    const want = FortiOsTree.parse(desired);
+    const have = FortiOsTree.parse(current);
+    const wantMulti = FortiOsVdoms.isMulti(want);
+    const haveMulti = FortiOsVdoms.isMulti(have);
+    const refused = (problem) => ({ steps: [], problems: [problem] });
+    if (wantMulti && !haveMulti) {
+      return refused("the config has vdoms and the device runs one VDOM. Turn multi-VDOM mode on by hand, on the console: `config system global`, `set vdom-mode multi-vdom`, `end`. It moves everything into root and ends every session");
+    }
+    if (!wantMulti && haveMulti) {
+      return refused("the device runs several VDOMs and the config has no vdoms. Write vdoms.management, or turn multi-VDOM mode off by hand");
+    }
+    if (!wantMulti)
+      return planOne(desired, current);
+    const moved = FortiOsVdoms.moved(want, have);
+    if (moved.length) {
+      return refused(`${moved.map(({ name, from, to }) => `${name} from ${from} to ${to}`).join(", ")}: move an interface into another VDOM by hand, on the console, since it may carry the way in`);
+    }
+    const scopes = new Map;
+    const scopeFor = (scope) => {
+      const name = scope.kind === "global" ? "" : scope.vdom;
+      if (!scopes.has(name))
+        scopes.set(name, { scope, want: new FortiOsBlock, have: new FortiOsBlock });
+      return scopes.get(name);
+    };
+    for (const [side, tree] of [
+      ["want", want],
+      ["have", have]
+    ]) {
+      for (const [key, block] of tree.blocks) {
+        const { scope, section } = FortiOsVdoms.scopeOf(key);
+        scopeFor(scope)[side].blocks.set(section, block);
+      }
+    }
+    const global = scopes.get("");
+    const globalPlan = global ? planOne(FortiOsTree.print(global.want), FortiOsTree.print(global.have)) : { steps: [], problems: [] };
+    const inScope = (scope, step) => ({ ...step, send: FortiOsVdoms.wrap(scope, step.send) });
+    const removal = (step) => step.title.endsWith(", removed");
+    const vdomPlans = [...scopes.values()].filter(({ scope }) => scope.kind === "vdom").map(({ scope, want: wanted, have: had }) => ({ scope, plan: planOne(FortiOsTree.print(wanted), FortiOsTree.print(had)) }));
+    const vdomSteps = vdomPlans.flatMap(({ scope, plan }) => plan.steps.map((step) => inScope(scope, { ...step, title: `${scope.kind === "vdom" ? scope.vdom : ""}: ${step.title}` })));
+    return {
+      problems: [...globalPlan.problems, ...vdomPlans.flatMap(({ plan }) => plan.problems)],
+      steps: [
+        ...globalPlan.steps.filter((step) => !removal(step)).map((step) => inScope({ kind: "global" }, step)),
+        ...vdomSteps,
+        ...globalPlan.steps.filter(removal).map((step) => inScope({ kind: "global" }, step))
+      ]
+    };
+  }
+  static moved(want, have) {
+    const wanted = want.blocks.get("system interface");
+    const had = have.blocks.get("system interface");
+    if (!wanted || !had)
+      return [];
+    return [...wanted.entries.entries()].flatMap(([name, { block }]) => {
+      const from = had.entries.get(name)?.block.settings.get("vdom");
+      const to = block.settings.get("vdom");
+      return from && to && FortiOsTree.bare(from) !== FortiOsTree.bare(to) ? [{ name, from: FortiOsTree.bare(from), to: FortiOsTree.bare(to) }] : [];
+    });
+  }
+  static gaps(device) {
+    if (!device.vdoms)
+      return [];
+    const found = [];
+    const tunnels = Object.entries(device.interfaces ?? {}).filter(([, iface]) => iface.type === "gre" || iface.type === "vxlan");
+    if (tunnels.length)
+      found.push(`vdoms with GRE or VXLAN tunnels (${tunnels.map(([name]) => name).join(", ")}), whose tables belong to a VDOM`);
+    if (Object.values(device.interfaces ?? {}).some((iface) => iface.type === "bridge"))
+      found.push("vdoms with a bridge, which needs transparent mode");
+    const management = device.vdoms.management;
+    const inManagement = (name) => name !== undefined && management.interfaces.includes(name);
+    for (const route of device.routing?.static ?? []) {
+      if (inManagement(route.interface))
+        found.push(`routing.static ${route.prefix} leaves through ${route.interface}, in vdoms.management; write it there`);
+    }
+    for (const name of management.interfaces) {
+      const settings = device.interfaces?.[name] ?? device.ports?.[name];
+      if (settings && "vrf" in settings && settings.vrf)
+        found.push(`vdoms.management interface ${name} in VRF ${settings.vrf}`);
+    }
+    return found;
+  }
+}
+
 // src/platforms/fortios/render.ts
 class FortiOsRender {
   static BANNER = 'system replacemsg admin "pre_admin-disclaimer-text"';
@@ -2410,8 +2564,24 @@ class FortiOsRender {
     FortiOsRouting.render(root, device);
     FortiOsRender.helpers(section("system session-helper"), device);
     FortiOsFirewall.render(root, device);
+    FortiOsRender.managementVdom(root, device);
     return FortiOsTree.print(root);
   }
+  static managementVdom(root, device) {
+    const management = device.vdoms?.management;
+    if (!management)
+      return;
+    const vdom = new FortiOsBlock;
+    for (const section of FortiOsVdoms.MANAGEMENT_SECTIONS)
+      vdom.block(section);
+    FortiOsRender.staticRoutes(vdom.block("router static"), vdom.block("router static6"), {
+      ...device,
+      routing: { static: management.static ?? [] }
+    });
+    FortiOsFirewall.managementOnly(vdom, device);
+    for (const [section, block] of vdom.blocks)
+      root.blocks.set(FortiOsVdoms.key(management.name, section), block);
+  }
   static certificates(local, trusted, device) {
     for (const [name, certificate] of Object.entries(device.certificates ?? {})) {
       const text = FortiOsTree.quote(certificate.certificate.trim());
@@ -2447,6 +2617,9 @@ class FortiOsRender {
       block.set("pre-login-banner", "enable");
     if (device.lldp === true)
       block.set("lldp-transmission", "enable").set("lldp-reception", "enable");
+    const vdom = FortiOsVdoms.managementOf(device);
+    if (vdom)
+      block.set("vdom-mode", "multi-vdom").set("management-vdom", FortiOsTree.quote(vdom));
   }
   static users(profiles, admins, device) {
     const roles = new Set(Object.values(device.users ?? {}).map((user) => user.role));
@@ -2473,7 +2646,7 @@ class FortiOsRender {
     for (const port of Catalog.ports(device.platform, device.model)) {
       const settings = device.ports?.[port];
       const entry = block.entry(Catalog.spell(device.platform, device.model, port));
-      entry.set("vdom", FortiOsTree.quote("root"));
+      entry.set("vdom", FortiOsTree.quote(FortiOsVdoms.vdomOf(device, port)));
       entry.set("type", "physical");
       if (!settings) {
         FortiOsRender.redirects(entry, device);
@@ -2497,7 +2670,7 @@ class FortiOsRender {
         continue;
       const members = Object.entries(device.ports ?? {}).filter(([, port]) => port?.lag === name).map(([port]) => Catalog.spell(device.platform, device.model, port));
       const entry = block.entry(name);
-      entry.set("vdom", FortiOsTree.quote("root"));
+      entry.set("vdom", FortiOsTree.quote(FortiOsVdoms.vdomOf(device, name)));
       entry.set("type", "aggregate");
       if (members.length)
         entry.set("member", FortiOsTree.quoteAll(members));
@@ -2515,7 +2688,7 @@ class FortiOsRender {
         continue;
       const parent = FortiOsRender.vlanParent(device, iface.vlan);
       const entry = block.entry(name);
-      entry.set("vdom", FortiOsTree.quote("root"));
+      entry.set("vdom", FortiOsTree.quote(FortiOsVdoms.vdomOf(device, name)));
       if (parent)
         entry.set("interface", FortiOsTree.quote(FortiOsNames.nameOf(device, parent)));
       entry.set("vlanid", device.vlans?.[iface.vlan]?.id ?? 0);
@@ -2533,7 +2706,7 @@ class FortiOsRender {
       if (iface.type !== "loopback")
         continue;
       const entry = block.entry(name);
-      entry.set("vdom", FortiOsTree.quote("root"));
+      entry.set("vdom", FortiOsTree.quote(FortiOsVdoms.vdomOf(device, name)));
       entry.set("type", "loopback");
       if (iface.description)
         entry.set("description", FortiOsTree.quote(iface.description));
@@ -2562,7 +2735,7 @@ class FortiOsRender {
           tunnel.set("dstport", iface.port);
       }
       const entry = block.entry(name);
-      entry.set("vdom", FortiOsTree.quote("root"));
+      entry.set("vdom", FortiOsTree.quote(FortiOsVdoms.vdomOf(device, name)));
       entry.set("type", iface.type === "gre" ? "tunnel" : "vxlan");
       entry.set("interface", via);
       if (iface.type === "vxlan" && iface.mac)
@@ -2951,6 +3124,7 @@ class FortiOs extends Platform {
     if (device.stp)
       found.push("stp, ports are routed");
     found.push(...FortiOs.transparentGaps(device));
+    found.push(...FortiOsVdoms.gaps(device));
     for (const [name, iface] of Object.entries(device.interfaces ?? {})) {
       if (iface.type === "vlan" && iface.mac)
         found.push(`interfaces.${name}.mac, which only RouterOS sets for now`);
@@ -2973,7 +3147,8 @@ class FortiOs extends Platform {
   neighbors(device, _network = [], options = {}) {
     return FortiOs.withCli(device, async (cli) => {
       await FortiOs.checkVersion(cli, device);
-      return FortiOs.neighborsOf(await cli.run("diagnose lldprx neighbor details"), device);
+      const details = await FortiOs.inGlobal(cli, device, () => cli.run("diagnose lldprx neighbor details"));
+      return FortiOs.neighborsOf(details, device);
     }, options);
   }
   static neighborsOf(text, device) {
@@ -2996,14 +3171,14 @@ class FortiOs extends Platform {
     return found;
   }
   plan(desired, current, options) {
-    return FortiOsPlan.of(desired, current, options);
+    return FortiOsVdoms.plan(desired, current, (want, have) => FortiOsPlan.of(want, have, options));
   }
   async apply(device, network, changes, options) {
     await FortiOs.applyOnce(device, changes, options);
     const switched = changes.steps.some((step) => step.send.some((line) => line.startsWith("set opmode ")));
     if (!switched)
       return;
-    const again = FortiOsPlan.of(FortiOsRender.of(device), await this.read(device, network, options), options);
+    const again = this.plan(FortiOsRender.of(device), await this.read(device, network, options), options);
     if (!again.steps.length)
       return;
     console.log("  the operation mode changed; applying what it added on its own");
@@ -3012,7 +3187,8 @@ class FortiOs extends Platform {
   async fill(device, _network, set, family, prefixes) {
     await FortiOs.withCli(device, async (cli) => {
       await FortiOs.checkVersion(cli, device);
-      for (const line of FortiOs.fillLines(set, family, prefixes)) {
+      const lines = FortiOs.fillLines(set, family, prefixes);
+      for (const line of device.vdoms ? FortiOsVdoms.wrap({ kind: "vdom", vdom: FortiOsVdoms.ROOT }, lines) : lines) {
         let answer = await cli.run(line);
         if (FortiOsCli.QUESTION.test(cli.prompt) && line === "purge")
           answer = await cli.answer("y");
@@ -3145,6 +3321,18 @@ class FortiOs extends Platform {
     if (`${version[1]}.${version[2]}` !== FortiOs.SUPPORTED) {
       throw new Error(`${device.name} runs FortiOS ${version[1]}.${version[2]}.${version[3]}; this adapter renders for FortiOS ${FortiOs.SUPPORTED}`);
     }
+    return status;
+  }
+  static async inGlobal(cli, device, work) {
+    const multi = typeof device === "boolean" ? device : Boolean(device.vdoms);
+    if (!multi)
+      return work();
+    await cli.run("config global");
+    try {
+      return await work();
+    } finally {
+      await FortiOs.leave(cli);
+    }
   }
   static scrub(text) {
     const root = FortiOsTree.parse(text);
@@ -3168,11 +3356,14 @@ class FortiOs extends Platform {
     return FortiOsTree.print(root);
   }
   static async readConfig(cli, device) {
-    await FortiOs.checkVersion(cli, device);
+    const status = await FortiOs.checkVersion(cli, device);
+    const show = (section) => cli.run(`${FortiOsRender.FULL.includes(section) ? "show full-configuration" : "show"} ${section}`, 120000);
     const parts = [];
-    for (const section of FortiOsRender.SECTIONS) {
-      const show = FortiOsRender.FULL.includes(section) ? "show full-configuration" : "show";
-      parts.push(await cli.run(`${show} ${section}`, 120000));
+    if (/^Virtual domain configuration: (multiple|split-task)/m.test(status)) {
+      parts.push(...await FortiOs.readVdoms(cli, device, show));
+    } else {
+      for (const section of FortiOsRender.SECTIONS)
+        parts.push(await show(section));
     }
     const text = parts.join(`
 `);
@@ -3180,26 +3371,53 @@ class FortiOs extends Platform {
       throw new Error(`${device.name} returned no configuration`);
     return FortiOs.scrub(FortiOsPlan.clean(text));
   }
+  static async readVdoms(cli, device, show) {
+    const management = FortiOsVdoms.managementOf(device);
+    if (!management)
+      throw new Error(`${device.name} runs several VDOMs and its config has no vdoms; write vdoms.management`);
+    const parts = [];
+    const inVdom = async (vdom, sections) => {
+      await cli.run("config vdom");
+      await cli.run(`edit ${vdom}`);
+      try {
+        for (const section of sections) {
+          const text = await show(section);
+          parts.push(vdom === FortiOsVdoms.ROOT ? text : FortiOsVdoms.named(vdom, text));
+        }
+      } finally {
+        await FortiOs.leave(cli);
+      }
+    };
+    const listed = await FortiOs.inGlobal(cli, true, async () => {
+      for (const section of FortiOsRender.SECTIONS.filter((one) => FortiOsVdoms.GLOBAL.has(one)))
+        parts.push(await show(section));
+      return FortiOsVdoms.listed(await cli.run("diagnose sys vd list"));
+    });
+    await inVdom(FortiOsVdoms.ROOT, FortiOsRender.SECTIONS.filter((one) => !FortiOsVdoms.GLOBAL.has(one)));
+    if (listed.includes(management))
+      await inVdom(management, FortiOsVdoms.MANAGEMENT_SECTIONS);
+    return parts;
+  }
   static async leave(cli) {
     for (let level = 0;level < 10 && /\(.*\) [#$] $/.test(cli.prompt); level++)
       await cli.run("end");
   }
-  static async saving(cli, mode, seconds) {
+  static async saving(cli, mode, multi, seconds) {
     const lines = ["config system global", `set cfg-save ${mode}`, ...seconds ? [`set cfg-revert-timeout ${seconds}`] : [], "end"];
-    for (const line of lines) {
+    for (const line of multi ? FortiOsVdoms.wrap({ kind: "global" }, lines) : lines) {
       const answer = await cli.run(line);
       if (FortiOs.REFUSED.test(answer))
         throw new Error(`the device refused ${line}: ${answer.trim().slice(0, 300)}`);
     }
   }
-  static async configure(cli, plan, guard) {
+  static async configure(cli, plan, guard, multi) {
     const minutes = guard.seconds / 60;
-    await FortiOs.saving(cli, "revert", guard.seconds);
+    await FortiOs.saving(cli, "revert", multi, guard.seconds);
     const restore = async (reason) => {
       await FortiOs.leave(cli).catch(() => {
         return;
       });
-      await cli.run("execute cfg reload").catch(() => {
+      await FortiOs.inGlobal(cli, multi, () => cli.run("execute cfg reload")).catch(() => {
         return;
       });
       return new Reloaded(`${reason}
@@ -3233,27 +3451,28 @@ class FortiOs extends Platform {
     } catch (error) {
       throw await restore(`a fresh login failed: ${error.message}`);
     }
-    const saved = await cli.run("execute cfg save", 120000);
+    const saved = await FortiOs.inGlobal(cli, multi, () => cli.run("execute cfg save", 120000));
     if (!/config saved|no config to be saved/.test(saved)) {
       throw new Error(`access was proved but the save failed; the device reverts in ${minutes} minutes:
     ${saved.trim().slice(0, 300)}`);
     }
-    await FortiOs.saving(cli, "automatic");
+    await FortiOs.saving(cli, "automatic", multi);
     console.log("  logged in again, saved");
   }
   static async settle(device, options) {
     for (let attempt = 0;attempt < FortiOs.RELOAD.attempts; attempt++) {
       await new Promise((done) => setTimeout(done, FortiOs.RELOAD.interval));
       const settled = await FortiOs.withCli(device, async (cli) => {
-        if (!/no config to be reloaded/.test(await cli.run("execute cfg reload")))
+        const reloaded = await FortiOs.inGlobal(cli, device, () => cli.run("execute cfg reload"));
+        if (!/no config to be reloaded/.test(reloaded))
           return false;
-        await FortiOs.saving(cli, "automatic");
+        await FortiOs.saving(cli, "automatic", Boolean(device.vdoms));
         return true;
       }, options).catch(() => false);
       if (settled)
         return "the device is back and saves changes on its own again";
     }
-    return "the device did not come back in time and still reverts every change; set `cfg-save automatic` under `config system global`";
+    return "the device did not come back in time and still reverts every change; set `cfg-save automatic` under `config system global` (in `config global` on a device with VDOMs)";
   }
   static async applyOnce(device, plan, options) {
     const seconds = options.rollback * 60;
@@ -3261,7 +3480,7 @@ class FortiOs extends Platform {
       if (options.console) {
         await FortiOs.consoleSession(device, async (cli, relogin) => {
           await FortiOs.checkVersion(cli, device);
-          await FortiOs.configure(cli, plan, { seconds, prove: relogin });
+          await FortiOs.configure(cli, plan, { seconds, prove: relogin }, Boolean(device.vdoms));
         });
         return;
       }
@@ -3273,7 +3492,7 @@ class FortiOs extends Platform {
             const proof = await FortiOs.login(device);
             proof.end();
           }
-        });
+        }, Boolean(device.vdoms));
       });
     } catch (error) {
       if (!(error instanceof Reloaded))
@@ -3750,6 +3969,28 @@ class Cabling {
     }
     return findings;
   }
+  static describeLinks(devices) {
+    const byName = new Map(devices.map((device) => [device.name, device]));
+    return devices.map((device) => {
+      const ports = Object.entries(device.ports ?? {});
+      if (!ports.some(([, port]) => port?.link && port.description === undefined))
+        return device;
+      const described = ports.map(([name, port]) => {
+        const far = port?.link ? byName.get(port.link.device) : undefined;
+        if (!port?.link || port.description !== undefined || !far)
+          return [name, port];
+        return [name, { ...port, description: `${far.name} ${Cabling.labelOf(far, port.link.port)}` }];
+      });
+      return { ...device, ports: Object.fromEntries(described) };
+    });
+  }
+  static labelOf(device, port) {
+    try {
+      return Catalog.spell(device.platform, device.model, port);
+    } catch {
+      return port;
+    }
+  }
   static isDevice(system, name) {
     return system === name || system.startsWith(`${name}.`);
   }
@@ -7881,9 +8122,23 @@ class RouterOsRender {
   }
   untracked(family) {
     const menu = family === "ipv4" ? "/ip firewall raw" : "/ipv6 firewall raw";
-    for (const prefix of this.device.firewall?.untracked ?? []) {
-      if (Address2.family(prefix) !== family)
+    const untracked = (this.device.firewall?.untracked ?? []).filter((prefix) => Address2.family(prefix) === family);
+    for (const address of RouterOsRender.natAddresses(this.device)) {
+      if (Address2.family(address) !== family || !untracked.some((prefix) => Address2.contains(prefix, address)))
         continue;
+      for (const [direction, property] of [
+        ["to", "dst-address"],
+        ["from", "src-address"]
+      ]) {
+        this.add(menu, "add", {
+          action: "accept",
+          chain: "prerouting",
+          comment: `Tracked for NAT, ${direction} ${address}`,
+          [property]: address
+        });
+      }
+    }
+    for (const prefix of untracked) {
       for (const [direction, property] of [
         ["to", "dst-address"],
         ["from", "src-address"]
@@ -7897,6 +8152,17 @@ class RouterOsRender {
       }
     }
   }
+  static natAddresses(device) {
+    const nat = device.firewall?.nat;
+    const addresses = [
+      ...(nat?.source ?? []).flatMap((rule) => rule.action === "masquerade" ? [] : [rule.to]),
+      ...(nat?.destination ?? []).flatMap((rule) => [
+        ...rule.match?.dst ? [rule.match.dst] : [],
+        ...rule.action === "masquerade" ? [] : [rule.to]
+      ])
+    ];
+    return [...new Set(addresses)];
+  }
   families(match) {
     const sets = this.device.firewall?.address_sets ?? {};
     const address = match?.src ?? match?.dst;
@@ -10986,6 +11252,32 @@ class Validator {
     Validator.checkFirewall(device, names, cidr);
     Validator.checkServices(device, names, report, cidr);
     Validator.checkCertificates(device, names, report);
+    Validator.checkVdoms(device, names, report, cidr, ip);
+  }
+  static checkVdoms(device, names, report, cidr, ip) {
+    const management = device.vdoms?.management;
+    if (!management)
+      return;
+    if (device.platform !== "fortios")
+      report("vdoms are a FortiOS setting");
+    if (management.name === "root")
+      report("vdoms.management.name is root, the VDOM everything else is in; give it a name of its own");
+    for (const name of management.interfaces) {
+      names.expectInterface("vdoms.management interface", name);
+      const port = device.ports?.[name];
+      if (port?.lag)
+        report(`vdoms.management interface ${name} is in LAG ${port.lag}; list the LAG`);
+    }
+    for (const route of management.static ?? []) {
+      const where = `vdoms.management static route ${route.prefix}`;
+      cidr(where, route.prefix);
+      if (route.via)
+        ip(where, route.via);
+      if (!route.via && !route.interface && !route.blackhole)
+        report(`${where} has no next hop`);
+      if (route.interface && !management.interfaces.includes(route.interface))
+        report(`${where} leaves through ${route.interface}, which is not in the VDOM`);
+    }
   }
   static checkLimits(device) {
     const limits = Catalog.limits(device.platform, device.model);
@@ -11569,10 +11861,14 @@ class Cli {
     return new Cli(configPath, network, options);
   }
   static async load(path) {
-    if (process.versions.bun)
-      return (await import(path)).default;
-    const { createJiti } = await import("jiti");
-    return createJiti(import.meta.url).import(path, { default: true });
+    let network;
+    if (process.versions.bun) {
+      network = (await import(path)).default;
+    } else {
+      const { createJiti } = await import("jiti");
+      network = await createJiti(import.meta.url).import(path, { default: true });
+    }
+    return { ...network, devices: Cabling.describeLinks(network.devices) };
   }
   static fail(message) {
     console.error(message);
@@ -12377,7 +12673,7 @@ Renamed. Run circuit validate, then circuit apply ${to}: the device keeps its ol
     const port = Number(flags.port);
     if (!Number.isInteger(port) || port < 1 || port > 65535)
       Cli.fail("--port takes a number from 1 to 65535");
-    const { StudioServer } = await import("../chunks/server-cxr9ynxc.js");
+    const { StudioServer } = await import("../chunks/server-ggertnce.js");
     const host = flags.host;
     const allowHosts = (flags.allowHost ?? "").split(",").filter(Boolean);
     if (!StudioServer.isLoopback(host) && !allowHosts.length) {