@isothrum/editor 0.0.0-stage → 0.1.0

package/src/lib/tool/text/fr.ts

@@ -0,0 +1,358 @@
+import type { EditorText } from "./en";
+
+export const fr: EditorText = {
+  toolbar: {
+    blocks: { switch: "Switch", router: "Routeur", firewall: "Pare-feu", container: "Conteneur", vm: "Machine virtuelle", mine: "Mes équipements" },
+    kindsOf: (block) => `Types : ${block.toLowerCase()}`,
+    devices: "Appareils",
+    hand: "Main : déplacer le canevas",
+    select: "Sélection : sélectionner, déplacer, supprimer",
+    lan: "LAN",
+    lanTitle: "LAN / VLAN : une zone ; les machines à l'intérieur y reçoivent une adresse",
+    switch: "Switch",
+    switchTitle: "Switch : des ports dans des VLAN, et un trunk",
+    note: "Note",
+    noteTitle: "Note : du texte, un cadre ou une ellipse, pour expliquer le lab",
+    forget: (device) => `Oublier ${device}`,
+    forgetLabel: (device) => `Oublier l'appareil ${device}`,
+    undo: "Annuler",
+    undoTitle: "Annuler · Ctrl/⌘ Z",
+    redo: "Rétablir",
+    redoTitle: "Rétablir · Ctrl/⌘ Maj Z",
+  },
+  hints: {
+    lan: "Cliquez sur le canevas pour placer un LAN ; les machines à l'intérieur y reçoivent une adresse. Double-cliquez sur son nom ou sa plage pour les modifier.",
+    note: "Cliquez sur le canevas pour placer une note, puis double-cliquez dessus pour écrire. Les notes restent dans l'éditeur, pas dans isoloom.yml.",
+    place: (device) => `${device} : cliquez sur le canevas pour l'ajouter. Échap pour annuler.`,
+    hand: "Faites glisser pour déplacer le canevas. Appuyez sur V pour revenir à la sélection.",
+    cable: "Tirez d'un point d'une machine vers une autre pour les câbler.",
+    select: "Faites glisser sur le canevas pour sélectionner plusieurs machines : Suppr, ou Ctrl/⌘ C, V, D. Maintenez Espace pour déplacer le canevas.",
+  },
+  devices: {
+    router: { label: "Routeur", hint: "automatique : ses réseaux communiquent entre eux" },
+    "router-frr": { label: "Routeur (FRR)", hint: "conteneur FRRouting que vous configurez" },
+    firewall: { label: "Pare-feu", hint: "nftables sur Alpine" },
+    container: { label: "Conteneur Linux" },
+    web: { label: "Serveur web", hint: "nginx, port 80" },
+    database: { label: "Base de données", hint: "PostgreSQL, port 5432" },
+    desktop: { label: "Bureau Linux", hint: "Xfce avec VNC : clic droit, Écran ; mot de passe vncpassword" },
+    "linux-vm": { label: "VM Linux" },
+    "ubuntu-vm": { label: "VM Ubuntu" },
+    "kali-vm": { label: "VM Kali" },
+    "windows-vm": { label: "VM Windows" },
+    workstation: { label: "Poste de travail", hint: "là où arrive l'utilisateur" },
+    "cisco-iol": { label: "Routeur Cisco IOL", hint: "IOS sur Linux, votre image vrnetlab" },
+    "cisco-iol-l2": { label: "Switch Cisco IOL", hint: "IOL-L2, votre image vrnetlab" },
+  },
+  myDevice: (what) => `votre appareil : ${what}`,
+  myDeviceRouter: "routeur automatique",
+  status: {
+    loading: "Chargement…",
+    toFix: (count) => `${String(count)} à corriger`,
+    valid: "Valide",
+  },
+  run: {
+    autoStart: "Lancer ce lab à l’ouverture de l’application",
+    autoStartNote: "Sur cet ordinateur, quand l’application s’ouvre sur ce lab et qu’il ne tourne pas déjà.",
+    statusTitle: (up, total) => `${String(up)} machines sur ${String(total)} en marche`,
+    probed: "ports lus sur les machines",
+    inferred: "ports d’après l’état des machines (les VM ne sont pas sondées)",
+    run: "Lancer",
+    starting: "Démarrage…",
+    stop: "Arrêter",
+    stopping: "Arrêt…",
+    vmsTitle: "Un lab avec des VM tourne avec Vagrant (et VirtualBox ou libvirt) : installez-le depuis vagrantup.com, ou exportez le lab",
+    runVmsTitle: "Lancer le lab sur cette machine (VM avec Vagrant)",
+    startingVmsLog: "Démarrage des VM avec vagrant up (la première fois télécharge leurs box : quelques minutes)…",
+    runTitle: "Lancer le lab sur cette machine (Docker)",
+    startingLog: "Démarrage du lab avec docker compose…",
+    window: "Lancer sur cette machine",
+    running: "Le lab tourne. Sélectionnez un LAN ou un câble pour capturer son trafic.",
+    stopped: "Le lab est arrêté.",
+    noDocker:
+      "Docker ne répond pas. Installez-le et démarrez-le ; sous Linux, ajoutez-vous aussi au groupe docker (sudo usermod -aG docker $USER, puis reconnectez-vous).",
+    noLiveCapture: (wireshark, dir) =>
+      `${
+        wireshark
+          ? "Wireshark ne peut pas capturer en direct depuis ce compte : lancez sudo usermod -aG wireshark $USER, puis reconnectez-vous. En attendant, les captures"
+          : "Wireshark n'est pas installé : les captures"
+      } sont enregistrées en fichiers .pcap dans ${dir}.`,
+  },
+  capture: {
+    capturing: (network) => `Capture de ${network}`,
+    writingTo: "Écriture dans",
+    live: "En direct dans Wireshark.",
+    stop: "Arrêter la capture",
+    start: "Capturer le trafic",
+    runFirst: "Lancez le lab pour capturer son trafic.",
+  },
+  link: {
+    suspend: "Suspendre le lien",
+    resume: "Rétablir le lien",
+    suspendAll: "Suspendre tous les liens",
+    resumeAll: "Rétablir tous les liens",
+    cableSuspended: "Lien suspendu : rien ne passe.",
+    lanSuspended: (ports) => (ports === 1 ? "1 lien suspendu." : `${String(ports)} liens suspendus.`),
+    runFirst: "Lancez le lab pour suspendre ses liens.",
+  },
+  export: "Exporter",
+  engineDidntLoad: (error) => `Le moteur ne s'est pas chargé : ${error}`,
+  engineFailed: (error) => `Le moteur a échoué sur ce lab : ${error}`,
+  toasts: {
+    brokenLink: "Ce lien de partage est abîmé : le lab n'a pas pu être lu.",
+    openedShared: (lab) => `Lab partagé « ${lab} » ouvert. Annuler ramène le vôtre.`,
+    linkCopied: "Lien de partage copié : toute personne qui l'ouvre reçoit une copie de ce lab.",
+    copyPrompt: "Copiez ce lien pour partager le lab :",
+    savedDevice: (device) => `« ${device} » enregistré : il est au bout de la barre d'outils.`,
+    gns3Opened: (lab, machines, lans) =>
+      `« ${lab} » ouvert depuis GNS3 : ${String(machines)} machine${machines > 1 ? "s" : ""}, ${String(lans)} LAN.`,
+    undoBringsBack: "Annuler ramène votre lab.",
+    gns3Unreadable: "Ce projet GNS3 n'a pas pu être lu.",
+  },
+  windows: {
+    machine: "Machine",
+    lan: (lan) => `LAN ${lan}`,
+    cable: (a, b) => `Câble ${a} ↔ ${b}`,
+    portOn: (machine) => `Port sur ${machine}`,
+    cableNote: "Chaque câble est son propre petit réseau (un /29) ; ses deux extrémités en reçoivent les deux premières adresses.",
+    removeCable: "Supprimer le câble",
+    conditions: {
+      title: "Conditions du lien",
+      delay: "Latence (ms, dans chaque sens)",
+      jitter: "Gigue (ms)",
+      loss: "Perte (%)",
+      rate: "Débit (Mbit/s)",
+      hint: "Un lien lent ou qui perd des paquets, appliqué avec tc netem à chaque extrémité. Vide : aucune.",
+      onLan: "Ce câble place la machine sur le LAN : réglez les conditions sur le LAN.",
+      onVlan: "Les conditions se règlent sur un câble ou un LAN simple, pas encore sur le VLAN d'un switch.",
+    },
+    selected: (count) => `${String(count)} sélectionnés`,
+    selection: (items, cables) =>
+      `${String(items)} élément${items > 1 ? "s" : ""}, ${String(cables)} câble${cables > 1 ? "s" : ""}. Faites glisser l'un d'eux pour les déplacer ensemble.`,
+    deleteSelection: (count) => `Supprimer ${String(count)} (touche Suppr)`,
+    close: "Fermer",
+  },
+  lab: {
+    title: "Lab",
+    containers: "Conteneurs",
+    vms: "VM",
+    lans: "LAN",
+    cables: "Câbles",
+    toFix: "À corriger",
+    valid: "Le lab est valide : prêt à exporter.",
+    routing:
+      "Un routeur a besoin de sa propre configuration de transfert : chaque câble est son propre réseau, et rien ne route entre eux à votre place.",
+  },
+  menu: {
+    menu: "Menu",
+    example: "Charger le lab d'exemple",
+    vlanExample: "Charger l'exemple VLAN",
+    gns3: "Ouvrir un projet GNS3…",
+    gns3File: "Projet GNS3",
+    share: "Copier un lien de partage",
+    fit: "Ajuster à l'écran",
+    clear: "Vider le canevas",
+    light: "Thème clair",
+    dark: "Thème sombre",
+    style: "Style",
+    styles: { sketch: "Croquis : dessiné à la main", business: "Business : net et sobre" },
+    language: "Langue",
+    about: "À propos d'Isothrum",
+    blog: "Blog",
+  },
+  welcome: {
+    menuHint: "Exemple, thème, langue…",
+    toolbarHint: "Choisissez un appareil, puis cliquez sur le canevas",
+    pitch: "Dessinez un lab réseau de conteneurs et de VM. Téléchargez-le, prêt à lancer avec Docker, Vagrant ou Terraform.",
+    example: "Charger le lab d'exemple",
+    how: "Comment ça marche",
+  },
+  inspector: {
+    name: "Nom",
+    runsAs: "Exécuté comme",
+    automaticRouter: "Routeur automatique",
+    container: "Conteneur (Docker)",
+    vm: "Machine virtuelle",
+    routerNote:
+      "Rien à configurer : les réseaux auxquels il est relié (ses LAN, VLAN et câbles) communiquent par le routeur d'Isoloom. Pour configurer le routage vous-même, exécutez-le comme conteneur (FRR) ou comme VM.",
+    image: "Image",
+    keepRunning: "Le garder allumé",
+    applianceNote: "Cisco IOL tourne depuis votre propre image : construisez-la avec",
+    ciscoOs: "OS Cisco",
+    needsKvm: "Tourne dans QEMU : l’hôte Docker doit avoir /dev/kvm.",
+    dynamipsFirmware: (name: string) => `Placez votre image IOS de 7200 dans le téléchargement : images/${name}.bin.`,
+    iosConfig: "Configuration IOS",
+    iosConfigHint: "Ajoutée à celle qu’Isothrum écrit (nom, admin/admin en SSH, l’adresse de chaque interface). Appliquée au premier démarrage.",
+    keepRunningHint: "Pour une image sans service propre (Alpine, Ubuntu, Kali…) : une machine depuis laquelle travailler.",
+    os: "Système d'exploitation",
+    provision: "Étapes de provisionnement (une par ligne)",
+    ports: "Ports de service",
+    access: "L'utilisateur arrive sur cette machine",
+    cables: "Câbles",
+    noCables: "Aucun pour l'instant : tirez depuis l'un de ses points vers une autre machine.",
+    saveTitle: "Garder la configuration de cette machine comme appareil dans la barre d'outils, pour la placer à nouveau",
+    save: "Enregistrer comme appareil",
+    remove: "Supprimer la machine",
+  },
+  canvas: {
+    imageShort: "Image",
+    hosts: (n) => (n === 1 ? "1 hôte" : `${String(n)} hôtes`),
+    roles: { router: "Routeur", firewall: "Pare-feu", workstation: "Poste de travail", server: "Serveur", desktop: "Bureau", host: "Hôte" },
+    switchModel: (ports) => `Switch · ${String(ports)} ports`,
+    live: {
+      up: "En marche",
+      starting: "Démarrage",
+      unhealthy: "En mauvaise santé",
+      down: "Arrêtée",
+      portUp: "Lien actif",
+      portDown: "Lien coupé",
+      portUnknown: "Inconnu (arrêtée, ou le port appartient à l’OS de l’équipement)",
+      lanPorts: (up, total) => `${String(up)} ports sur ${String(total)} actifs sur ce LAN`,
+      cable: { up: "Le trafic passe", cut: "Suspendu : rien ne passe", down: "Coupé : une extrémité est arrêtée ou son port est coupé" },
+      cableShort: { cut: "suspendu", down: "coupé" },
+    },
+    editTitle: (what) => `${what} : double-cliquez pour modifier`,
+    unnamed: "sans nom",
+    machineName: "Nom de la machine",
+    vm: "VM",
+    automatic: "Automatique",
+    container: "Conteneur",
+    access: "accès",
+    addressTitle: (network, fixed) => `${network} : double-cliquez pour fixer cette adresse${fixed ? " (fixée)" : ""}`,
+    fixed: "fixée",
+    addressOn: (network) => `Adresse sur ${network}`,
+    lanName: "Nom du LAN",
+    addressBlock: "Plage d'adresses",
+    internetOnTitle: "Accède à internet (cliquez pour le couper)",
+    internetOffTitle: "Pas d'internet (cliquez pour l'autoriser)",
+    internetOn: "Accès à internet : activé",
+    internetOff: "Accès à internet : désactivé",
+    showAreaTitle: "Afficher la zone du LAN",
+    hideAreaTitle: "Masquer la zone du LAN (le LAN reste : seul son rectangle disparaît)",
+    showArea: "Afficher la zone",
+    hideArea: "Masquer la zone",
+    switchName: "Nom du switch",
+    port: (n) => `Port ${String(n)}`,
+    trunkPort: "Port trunk",
+    trunkCarries: (vlans) => `trunk, transporte ${vlans}`,
+    noVlan: "aucun VLAN",
+    clickToChange: "(cliquez pour changer)",
+    vlanNumber: "Numéro de VLAN",
+    vlanBlock: "Plage d'adresses du VLAN",
+    remove: (what) => `Supprimer ${what}`,
+    routerName: "Nom du routeur",
+    portFree: (port) => `${port} : libre`,
+    textOnly: "Texte seul",
+    box: "Cadre",
+    ellipse: "Ellipse",
+    colors: { yellow: "jaune", red: "rouge", blue: "bleu", green: "vert", violet: "violet" },
+    color: (color) => `Couleur ${color}`,
+    write: "Double-cliquez pour écrire",
+    note: "Note",
+    noteName: "note",
+  },
+  exportPanel: {
+    copy: "Copier",
+    copied: "Copié",
+    labName: "Nom du lab (celui du zip)",
+    fixFirst: "Corrigez le lab avant d'exporter",
+    download: (lab) => `Télécharger ${lab}.zip`,
+    onlySpec: "Seulement isoloom.yml",
+    where: "Où le lancer",
+    whereIntro: "Le zip contient un dossier par cible. Décompressez-le, puis lancez celle qui vous convient.",
+    mixed:
+      "Ce lab mélange conteneurs et VM : il tourne donc avec Vagrant. Passez tout en conteneurs (Docker, Kubernetes, une VM cloud) ou tout en VM (Proxmox, VM cloud) pour débloquer d'autres cibles.",
+    install: "Isoloom lance n'importe laquelle en une commande. Installez-le une fois :",
+    files: (count) => `${String(count)} fichier${count > 1 ? "s" : ""}`,
+    downloadOnly: (target) => `Télécharger seulement ${target} (avec isoloom.yml)`,
+    downloadTarget: (target) => `Télécharger ${target}`,
+    withIsoloom: "Avec Isoloom (arrêtez-le avec isoloom down)",
+    withTool: "Ou directement avec l'outil",
+    run: "Lancer",
+    specIntro: "Le lab en un seul fichier lisible, à garder dans Git ou à modifier à la main.",
+    showSpec: "Afficher le fichier",
+    hideSpec: "Masquer le fichier",
+    containersAndVms: "conteneurs et VM",
+    dockerOnOneVm: "Docker sur une VM",
+    oneVmPerMachine: "une VM par machine",
+  },
+  issues: {
+    vlanBlocks: (vlan, block, other, sw) => `${vlan} est en ${block} sur un switch et en ${other} sur ${sw}.`,
+    areaBlock: (lan, block, switches) => `La zone ${lan} est en ${block}, ses switchs disent ${switches}.`,
+    noName: { machine: "Une machine n'a pas de nom.", lan: "Un LAN n'a pas de nom.", switch: "Un switch n'a pas de nom." },
+    sameName: {
+      machine: (name) => `Deux machines s'appellent « ${name} ».`,
+      lan: (name) => `Deux LAN s'appellent « ${name} ».`,
+      switch: (name) => `Deux switchs s'appellent « ${name} ».`,
+    },
+    badPort: (machine, entry) => `« ${entry} » dans les ports de ${machine} n'est pas un port : un nombre de 1 à 65535, puis /udp, /http, /https ou /tls s'il n'est pas en TCP simple.`,
+  },
+  gns3: {
+    notGns3: "Ce n'est pas un projet GNS3 : ouvrez le fichier .gns3 (dans un .gns3project, c'est celui à la racine).",
+    noTopology: "Ce fichier ne contient aucune topologie GNS3.",
+    cisco: (node, kind) =>
+      `${node} : un routeur Cisco ${kind} est devenu un routeur automatique ; sa configuration IOS n'est pas reprise.`,
+    firewall: (node) => `${node} : un pare-feu est devenu un routeur automatique (ses règles ne sont pas reprises).`,
+    noEquivalent: (node, type) => `${node} : le nœud « ${type} » de GNS3 n'a pas d'équivalent ; ignoré.`,
+    noNodes: "Le projet n'a aucun nœud.",
+  },
+  account: {
+    signIn: "Se connecter avec Cyber Auth",
+    signOut: "Se déconnecter",
+    signedInAs: (name: string) => `Connecté : ${name}`,
+  },
+  projects: {
+    save: "Enregistrer dans mes projets",
+    saveAs: "Enregistrer comme nouveau projet…",
+    openList: "Ouvrir un projet…",
+    saveAsPrompt: "Nom du nouveau projet :",
+    windowTitle: "Mes projets",
+    loading: "Chargement de vos projets…",
+    none: "Aucun projet pour l'instant : enregistrez ce lab pour en créer un.",
+    open: "ouvert",
+    openButton: "Ouvrir",
+    delete: (name: string) => `Supprimer ${name}`,
+    confirmDelete: (name: string) => `Supprimer le projet « ${name} » et son historique ?`,
+    failed: (error: string) => `Impossible de charger vos projets : ${error}`,
+    history: (name: string) => `Versions précédentes de ${name}`,
+    noVersions: "Pas encore de version précédente.",
+    restore: "Ouvrir",
+    historyHint: "Ouvrir une version la place sur le canevas : Annuler ramène la version actuelle, et le prochain enregistrement la conserve.",
+    opened: (name: string) => `« ${name} » ouvert. Annuler ramène le lab qui était là.`,
+    status: {
+      idle: (name: string) => `Projet « ${name} »`,
+      saving: (name: string) => `Enregistrement de « ${name} »…`,
+      saved: (name: string) => `Enregistré dans « ${name} »`,
+      error: (name: string) => `Échec de l'enregistrement de « ${name} »`,
+    },
+  },
+  machineRun: {
+    display: "Écran (VNC)",
+    displayTitle: "L’écran de la machine : son serveur VNC, ou l’affichage de la VM",
+    displayOpened: (what) => `Ouvert : ${what}`,
+    consoleHint: "Double-cliquez sur une machine pour sa console ; clic droit pour son écran et le reste.",
+    runFirst: "Lancez le lab pour ouvrir ses consoles.",
+    running: "En marche dans le lab.",
+    stopped: "Arrêtée (le reste du lab tourne).",
+    unknown: "Absente du lab en marche : relancez le lab pour l’ajouter.",
+    console: "Console",
+    restart: "Redémarrer",
+    stop: "Arrêter",
+    start: "Démarrer",
+    snapshots: "Instantanés",
+    takeSnapshot: "En prendre un",
+    snapshotHint: "Enregistrer la machine telle qu’elle est (ses fichiers, la configuration enregistrée d’un routeur) ; pas ses volumes",
+    snapshotPrompt: "Nom de l’instantané (facultatif) :",
+    noSnapshots: "Aucun pour l’instant.",
+    restore: "Restaurer",
+    inUse: "utilisé",
+    ownImage: "Revenir à son image",
+    deleteSnapshot: (label: string) => `Supprimer l’instantané ${label}`,
+  },
+  update: {
+    available: (version: string) => `Isothrum ${version} est disponible.`,
+    restart: "Redémarrer pour mettre à jour",
+    installing: "Mise à jour…",
+    later: "Plus tard",
+  },
+};

package/src/lib/tool/text/index.ts

@@ -0,0 +1,21 @@
+import { hasLocale, type Locale } from "@/lib/i18n";
+import { de } from "./de";
+import { en, type EditorText } from "./en";
+import { es } from "./es";
+import { fr } from "./fr";
+
+export type { EditorText };
+
+/**
+ * The editor's own words in each language. They live here, typed, rather than in the site's
+ * JSON dictionaries: the editor only renders in the browser, and many of its strings take
+ * values (names, counts), which functions say better than templates.
+ */
+const TEXTS: Record<Locale, EditorText> = { en, fr, es, de };
+
+export function editorText(lang: string): EditorText {
+  return hasLocale(lang) ? TEXTS[lang] : en;
+}
+
+/** English: the source the other languages follow. */
+export const defaultText = en;

package/src/lib/tool/text/text.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "vitest";
+import { PRESETS } from "../presets";
+import { de } from "./de";
+import { en } from "./en";
+import { es } from "./es";
+import { fr } from "./fr";
+import { defaultText, editorText } from "./index";
+
+const languages = { en, fr, es, de };
+
+describe("editorText", () => {
+  test("gives each site language its own words", () => {
+    expect([editorText("en"), editorText("fr"), editorText("es"), editorText("de")]).toEqual([en, fr, es, de]);
+  });
+
+  test("falls back to English, the source the others follow", () => {
+    expect(editorText("it")).toBe(en);
+    expect(defaultText).toBe(en);
+  });
+});
+
+describe.each(Object.entries(languages))("%s", (_, text) => {
+  test("names every built-in device of the toolbar", () => {
+    for (const p of PRESETS) expect(p.id in text.devices, p.id).toBe(true);
+  });
+
+  test("puts the names it is given in its messages", () => {
+    expect(text.issues.sameName.machine("web7")).toContain("web7");
+    expect(text.issues.badPort("web7", "80/sctp")).toContain("80/sctp");
+    expect(text.gns3.cisco("R1", "IOU")).toContain("R1");
+    expect(text.myDevice("alpine:3.20")).toContain("alpine:3.20");
+  });
+});

package/src/lib/tool/topology.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, test } from "vitest";
+import { cable, compile, lan, machine, sw1Networks, switchNode } from "@/test/lab";
+import { toTopology } from "./topology";
+
+/** A machine's box, centered in the 400 by 300 LAN at the origin. */
+const inside = { x: 140, y: 92 };
+/** Far from every LAN. */
+const away = { x: 2000, y: 2000 };
+
+describe("which networks a machine is on", () => {
+  test("the LAN whose area it sits in, with the next free address", () => {
+    expect(compile([lan("office"), machine("web", {}, inside)]).nodes.web.networks).toEqual({ office: null });
+  });
+
+  test("its fixed address there, when it has one", () => {
+    expect(compile([lan("office"), machine("web", { pins: { office: 20 } }, inside)]).nodes.web.networks).toEqual({ office: 20 });
+  });
+
+  test("a LAN it is cabled to, whichever end the LAN is", () => {
+    const nodes = [lan("office"), lan("dmz", {}, { x: 1000 }), machine("web", {}, away)];
+    const t = compile(nodes, [cable("c1", "web", "office"), cable("c2", "dmz", "web")]);
+    expect(t.nodes.web.networks).toEqual({ office: null, dmz: null });
+  });
+
+  test("the VLAN of the switch's access port it is cabled to, whichever end the switch is", () => {
+    const nodes = [switchNode("sw1"), machine("a", {}, away), machine("b", {}, away)];
+    const t = compile(nodes, [cable("c1", "a", "sw1", { targetHandle: "p1" }), cable("c2", "sw1", "b", { sourceHandle: "p3" })]);
+    expect([t.nodes.a.networks, t.nodes.b.networks]).toEqual([{ vlan10: null }, { vlan20: null }]);
+  });
+
+  test("every VLAN of the switch on its trunk, and none on a free port", () => {
+    const nodes = [switchNode("sw1"), machine("r", {}, away), machine("free", {}, away)];
+    const t = compile(nodes, [cable("c1", "r", "sw1", { targetHandle: "trunk" }), cable("c2", "free", "sw1", { targetHandle: "p5" })]);
+    expect([t.nodes.r.networks, t.nodes.free.networks]).toEqual([{ vlan10: null, vlan20: null }, {}]);
+  });
+});
+
+describe("what a machine runs", () => {
+  test("an automatic router is a router", () => {
+    expect(compile([machine("r", { kind: "router", icon: "router" })]).nodes.r.kind).toEqual({ router: {} });
+  });
+
+  test("a container keeps its image trimmed, idle when it is a stock Linux image", () => {
+    const t = compile([machine("a", { image: " alpine:3.20 " }), machine("b", { image: "nginx" }), machine("c", { image: "alpine", idle: false })]);
+    expect([t.nodes.a.kind, t.nodes.b.kind, t.nodes.c.kind]).toEqual([
+      { container: { image: "alpine:3.20", idle: true } },
+      { container: { image: "nginx", idle: false } },
+      { container: { image: "alpine", idle: false } },
+    ]);
+  });
+
+  test("a Cisco appliance carries its OS and its own configuration, when it has one", () => {
+    const iol = { image: "vrnetlab/cisco_iol:17.12.01", appliance: "cisco-iol" as const };
+    const t = compile([machine("r1", { ...iol, config: "router ospf 1" }), machine("r2", { ...iol, config: "  " })]);
+    expect(t.nodes.r1.kind).toEqual({ container: { ...iol, config: "router ospf 1" } });
+    expect(t.nodes.r2.kind).toEqual({ container: iol });
+  });
+
+  test("a VM keeps its OS and one provisioning step per non-blank line", () => {
+    const t = compile([machine("vm", { kind: "vm", os: "debian@12", provision: "a\n b \n\n" })]);
+    expect(t.nodes.vm.kind).toEqual({ vm: { os: "debian@12", provision: ["a", "b"] } });
+  });
+
+  test("services are the ports of the list Isoloom takes, with what each speaks", () => {
+    expect(compile([machine("web", { ports: "x, 70000, 22, 443/https ,0, 53/udp" })]).nodes.web.services).toEqual([{ port: 22 }, { port: 443, protocol: "https" }, { port: 53, protocol: "udp" }]);
+  });
+
+  test("the access machine says so", () => {
+    expect(compile([machine("pc", { access: true })]).nodes.pc.access).toBe(true);
+  });
+
+  test("a machine without a name is left out", () => {
+    expect(compile([machine("m", { name: "" })]).nodes).toEqual({});
+  });
+});
+
+describe("links", () => {
+  test("a cable between two named machines is a link, its ports trimmed and its conditions as tc", () => {
+    const t = compile([machine("a", {}, away), machine("b", {}, away)], [cable("c", "a", "b", { aPort: " eth2 ", bPort: "eth1", tc: { delay: 10 } })]);
+    expect(t.links).toEqual([{ a: { node: "a", port: "eth2" }, b: { node: "b", port: "eth1" }, tc: { delay: "10ms" } }]);
+  });
+
+  test("a cable to a LAN, to a nameless machine or without ends' labels is no link", () => {
+    const nodes = [lan("office"), machine("a", {}, away), machine("b", { name: "" }, away)];
+    const unlabelled = { ...cable("c3", "a", "a"), data: undefined };
+    expect(compile(nodes, [cable("c1", "a", "office"), cable("c2", "a", "b"), unlabelled]).links).toEqual([]);
+  });
+});
+
+describe("networks", () => {
+  test("each named LAN area, its block trimmed, its internet and conditions", () => {
+    const t = compile([lan("office", { cidr: " 10.10.1.0/24 ", internet: false, tc: { loss: 1 } }), lan("unnamed", { name: "" })]);
+    expect(t.networks).toEqual({ office: { cidr: "10.10.1.0/24", internet: false, tc: { loss: 1 } } });
+  });
+
+  test("a switch's VLANs, nested under the switch's LAN", () => {
+    expect(compile([switchNode("sw1")]).networks).toEqual(sw1Networks);
+  });
+
+  test("a LAN area named like a VLAN is that VLAN: its block and internet, without conditions", () => {
+    const area = lan("l", { name: "vlan10", cidr: "10.10.10.0/24", internet: false, tc: { delay: 5 } });
+    expect(compile([area, switchNode("sw1")]).networks.vlan10).toEqual({ cidr: "10.10.10.0/24", internet: false, switch: "sw1", vlan: 10 });
+  });
+
+  test("the topology is JSON text, named after the lab", () => {
+    expect(JSON.parse(toTopology("office-lab", [], []))).toEqual({ name: "office-lab", nodes: {}, networks: {}, links: [] });
+  });
+});

package/src/lib/tool/topology.ts

@@ -0,0 +1,116 @@
+import { tcOf, type Tc } from "./conditions";
+import { lansAround } from "./geometry";
+import { idleByDefault, isLan, isMachine, isSwitch, type CableEdge, type LabNode, type MachineData } from "./model";
+import { readPorts, type Service } from "./ports";
+import { accessVlan, isTrunkPort, switchLans, vlanName } from "./vlans";
+
+/** The lab as the engine's topology JSON (`isothrum_compiler::Topology`). */
+
+/** Machine id -> the LANs it is on. */
+type Membership = Map<string, Set<string>>;
+
+function join(membership: Membership, machine: string, lan: string): void {
+  membership.set(machine, (membership.get(machine) ?? new Set()).add(lan));
+}
+
+/** A machine on a switch port joins the port's VLAN; on the trunk, every VLAN of the switch. */
+function joinSwitchPorts(membership: Membership, e: CableEdge, byId: Map<string, LabNode>): void {
+  const a = byId.get(e.source);
+  const b = byId.get(e.target);
+  for (const [m, sw, handle] of [
+    [a, b, e.targetHandle],
+    [b, a, e.sourceHandle],
+  ] as const) {
+    if (!m || !sw || !isMachine(m) || !isSwitch(sw)) continue;
+    if (isTrunkPort(sw, handle)) {
+      for (const v of sw.data.vlans) join(membership, m.id, vlanName(v.id));
+    } else {
+      const vlan = accessVlan(sw, handle);
+      if (vlan !== null) join(membership, m.id, vlanName(vlan));
+    }
+  }
+}
+
+/** A machine is on a LAN when it sits inside its area, or when a cable runs from it to the area. */
+function membershipOf(nodes: LabNode[], edges: CableEdge[], byId: Map<string, LabNode>): Membership {
+  const membership: Membership = 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;
+}
+
+/** What a machine runs, as the engine's `kind`. */
+function kindOf(m: MachineData) {
+  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 } };
+}
+
+/** The ports in a machine's field that Isoloom takes (the others are reported: `canvasIssues`). */
+const servicesOf = (m: MachineData): Service[] => readPorts(m.ports).services;
+
+/** Cables between two machines; a cable to a LAN is a membership, not a link. */
+function linksOf(edges: CableEdge[], byId: Map<string, LabNode>) {
+  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) }];
+  });
+}
+
+interface Net {
+  cidr: string;
+  internet: boolean;
+  tc?: Tc;
+  switch?: string;
+  vlan?: number;
+}
+
+/** The LAN areas, and each switch's VLANs, which nest under it in isoloom.yml (`sw1.vlan10`). */
+function networksOf(nodes: LabNode[], edges: CableEdge[]): Record<string, Net> {
+  const lans = nodes.filter(isLan).filter((l) => l.data.name);
+  const networks: Record<string, Net> = 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)] as Net | undefined) ?? { cidr: v.cidr.trim(), internet: true };
+      networks[vlanName(v.id)] = { ...net, tc: undefined, switch: nameOfGroup(sw.id), vlan: v.id };
+    }
+  }
+  return networks;
+}
+
+export function toTopology(name: string, nodes: LabNode[], edges: CableEdge[]): string {
+  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((lan) => [lan, m.pins?.[lan] ?? 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 });
+}