@isothrum/editor 0.0.0-stage → 0.1.0

package/dist/model.js

@@ -0,0 +1,745 @@
+// src/lib/tool/model.ts
+var APPLIANCES = [
+  { id: "cisco-iol", label: "IOL (IOS on Linux)", image: "vrnetlab/cisco_iol:17.12.01" },
+  { id: "cisco-iol-l2", label: "IOL-L2 (switch)", image: "vrnetlab/cisco_iol:L2-17.12.01", switch: true },
+  { id: "cisco-vios", label: "IOSv", image: "vrnetlab/cisco_vios:15.9.3M6", kvm: true },
+  { id: "cisco-vios-l2", label: "IOSvL2 (switch)", image: "vrnetlab/cisco_viosl2:15.2", switch: true, kvm: true },
+  { id: "cisco-csr1000v", label: "CSR1000v (IOS XE)", image: "vrnetlab/cisco_csr1000v:17.03.08", kvm: true },
+  { id: "cisco-c8000v", label: "Catalyst 8000v (IOS XE)", image: "vrnetlab/cisco_c8000v:17.15.01a", kvm: true },
+  { id: "cisco-dynamips", label: "Dynamips 7200 (classic IOS)", image: "" }
+];
+function applianceInterface(kind, k) {
+  switch (kind) {
+    case "cisco-iol":
+    case "cisco-iol-l2":
+      return `Ethernet${String(Math.floor(k / 4))}/${String(k % 4)}`;
+    case "cisco-vios":
+    case "cisco-vios-l2":
+      return `GigabitEthernet0/${String(k)}`;
+    case "cisco-csr1000v":
+    case "cisco-c8000v":
+      return `GigabitEthernet${String(k + 1)}`;
+    case "cisco-dynamips":
+      return k === 1 ? "FastEthernet0/0" : `FastEthernet${String(Math.floor(k / 2))}/${String(k % 2)}`;
+  }
+}
+var STOCK_IMAGES = ["alpine", "ubuntu", "debian", "kali-rolling", "fedora", "rockylinux", "almalinux", "centos", "busybox", "archlinux", "netshoot"];
+function imageName(image) {
+  return image.trim().split(":")[0].split("/").pop()?.toLowerCase() ?? "";
+}
+function idleByDefault(image) {
+  return STOCK_IMAGES.includes(imageName(image));
+}
+var NOTE_COLORS = ["yellow", "red", "blue", "green", "violet"];
+var isMachine = (n) => n.type === "machine";
+var isRealRouter = (n) => isMachine(n) && n.data.icon === "router" && n.data.kind !== "router";
+var ROUTER_PORTS = 4;
+var ROUTER_W = 168;
+var ROUTER_H = 74;
+var routerPort = (i) => `eth${String(i)}`;
+var isAppliance = (n) => isMachine(n) && (n.data.icon === "router" || n.data.icon === "shield");
+var isLan = (n) => n.type === "lan";
+var isSwitch = (n) => n.type === "switch";
+var isNote = (n) => n.type === "note";
+var nodeName = (n) => isNote(n) ? "note" : n.data.name;
+var SWITCH_PORTS = 8;
+var SWITCH_W = 306;
+var SWITCH_H = 74;
+var TRUNK = "trunk";
+var MACHINE_W = 120;
+var MACHINE_H = 116;
+var LAN_W = 420;
+var LAN_H = 300;
+function sizeOf(n) {
+  if (n.type === "lan") return { w: n.width ?? LAN_W, h: n.height ?? LAN_H };
+  if (n.type === "switch") return { w: SWITCH_W, h: SWITCH_H };
+  if (n.type === "note") return { w: n.width ?? 200, h: n.height ?? 90 };
+  if (n.data.icon === "router" && n.data.kind !== "router") return { w: ROUTER_W, h: ROUTER_H };
+  return { w: MACHINE_W, h: MACHINE_H };
+}
+function centerOf(n, fallback = { w: MACHINE_W, h: MACHINE_H }) {
+  return {
+    x: n.position.x + (n.width ?? n.measured?.width ?? fallback.w) / 2,
+    y: n.position.y + (n.height ?? n.measured?.height ?? fallback.h) / 2
+  };
+}
+var LAN_BEHAVIOR = { dragHandle: ".lan-handle", className: "pointer-events-none" };
+var DESIGNS = ["sketch", "business"];
+function cleanName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "");
+}
+function uid(prefix) {
+  return `${prefix}-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 7)}`;
+}
+function freeName(prefix, nodes) {
+  const taken = new Set(nodes.map(nodeName));
+  for (let i = 1; ; i++) {
+    if (!taken.has(`${prefix}${String(i)}`)) return `${prefix}${String(i)}`;
+  }
+}
+function unselected(items) {
+  return items.map((n) => ({ ...n, selected: false }));
+}
+
+// src/lib/tool/geometry.ts
+var ON = 0.5;
+function lanRect(l) {
+  return { x: l.position.x, y: l.position.y, w: l.width ?? LAN_W, h: l.height ?? LAN_H };
+}
+function within(r, p, slack = 0) {
+  return p.x >= r.x - slack && p.x <= r.x + r.w + slack && p.y >= r.y - slack && p.y <= r.y + r.h + slack;
+}
+function sideOf(r, p) {
+  const alongX = p.x >= r.x && p.x <= r.x + r.w;
+  const alongY = p.y >= r.y && p.y <= r.y + r.h;
+  if (alongX && Math.abs(p.y - r.y) < ON) return "top";
+  if (alongX && Math.abs(p.y - (r.y + r.h)) < ON) return "bottom";
+  if (alongY && Math.abs(p.x - r.x) < ON) return "left";
+  if (alongY && Math.abs(p.x - (r.x + r.w)) < ON) return "right";
+  return null;
+}
+function drawnCenter(m) {
+  const { w, h } = sizeOf(m);
+  return { x: m.position.x + w / 2, y: m.position.y + h / 2 };
+}
+function sideOnLan(m, lans) {
+  const c = drawnCenter(m);
+  for (const l of lans) {
+    const side2 = sideOf(lanRect(l), c);
+    if (side2) return side2;
+  }
+  return null;
+}
+function lanUnder(m, lans) {
+  for (const l of lans) {
+    const side2 = sideOnLan(m, [l]);
+    if (side2) return { lan: l, side: side2 };
+  }
+  return null;
+}
+function lansAround(m, nodes) {
+  const c = drawnCenter(m);
+  const onEdge = isAppliance(m) ? lanUnder(m, nodes.filter(isLan))?.lan.id : void 0;
+  return nodes.filter(isLan).filter((l) => (!l.data.hidden || l.id === onEdge) && within(lanRect(l), c));
+}
+
+// src/lib/tool/vlans.ts
+var vlanName = (id) => `vlan${String(id)}`;
+function switchPort(handle2) {
+  if (handle2 === TRUNK) return TRUNK;
+  const m = handle2 ? /^p(\d+)$/.exec(handle2) : null;
+  return m ? Number(m[1]) - 1 : null;
+}
+function isTrunkPort(sw, handle2) {
+  const port = switchPort(handle2);
+  return port === TRUNK || typeof port === "number" && sw.data.ports[port] === TRUNK;
+}
+function accessVlan(sw, handle2) {
+  const port = switchPort(handle2);
+  const mode = typeof port === "number" ? sw.data.ports[port] : null;
+  return typeof mode === "number" ? mode : null;
+}
+function switchLans(nodes, edges) {
+  const switches = nodes.filter(isSwitch);
+  const group = new Map(switches.map((s) => [s.id, s.id]));
+  const root = (id) => {
+    const up = group.get(id);
+    return up === void 0 || up === id ? id : root(up);
+  };
+  const unite = (a, b) => group.set(root(a), root(b));
+  for (const e of edges) if (group.has(e.source) && group.has(e.target)) unite(e.source, e.target);
+  const firstWith = /* @__PURE__ */ new Map();
+  for (const sw of switches) {
+    for (const v of sw.data.vlans) {
+      const other = firstWith.get(v.id);
+      if (other) unite(sw.id, other);
+      else firstWith.set(v.id, sw.id);
+    }
+  }
+  return (id) => switches.find((s) => root(s.id) === root(id))?.data.name ?? "";
+}
+
+// src/lib/tool/cables.ts
+function machineHandle(m, old) {
+  if (isAppliance(m)) return "port";
+  return old === "bottom" ? "bottom" : "top";
+}
+var isPort = (h) => !!h && /^eth\d+$/.test(h);
+function takenPorts(edges, byId) {
+  const taken = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    for (const [id, h] of [
+      [e.source, e.sourceHandle],
+      [e.target, e.targetHandle]
+    ]) {
+      const n = byId.get(id);
+      if (n && isRealRouter(n) && isPort(h)) taken.set(id, (taken.get(id) ?? /* @__PURE__ */ new Set()).add(h));
+    }
+  }
+  return taken;
+}
+function migrateEdges(edges, nodes) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const taken = takenPorts(edges, byId);
+  const freePort = (id) => {
+    const used = taken.get(id) ?? /* @__PURE__ */ new Set();
+    for (let i = 0; i < 64; i++) {
+      if (!used.has(routerPort(i))) {
+        used.add(routerPort(i));
+        taken.set(id, used);
+        return routerPort(i);
+      }
+    }
+    return routerPort(0);
+  };
+  const fix = (id, h) => {
+    const n = byId.get(id);
+    if (n && isRealRouter(n)) return isPort(h) ? h : freePort(id);
+    return n && isMachine(n) ? machineHandle(n, h) : h;
+  };
+  return edges.map((e) => ({ ...e, sourceHandle: fix(e.source, e.sourceHandle), targetHandle: fix(e.target, e.targetHandle) }));
+}
+function usedPorts(nodeId, edges) {
+  return edges.flatMap((e) => [...e.source === nodeId && e.data ? [e.data.aPort] : [], ...e.target === nodeId && e.data ? [e.data.bPort] : []]);
+}
+function nextPort(nodeId, edges, first = 0) {
+  const used = new Set(usedPorts(nodeId, edges));
+  for (let i = first; ; i++) {
+    if (!used.has(`eth${String(i)}`)) return `eth${String(i)}`;
+  }
+}
+
+// src/lib/tool/conditions.ts
+var isSet = (n) => typeof n === "number" && Number.isFinite(n);
+var whole = (n) => Math.abs(n - Math.round(n)) < 1e-9;
+function rateText(rate) {
+  if (Number.isInteger(rate)) return `${String(rate)}mbit`;
+  if (whole(rate * 1e3)) return `${String(Math.round(rate * 1e3))}kbit`;
+  return `${String(rate * 1e6)}bit`;
+}
+function tcOf(c) {
+  if (!c) return void 0;
+  const tc = {
+    ...isSet(c.delay) ? { delay: `${String(c.delay)}ms` } : {},
+    ...isSet(c.jitter) ? { jitter: `${String(c.jitter)}ms` } : {},
+    ...isSet(c.loss) ? { loss: c.loss } : {},
+    ...isSet(c.rate) ? { rate: rateText(c.rate) } : {}
+  };
+  return Object.keys(tc).length ? tc : void 0;
+}
+var TIME = /* @__PURE__ */ new Map([
+  ["us", [1, 1e3]],
+  ["ms", [1, 1]],
+  ["s", [1e3, 1]]
+]);
+var RATE = /* @__PURE__ */ new Map([
+  ["bit", [1, 1e6]],
+  ["kbit", [1, 1e3]],
+  ["mbit", [1, 1]],
+  ["gbit", [1e3, 1]],
+  ["bps", [8, 1e6]],
+  ["kbps", [8, 1e3]],
+  ["mbps", [8, 1]],
+  ["gbps", [8e3, 1]]
+]);
+var UNITS = { delay: TIME, jitter: TIME, rate: RATE };
+var MEASURE = /^([+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)([A-Za-z]*)$/;
+function measure(v, units) {
+  const m = MEASURE.exec(v);
+  const scale = m ? units.get(m[2]) : void 0;
+  if (!m || !scale) return void 0;
+  const n = Number(m[1]) * scale[0] / scale[1];
+  return Number.isFinite(n) ? n : void 0;
+}
+function conditionsOf(tc) {
+  const conditions = {};
+  const problems = [];
+  for (const field of ["delay", "jitter", "rate"]) {
+    const value = tc?.[field];
+    if (value === void 0) continue;
+    const n = measure(value, UNITS[field]);
+    if (n === void 0) problems.push({ field, value });
+    else conditions[field] = n;
+  }
+  if (tc?.loss !== void 0) conditions.loss = tc.loss;
+  return { conditions: Object.keys(conditions).length ? conditions : void 0, problems };
+}
+var EXPECTED = { delay: "a time like 40ms, 500us or 1s", jitter: "a time like 40ms, 500us or 1s", rate: "a rate like 10mbit or 512kbit" };
+function tcProblemText(at, p) {
+  return `${at}.${p.field}: \`${p.value}\` isn't ${EXPECTED[p.field]}; the drawing leaves it out`;
+}
+
+// src/lib/tool/ports.ts
+var PORT_PROTOCOLS = ["tcp", "udp", "http", "https", "tls"];
+var ENTRY = /^(\d{1,5})(?:\/([a-z]+))?$/;
+var isProtocol = (p) => PORT_PROTOCOLS.some((x) => x === p);
+function service(entry) {
+  const m = ENTRY.exec(entry);
+  if (!m) return null;
+  const [, digits, protocol = "tcp"] = m;
+  const port = Number(digits);
+  if (port < 1 || port > 65535) return null;
+  if (protocol === "tcp") return { port };
+  return isProtocol(protocol) ? { port, protocol } : null;
+}
+function readPorts(text) {
+  const services = [];
+  const bad = [];
+  for (const entry of text.split(",").map((e) => e.trim()).filter(Boolean)) {
+    const s = service(entry);
+    if (s) services.push(s);
+    else bad.push(entry);
+  }
+  return { services, bad };
+}
+function portsText(services) {
+  return services.map((s) => s.protocol && s.protocol !== "tcp" ? `${String(s.port)}/${s.protocol}` : String(s.port)).join(", ");
+}
+
+// src/lib/tool/layout.ts
+var COLS = 3;
+var CELL_W = 170;
+var CELL_H = 175;
+var GAP = 160;
+function icon(kind, access) {
+  if (kind.router) return "router";
+  if (kind.vm) return access ? "laptop" : "monitor";
+  const image = kind.container?.image ?? "";
+  return /nginx|httpd|apache|caddy|traefik|postgres|mysql|mariadb|redis|mongo|bind|dnsmasq|vsftpd|postfix/.test(image) ? "server" : "container";
+}
+function conditionsAt(layout, at, tc) {
+  const { conditions, problems } = conditionsOf(tc);
+  layout.problems.push(...problems.map((p) => tcProblemText(at, p)));
+  return conditions;
+}
+var lansOf = (layout, n) => Object.keys(n.networks ?? {}).filter((name) => layout.lans.has(name));
+function residents(topo) {
+  const lanNames = Object.keys(topo.networks ?? {});
+  const inside = new Map(lanNames.map((l) => [l, []]));
+  for (const [name, n] of Object.entries(topo.nodes)) {
+    const first = Object.keys(n.networks ?? {}).find((l) => lanNames.includes(l));
+    if (!n.kind.router && first) inside.get(first)?.push(name);
+  }
+  return inside;
+}
+function placeLans(layout, inside) {
+  let x = 0;
+  for (const [name, net] of Object.entries(layout.topo.networks ?? {})) {
+    const count = Math.max(1, inside.get(name)?.length ?? 0);
+    const w = Math.max(340, Math.min(COLS, count) * CELL_W + 80);
+    const h = Math.max(240, Math.ceil(count / COLS) * CELL_H + 90);
+    const lan2 = {
+      ...LAN_BEHAVIOR,
+      id: uid("l"),
+      type: "lan",
+      position: { x, y: 0 },
+      width: w,
+      height: h,
+      data: { name: cleanName(name), cidr: net.cidr, internet: net.internet ?? true, tc: conditionsAt(layout, `networks.${name}.tc`, net.tc) }
+    };
+    layout.lans.set(name, lan2);
+    layout.nodes.push(lan2);
+    x += w + GAP;
+  }
+}
+function addMachine(layout, name, n, position) {
+  const access = !!n.access;
+  const data = {
+    name: cleanName(name),
+    kind: n.kind.router ? "router" : n.kind.vm ? "vm" : "container",
+    icon: icon(n.kind, access),
+    image: n.kind.container?.image ?? "",
+    os: n.kind.vm?.os ?? "",
+    provision: (n.kind.vm?.provision ?? []).join("\n"),
+    ports: portsText(n.services ?? []),
+    access,
+    ...n.kind.container ? { idle: n.kind.container.idle } : {}
+  };
+  const pins = Object.fromEntries(Object.entries(n.networks ?? {}).filter((e) => typeof e[1] === "number"));
+  if (Object.keys(pins).length) data.pins = pins;
+  const m = { id: uid("m"), type: "machine", position, data };
+  layout.machines.set(name, m);
+  layout.nodes.push(m);
+}
+function placeMachines(layout, inside) {
+  for (const [lanName, names] of inside) {
+    const lan2 = layout.lans.get(lanName);
+    if (!lan2) continue;
+    names.forEach((name, i) => {
+      const at = { x: lan2.position.x + 40 + i % COLS * CELL_W, y: lan2.position.y + 70 + Math.floor(i / COLS) * CELL_H };
+      addMachine(layout, name, layout.topo.nodes[name], at);
+    });
+  }
+  const lanBottom = Math.max(0, ...[...layout.lans.values()].map((l) => l.height ?? 0));
+  let routerX = 0;
+  let looseX = 0;
+  for (const [name, n] of Object.entries(layout.topo.nodes)) {
+    if (layout.machines.has(name)) continue;
+    const joined = lansOf(layout, n).flatMap((l) => layout.lans.get(l) ?? []);
+    if (n.kind.router && joined.length) {
+      const center = joined.reduce((s, l) => s + l.position.x + (l.width ?? 0) / 2, 0) / joined.length;
+      routerX = Math.max(routerX, center - MACHINE_W / 2);
+      addMachine(layout, name, n, { x: routerX, y: lanBottom + 110 });
+      routerX += MACHINE_W + 60;
+    } else {
+      addMachine(layout, name, n, { x: looseX, y: lanBottom + 110 + CELL_H + 60 });
+      looseX += CELL_W;
+    }
+  }
+}
+function side(lan2, m) {
+  const d = { x: centerOf(m).x - centerOf(lan2).x, y: centerOf(m).y - centerOf(lan2).y };
+  if (Math.abs(d.x) / (lan2.width ?? 1) > Math.abs(d.y) / (lan2.height ?? 1)) return d.x < 0 ? "left" : "right";
+  return d.y < 0 ? "top" : "bottom";
+}
+function handle(m, other) {
+  if (m.data.icon === "router" || m.data.icon === "shield") return "port";
+  return centerOf(other).y < centerOf(m).y ? "top" : "bottom";
+}
+function cableToLans(layout) {
+  for (const [name, n] of Object.entries(layout.topo.nodes)) {
+    const m = layout.machines.get(name);
+    if (!m) continue;
+    const skip = n.kind.router ? void 0 : lansOf(layout, n)[0];
+    for (const l of lansOf(layout, n).filter((x) => x !== skip)) {
+      const lan2 = layout.lans.get(l);
+      if (!lan2) continue;
+      layout.edges.push({
+        id: uid("c"),
+        type: "cable",
+        source: m.id,
+        sourceHandle: handle(m, lan2),
+        target: lan2.id,
+        targetHandle: side(lan2, m),
+        data: { aPort: nextPort(m.id, layout.edges), bPort: "" }
+      });
+    }
+  }
+}
+function cableLinks(layout) {
+  for (const [i, link] of (layout.topo.links ?? []).entries()) {
+    const a = layout.machines.get(link.a.node);
+    const b = layout.machines.get(link.b.node);
+    if (!a || !b) continue;
+    layout.edges.push({
+      id: uid("c"),
+      type: "cable",
+      source: a.id,
+      sourceHandle: handle(a, b),
+      target: b.id,
+      targetHandle: handle(b, a),
+      data: {
+        aPort: link.a.port || nextPort(a.id, layout.edges),
+        bPort: link.b.port || nextPort(b.id, layout.edges),
+        tc: conditionsAt(layout, `links[${String(i)}].tc`, link.tc)
+      }
+    });
+  }
+}
+function draftFromTopology(topo) {
+  const layout = { topo, nodes: [], edges: [], lans: /* @__PURE__ */ new Map(), machines: /* @__PURE__ */ new Map(), problems: [] };
+  const inside = residents(topo);
+  placeLans(layout, inside);
+  placeMachines(layout, inside);
+  cableToLans(layout);
+  cableLinks(layout);
+  const draft = { name: cleanName(topo.name) || "lab", nodes: layout.nodes, edges: migrateEdges(layout.edges, layout.nodes) };
+  return { draft, problems: layout.problems };
+}
+
+// src/lib/tool/topology.ts
+function join(membership, machine2, lan2) {
+  membership.set(machine2, (membership.get(machine2) ?? /* @__PURE__ */ new Set()).add(lan2));
+}
+function joinSwitchPorts(membership, e, byId) {
+  const a = byId.get(e.source);
+  const b = byId.get(e.target);
+  for (const [m, sw, handle2] of [
+    [a, b, e.targetHandle],
+    [b, a, e.sourceHandle]
+  ]) {
+    if (!m || !sw || !isMachine(m) || !isSwitch(sw)) continue;
+    if (isTrunkPort(sw, handle2)) {
+      for (const v of sw.data.vlans) join(membership, m.id, vlanName(v.id));
+    } else {
+      const vlan = accessVlan(sw, handle2);
+      if (vlan !== null) join(membership, m.id, vlanName(vlan));
+    }
+  }
+}
+function membershipOf(nodes, edges, byId) {
+  const membership = /* @__PURE__ */ new Map();
+  for (const n of nodes.filter(isMachine)) for (const l of lansAround(n, nodes)) join(membership, n.id, l.data.name);
+  for (const e of edges) {
+    const a = byId.get(e.source);
+    const b = byId.get(e.target);
+    if (a && b && isMachine(a) && isLan(b)) join(membership, a.id, b.data.name);
+    if (a && b && isLan(a) && isMachine(b)) join(membership, b.id, a.data.name);
+    joinSwitchPorts(membership, e, byId);
+  }
+  return membership;
+}
+function kindOf(m) {
+  if (m.kind === "router") return { router: {} };
+  if (m.kind === "container") {
+    return {
+      container: m.appliance ? { image: m.image.trim(), appliance: m.appliance, ...m.config?.trim() ? { config: m.config } : {} } : { image: m.image.trim(), idle: m.idle ?? idleByDefault(m.image) }
+    };
+  }
+  const provision = m.provision.split("\n").map((l) => l.trim()).filter(Boolean);
+  return { vm: { os: m.os, provision } };
+}
+var servicesOf = (m) => readPorts(m.ports).services;
+function linksOf(edges, byId) {
+  return edges.flatMap((e) => {
+    const a = byId.get(e.source);
+    const b = byId.get(e.target);
+    if (!a || !b || !isMachine(a) || !isMachine(b) || !a.data.name || !b.data.name || !e.data) return [];
+    return [{ a: { node: a.data.name, port: e.data.aPort.trim() }, b: { node: b.data.name, port: e.data.bPort.trim() }, tc: tcOf(e.data.tc) }];
+  });
+}
+function networksOf(nodes, edges) {
+  const lans = nodes.filter(isLan).filter((l) => l.data.name);
+  const networks = Object.fromEntries(
+    lans.map((l) => [l.data.name, { cidr: l.data.cidr.trim(), internet: l.data.internet, tc: tcOf(l.data.tc) }])
+  );
+  const nameOfGroup = switchLans(nodes, edges);
+  for (const sw of nodes.filter(isSwitch)) {
+    for (const v of sw.data.vlans) {
+      const net = networks[vlanName(v.id)] ?? { cidr: v.cidr.trim(), internet: true };
+      networks[vlanName(v.id)] = { ...net, tc: void 0, switch: nameOfGroup(sw.id), vlan: v.id };
+    }
+  }
+  return networks;
+}
+function toTopology(name, nodes, edges) {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const membership = membershipOf(nodes, edges, byId);
+  const machines = Object.fromEntries(
+    nodes.filter(isMachine).filter((n) => n.data.name).map(({ id, data: m }) => {
+      const networks = Object.fromEntries([...membership.get(id) ?? []].map((lan2) => [lan2, m.pins?.[lan2] ?? null]));
+      return [m.name, { kind: kindOf(m), access: m.access, services: servicesOf(m), networks }];
+    })
+  );
+  const links = linksOf(edges, byId);
+  return JSON.stringify({ name, nodes: machines, networks: networksOf(nodes, edges), links });
+}
+
+// src/lib/tool/create.ts
+function twoVlans() {
+  return {
+    name: "",
+    vlans: [
+      { id: 10, cidr: "10.10.10.0/24" },
+      { id: 20, cidr: "10.10.20.0/24" }
+    ],
+    ports: [10, 10, 10, 10, 20, 20, 20, 20]
+  };
+}
+
+// src/lib/tool/os.ts
+var DEFAULT_OS = "debian@12";
+
+// src/lib/tool/examples.ts
+var base = { image: "", os: "", provision: "", ports: "", access: false };
+var machine = (id, position, data) => ({ id, type: "machine", position, data });
+var lan = (id, area, data) => ({
+  ...LAN_BEHAVIOR,
+  id,
+  type: "lan",
+  position: { x: area.x, y: area.y },
+  width: area.w,
+  height: area.h,
+  data
+});
+var cable = (id, [source, target], [sh, th], [aPort, bPort]) => ({
+  id,
+  type: "cable",
+  source,
+  sourceHandle: sh,
+  target,
+  targetHandle: th,
+  data: { aPort, bPort }
+});
+function exampleLab() {
+  const nodes = [
+    // LANs first, so they are drawn under the machines.
+    lan("l-office", { x: -40, y: 40, w: 280, h: 260 }, { name: "office", cidr: "10.10.1.0/24", internet: true }),
+    lan("l-servers", { x: 560, y: -80, w: 300, h: 500 }, { name: "servers", cidr: "10.10.2.0/24", internet: true }),
+    machine("m-user", { x: 40, y: 110 }, { ...base, name: "user", kind: "vm", icon: "laptop", os: DEFAULT_OS, access: true }),
+    // On the office LAN's right edge: a two-network appliance, office on one side, its port out.
+    machine("m-router", { x: 240 - MACHINE_W / 2, y: 170 - MACHINE_H / 2 }, { ...base, name: "router", kind: "router", icon: "router" }),
+    machine("m-web", { x: 650, y: 0 }, { ...base, name: "web", kind: "container", icon: "server", image: "nginx:1.27-alpine", ports: "80" }),
+    machine("m-db", { x: 650, y: 240 }, { ...base, name: "db", kind: "vm", icon: "monitor", os: DEFAULT_OS, provision: "provision/db.sh", ports: "5432" })
+  ];
+  const edges = [cable("c-1", ["m-router", "l-servers"], ["port", "left"], ["eth1", ""])];
+  return { name: "office-lab", nodes, edges };
+}
+function vlanExample() {
+  const nodes = [
+    { id: "s-sw1", type: "switch", position: { x: 40, y: 0 }, data: { ...twoVlans(), name: "sw1" } },
+    machine("m-router", { x: 180, y: -230 }, { ...base, name: "router", kind: "router", icon: "router" }),
+    machine("m-pc1", { x: -140, y: 220 }, { ...base, name: "pc1", kind: "vm", icon: "laptop", os: DEFAULT_OS, access: true }),
+    machine("m-pc2", { x: 40, y: 220 }, { ...base, name: "pc2", kind: "container", icon: "container", image: "alpine:3.20" }),
+    machine("m-srv", { x: 300, y: 220 }, { ...base, name: "srv", kind: "container", icon: "server", image: "nginx:1.27-alpine", ports: "80" })
+  ];
+  const onSwitch = (id, m, mh, port, labels) => cable(id, [m, "s-sw1"], [mh, port], labels);
+  const edges = [
+    onSwitch("c-1", "m-router", "port", "trunk", ["eth0", "T"]),
+    onSwitch("c-2", "m-pc1", "top", "p1", ["eth0", "1"]),
+    onSwitch("c-3", "m-pc2", "top", "p2", ["eth0", "2"]),
+    onSwitch("c-4", "m-srv", "top", "p5", ["eth0", "5"])
+  ];
+  return { name: "vlan-lab", nodes, edges };
+}
+
+// src/lib/tool/engine.ts
+function planOf(engine, topology, failed) {
+  try {
+    const raw = JSON.parse(engine.plan_json(topology));
+    return { ...raw, isoloom_yml: raw.isoloom_yml ?? null };
+  } catch (e) {
+    return { ok: false, error: failed(String(e)), isoloom_yml: null, problems: [], files: [], skipped: [], addresses: {} };
+  }
+}
+function ownFiles(engine, topology) {
+  return JSON.parse(engine.own_files_json(topology));
+}
+
+// src/lib/tool/export-targets.ts
+var CLOUDS = {
+  aws: "AWS",
+  azure: "Azure",
+  gcp: "Google Cloud",
+  digitalocean: "DigitalOcean",
+  linode: "Linode",
+  oci: "Oracle Cloud"
+};
+function cloudTarget(target, cloud, terraform, t) {
+  const where = CLOUDS[cloud ?? ""] ?? String(cloud);
+  if (target === "cloud-docker") return { name: `${where} (${t.dockerOnOneVm})`, isoloom: `isoloom run cloud-docker --cloud ${String(cloud)}`, run: terraform };
+  return { name: `${where} (${t.oneVmPerMachine})`, isoloom: `isoloom run cloud-vm --cloud ${String(cloud)}`, run: terraform };
+}
+function describe(dir, t) {
+  const [target, cloud] = dir.split("/");
+  const terraform = `cd .isoloom/${dir} && terraform init && terraform apply`;
+  switch (target) {
+    case "docker":
+      return { name: "Docker Compose", isoloom: "isoloom run docker", run: "docker compose -f .isoloom/docker/compose.yml up -d" };
+    case "hybrid":
+      return { name: `Vagrant (${t.containersAndVms})`, isoloom: "isoloom run hybrid", run: "cd .isoloom/hybrid && vagrant up" };
+    case "vagrant":
+      return { name: `Vagrant (${t.oneVmPerMachine})`, isoloom: "isoloom run vagrant", run: "cd .isoloom/vagrant && vagrant up" };
+    case "docker-vm":
+      return cloud === "proxmox" ? { name: `Proxmox (${t.dockerOnOneVm})`, isoloom: null, run: terraform } : { name: `Vagrant (${t.dockerOnOneVm})`, isoloom: "isoloom run docker-vm", run: "cd .isoloom/docker-vm && vagrant up" };
+    case "proxmox":
+      return { name: `Proxmox (${t.oneVmPerMachine})`, isoloom: "isoloom run proxmox", run: terraform };
+    case "kubernetes":
+      return { name: "Kubernetes", isoloom: "isoloom run kubernetes", run: "kubectl kustomize --load-restrictor LoadRestrictionsNone .isoloom/kubernetes | kubectl apply -f -" };
+    case "cloud-docker":
+    case "cloud-vm":
+      return cloudTarget(target, cloud, terraform, t);
+    default:
+      return { name: dir, isoloom: null, run: "" };
+  }
+}
+function folderOf(path) {
+  const parts = path.replace(/^\.isoloom\//, "").split("/");
+  const deeper = parts.length > 2 && (parts[0] === "cloud-docker" || parts[0] === "cloud-vm" || parts[0] === "docker-vm" && parts[1] === "proxmox");
+  return deeper ? `${parts[0]}/${parts[1]}` : parts[0];
+}
+function groupByTarget(files, t) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const dir = folderOf(f.path);
+    groups.set(dir, [...groups.get(dir) ?? [], f]);
+  }
+  return [...groups.entries()].map(([dir, fs]) => ({ dir, files: fs, ...describe(dir, t) }));
+}
+
+// src/lib/tool/issues.ts
+function blockIssues(nodes, text) {
+  const issues = [];
+  const blocks = /* @__PURE__ */ new Map();
+  for (const sw of nodes.filter(isSwitch)) {
+    for (const v of sw.data.vlans) {
+      const name = vlanName(v.id);
+      const seen = blocks.get(name);
+      if (seen && seen !== v.cidr) issues.push(text.vlanBlocks(name, seen, v.cidr, sw.data.name));
+      blocks.set(name, v.cidr);
+    }
+  }
+  for (const l of nodes.filter(isLan)) {
+    const seen = blocks.get(l.data.name);
+    if (seen && seen !== l.data.cidr) issues.push(text.areaBlock(l.data.name, l.data.cidr, seen));
+  }
+  return issues;
+}
+function nameIssues(nodes, text) {
+  const issues = [];
+  for (const [what, list] of [
+    ["machine", nodes.filter(isMachine)],
+    ["lan", nodes.filter(isLan)],
+    ["switch", nodes.filter(isSwitch)]
+  ]) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const n of list) {
+      if (!n.data.name) issues.push(text.noName[what]);
+      else if (seen.has(n.data.name)) issues.push(text.sameName[what](n.data.name));
+      seen.add(n.data.name);
+    }
+  }
+  return issues;
+}
+function portIssues(nodes, text) {
+  return nodes.filter(isMachine).flatMap((m) => readPorts(m.data.ports).bad.map((entry) => text.badPort(m.data.name, entry)));
+}
+function canvasIssues(nodes, text) {
+  return [...blockIssues(nodes, text), ...nameIssues(nodes, text), ...portIssues(nodes, text)];
+}
+export {
+  APPLIANCES,
+  DESIGNS,
+  LAN_BEHAVIOR,
+  LAN_H,
+  LAN_W,
+  MACHINE_H,
+  MACHINE_W,
+  NOTE_COLORS,
+  PORT_PROTOCOLS,
+  ROUTER_H,
+  ROUTER_PORTS,
+  ROUTER_W,
+  SWITCH_H,
+  SWITCH_PORTS,
+  SWITCH_W,
+  TRUNK,
+  applianceInterface,
+  canvasIssues,
+  centerOf,
+  cleanName,
+  draftFromTopology,
+  exampleLab,
+  freeName,
+  groupByTarget,
+  idleByDefault,
+  imageName,
+  isAppliance,
+  isLan,
+  isMachine,
+  isNote,
+  isRealRouter,
+  isSwitch,
+  nodeName,
+  ownFiles,
+  planOf,
+  portsText,
+  readPorts,
+  routerPort,
+  sizeOf,
+  toTopology,
+  uid,
+  unselected,
+  vlanExample
+};
+//# sourceMappingURL=model.js.map