@isothrum/editor 0.0.0-stage → 0.1.0

package/dist/types/components/tool/windows/lab-status.d.ts

@@ -0,0 +1,6 @@
+import { type LabLive, type SuspendedLink } from "../../../lib/tool/desktop.js";
+/** Desktop only: the running lab now, machine by machine, with each one's ports. */
+export declare function LabStatus({ live, cut }: {
+    live: LabLive;
+    cut: SuspendedLink[];
+}): import("react").JSX.Element;

package/dist/types/components/tool/windows/lab-windows.d.ts

@@ -0,0 +1,13 @@
+import type { EditorModel } from "../hooks/use-editor";
+/** Several things selected: what they are, and deleting them all. */
+export declare function SelectionWindow({ e }: {
+    e: EditorModel;
+}): import("react").JSX.Element;
+/** The lab at a glance: how many containers, VMs, LANs and cables, and what to fix. */
+export declare function StatusWindow({ e }: {
+    e: EditorModel;
+}): import("react").JSX.Element;
+/** Desktop app: the lab running on this machine, its log, and starting it with the app. */
+export declare function RunWindow({ e }: {
+    e: EditorModel;
+}): import("react").JSX.Element;

package/dist/types/components/tool/windows/link-controls.d.ts

@@ -0,0 +1,21 @@
+/** Desktop only: capture a LAN's or a cable's traffic while the lab runs. */
+export declare function CaptureControl({ network, running, file, capturing, onStart, onStop }: {
+    network: string;
+    running: boolean;
+    file: string | null | undefined;
+    capturing: boolean;
+    onStart: () => void;
+    onStop: () => void;
+}): import("react").JSX.Element;
+/**
+ * Desktop only: suspend a link while the lab runs, as GNS3 does: a cable's ends (their ports,
+ * down) or, with `all`, every link of a LAN. `suspended` says so when it is.
+ */
+export declare function LinkControl({ running, busy, all, suspended, onSuspend, onResume }: {
+    running: boolean;
+    busy: boolean;
+    all?: boolean;
+    suspended: string | null;
+    onSuspend: () => void;
+    onResume: () => void;
+}): import("react").JSX.Element;

package/dist/types/components/tool/windows/machine-controls.d.ts

@@ -0,0 +1,16 @@
+import type { Snapshot } from "../../../lib/tool/desktop.js";
+import type { MachineAction } from "../hooks/use-machine-actions";
+interface Props {
+    state: string | undefined;
+    busy: boolean;
+    onConsole: () => void;
+    onDisplay: () => void;
+    onAction: (action: MachineAction) => void;
+    snapshots: Snapshot[];
+    onSnapshot: (label: string) => void;
+    onUse: (id: string | null) => void;
+    onDeleteSnapshot: (id: string) => void;
+}
+/** In the desktop app, for a machine of the running lab: its state, its controls, its snapshots. */
+export declare function MachineControls(p: Props): import("react").JSX.Element;
+export {};

package/dist/types/components/tool/windows/machine-inspector.d.ts

@@ -0,0 +1,11 @@
+import { type MachineData, type MachineNode } from "../../../lib/tool/model.js";
+type Change = (patch: Partial<MachineData>) => void;
+/** A machine's window: its name and kind, what it runs, its services, its cables. */
+export declare function MachineInspector({ node, cables, onChange, onDelete, onSaveDevice }: {
+    node: MachineNode;
+    cables: string[];
+    onChange: Change;
+    onDelete: () => void;
+    onSaveDevice: () => void;
+}): import("react").JSX.Element;
+export {};

package/dist/types/components/tool/windows/runs-fields.d.ts

@@ -0,0 +1,18 @@
+import { type MachineData } from "../../../lib/tool/model.js";
+type Change = (patch: Partial<MachineData>) => void;
+/** A container: its image (none to type for Dynamips), and a Cisco OS's fields or whether it idles. */
+export declare function ContainerFields({ m, onChange }: {
+    m: MachineData;
+    onChange: Change;
+}): import("react").JSX.Element;
+/** A VM: its OS and its provisioning steps. */
+export declare function VmFields({ m, onChange }: {
+    m: MachineData;
+    onChange: Change;
+}): import("react").JSX.Element;
+/** A machine's services and whether the user lands on it (not an automatic router, nor an appliance). */
+export declare function ServiceFields({ m, onChange }: {
+    m: MachineData;
+    onChange: Change;
+}): import("react").JSX.Element;
+export {};

package/dist/types/components/tool/windows/selected-windows.d.ts

@@ -0,0 +1,21 @@
+import { type CableEdge, type LanNode, type MachineNode } from "../../../lib/tool/model.js";
+import type { EditorModel } from "../hooks/use-editor";
+/** A machine's window: the inspector, and (desktop app, lab running) its controls. */
+export declare function MachineWindow({ e, node }: {
+    e: EditorModel;
+    node: MachineNode;
+}): import("react").JSX.Element;
+/**
+ * A LAN's window: how it behaves (its name and block are edited on the canvas itself), and in the
+ * desktop app capturing its traffic and suspending its links.
+ */
+export declare function LanWindow({ e, lan }: {
+    e: EditorModel;
+    lan: LanNode;
+}): import("react").JSX.Element;
+/** A cable's window: the port at each end, how it behaves, and removing it. */
+export declare function CableWindow({ e, edge, data }: {
+    e: EditorModel;
+    edge: CableEdge;
+    data: NonNullable<CableEdge["data"]>;
+}): import("react").JSX.Element;

package/dist/types/components/ui/button.d.ts

@@ -0,0 +1,8 @@
+import { Button as ButtonPrimitive } from "@base-ui/react/button";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "icon" | "default" | "sm" | "xs" | "lg" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, ...props }: ButtonPrimitive.Props & VariantProps<typeof buttonVariants>): import("react").JSX.Element;
+export { Button, buttonVariants };

package/dist/types/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+import { Menu as MenuPrimitive } from "@base-ui/react/menu";
+declare function DropdownMenu({ ...props }: MenuPrimitive.Root.Props): React.JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: MenuPrimitive.Trigger.Props): React.JSX.Element;
+declare function DropdownMenuContent({ align, alignOffset, side, sideOffset, className, ...props }: MenuPrimitive.Popup.Props & Pick<MenuPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): React.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: MenuPrimitive.Group.Props): React.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: MenuPrimitive.GroupLabel.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: MenuPrimitive.Item.Props & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): React.JSX.Element;
+declare function DropdownMenuSub({ ...props }: MenuPrimitive.SubmenuRoot.Props): React.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: MenuPrimitive.SubmenuTrigger.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuSubContent({ align, alignOffset, side, sideOffset, className, ...props }: React.ComponentProps<typeof DropdownMenuContent>): React.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: MenuPrimitive.Separator.Props): React.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The Isothrum lab editor as a reusable React component, plus the ports a host wires in (accounts,
+ * the product mark). The pure lab-model logic (no React) lives in the `./model` entry.
+ */
+export { LabCanvas, type LabCanvasProps } from "./components/tool/lab-canvas.js";
+export { AuthClientProvider, useAuthClient, type AuthClient, type AuthSession, type AuthSessionUser, } from "./lib/auth.js";
+export { BrandMarkProvider, DefaultBrandMark, useBrandMark, type BrandMark, type BrandMarkProps, } from "./lib/brand.js";

package/dist/types/lib/auth.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from "react";
+/**
+ * The accounts surface the editor uses, injected by the host (the website wires Better Auth; the
+ * desktop app and the standalone editor leave it out and run with `accounts={false}`). Keeping it
+ * an injected port is what lets this package stay free of any auth implementation.
+ */
+export interface AuthSessionUser {
+    name?: string | null;
+    email: string;
+}
+export interface AuthSession {
+    user: AuthSessionUser;
+}
+export interface AuthClient {
+    /** React hook: the current session (or `null`), and whether it is still loading. */
+    useSession: () => {
+        data: AuthSession | null;
+        isPending: boolean;
+    };
+    signOut: () => Promise<unknown> | void;
+    signIn: {
+        oauth2: (options: {
+            providerId: string;
+            callbackURL: string;
+            errorCallbackURL: string;
+        }) => Promise<unknown> | void;
+    };
+}
+/** Provides the host's auth client to the editor. Omit it (or pass `null`) to run without accounts. */
+export declare function AuthClientProvider({ client, children }: {
+    client: AuthClient | null;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * The injected auth client. It is present only where accounts are enabled; the editor reads it
+ * solely inside `accounts`-gated UI, so a missing client there is a wiring error, not a normal path.
+ */
+export declare function useAuthClient(): AuthClient;

package/dist/types/lib/brand.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from "react";
+/**
+ * The product mark the empty canvas shows. It is a port so a host can inject its own mark while the
+ * package stays brand-neutral; the default below is the Isothrum mark (the geometry is shared with
+ * the website's favicon and OG images), themed by the host's `--primary` tokens.
+ */
+export interface BrandMarkProps {
+    className?: string;
+}
+export type BrandMark = (props: BrandMarkProps) => ReactNode;
+/** The default Isothrum mark, themed by `--primary`/`--primary-foreground`. */
+export declare function DefaultBrandMark({ className }: BrandMarkProps): import("react").JSX.Element;
+/** Lets a host replace the editor's product mark. Omit it to keep the default Isothrum mark. */
+export declare function BrandMarkProvider({ mark, children }: {
+    mark: BrandMark;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The product mark in use (the injected one, or the default). */
+export declare function useBrandMark(): BrandMark;

package/dist/types/lib/i18n.d.ts

@@ -0,0 +1,19 @@
+export declare const LOCALES: readonly ["en", "fr", "es", "de"];
+export declare const DEFAULT_LOCALE: "en";
+export type Locale = (typeof LOCALES)[number];
+/** Whether `value` names one of the site's locales. */
+export declare function hasLocale(value: string): value is Locale;
+/** Every locale but `locale`. */
+export declare function otherLocales(locale: string): Locale[];
+export declare const localeNames: Record<Locale, string>;
+/**
+ * Replace (or insert) the locale segment in a pathname.
+ * "/en/blog/foo" + "fr" → "/fr/blog/foo"
+ * "/blog/foo"    + "fr" → "/fr/blog/foo"
+ */
+export declare function withLocale(pathname: string, locale: Locale): string;
+/**
+ * Build the absolute-URL hreflang map for a path that exists in every locale.
+ * Useful for static pages (homepage, /blog index, etc).
+ */
+export declare function hreflangFor(siteUrl: string, pathWithoutLocale: string): Record<string, string>;

package/dist/types/lib/tool/blocks.d.ts

@@ -0,0 +1,35 @@
+import { type Preset } from "./presets";
+import type { EditorText } from "./text";
+/** The toolbar's blocks: a switch, a router, a firewall, a container, a VM, and the saved devices. */
+/** The switch tool's id in the toolbar (devices use their preset ids). */
+export declare const SWITCH_TOOL = "switch";
+/** The LAN tool's id in the toolbar. */
+export declare const LAN_TOOL = "lan";
+export declare const NOTE_TOOL = "note";
+/** One kind a block places: a preset (a device), or the switch tool. */
+export interface BlockOption {
+    tool: string;
+    label: string;
+    hint: string;
+    preset?: Preset;
+    key?: string | null;
+}
+export interface Block {
+    id: string;
+    label: string;
+    options: BlockOption[];
+}
+/** The blocks of the toolbar, each listing the kinds it places (the switch block starts with the switch tool). */
+export declare function deviceBlocks(presets: Preset[], mine: Preset[], t: EditorText): Block[];
+/** What the tool being placed is called, if any (a LAN, a switch, a note, or a device). */
+export declare function toolLabel(tool: string | null, presets: Preset[], t: EditorText): {
+    label: string;
+} | undefined;
+/** Every device the toolbar can place: the built-in ones, then the saved ones. */
+export declare const allPresets: (mine: Preset[]) => Preset[];
+/** The line under the toolbar: what a click does now. */
+export declare function hintFor(tool: string | null, label: string | undefined, state: {
+    hand: boolean;
+    nodes: number;
+    edges: number;
+}, t: EditorText): string;

package/dist/types/lib/tool/cables.d.ts

@@ -0,0 +1,48 @@
+import type { Connection } from "@xyflow/react";
+import { type CableEdge, type LabNode, type LanNode } from "./model";
+/**
+ * Cables saved with the old handles (one on each side of every machine) move onto the current
+ * ones: an appliance's single port, the top or bottom of other machines. LAN handles stay.
+ */
+export declare function migrateEdges(edges: CableEdge[], nodes: LabNode[]): CableEdge[];
+/**
+ * The first free `eth<n>` on a machine, from `first`: an appliance on a LAN's edge uses eth0 on
+ * that LAN, so its cables start at eth1.
+ */
+export declare function nextPort(nodeId: string, edges: CableEdge[], first?: number): string;
+/**
+ * The Isoloom network a cable became (`link-<n>`): cables between two machines are numbered in
+ * the order `toTopology` lists them. A cable to a LAN is that LAN.
+ */
+export declare function networkOfCable(edgeId: string, nodes: LabNode[], edges: CableEdge[]): string | null;
+/** The names of a cable's ends that are machines (a LAN or a switch has no port to cut). */
+export declare function machineEnds(edge: CableEdge, nodes: LabNode[]): string[];
+/** What a cable's ends can plug into, by node id. */
+export interface LabIndex {
+    lanIds: Set<string>;
+    switchIds: Set<string>;
+    routerIds: Set<string>;
+}
+/** A cable's two ends, as React Flow gives them (a connection being drawn, or a cable). */
+interface Ends {
+    source: string;
+    target: string;
+    sourceHandle?: string | null;
+    targetHandle?: string | null;
+}
+/**
+ * Machine to machine, LAN or port. Never LAN to LAN or switch to LAN, and a switch or router
+ * port takes one cable, as on real gear. `ignore`: the cable being moved, whose ends don't count.
+ */
+export declare function canConnect(c: Ends, index: LabIndex, edges: CableEdge[], ignore?: string): boolean;
+/** An appliance on a LAN's edge already uses eth0 there. */
+export declare function onLanEdge(id: string, nodes: LabNode[], lans: LanNode[]): boolean;
+/** A new cable for a connection, its ends labelled (`first(node)`: the first port to give). */
+export declare function newCable(c: Connection, index: LabIndex, edges: CableEdge[], first: (node: string) => number): CableEdge;
+/**
+ * The cables after `old` moved to `c`. A moved end gets the label of where it lands: the switch
+ * port, nothing on a LAN, or the machine's next free port. An end that stays put keeps its label
+ * (same machine: same port; where on its box the cable attaches is only drawing).
+ */
+export declare function reconnected(edges: CableEdge[], old: CableEdge, c: Connection, index: LabIndex, first: (node: string) => number): CableEdge[];
+export {};

package/dist/types/lib/tool/clone.d.ts

@@ -0,0 +1,12 @@
+import type { XYPosition } from "@xyflow/react";
+import { type CableEdge, type LabNode } from "./model";
+/**
+ * Copies of `picked` (and of the cables between them) ready to add to `existing`: new ids,
+ * moved by `offset`, fresh names (web1 -> web3), a LAN with its own free block, no fixed
+ * addresses (they would collide with the originals). VLANs keep their numbers: they are
+ * lab-wide.
+ */
+export declare function cloneLab(picked: LabNode[], edges: CableEdge[], existing: LabNode[], offset: XYPosition): {
+    nodes: LabNode[];
+    edges: CableEdge[];
+};

package/dist/types/lib/tool/conditions.d.ts

@@ -0,0 +1,31 @@
+import type { LinkConditions } from "./model";
+/** Isoloom's `tc` for a slow or lossy link, as the engine's topology takes it. */
+export interface Tc {
+    delay?: string;
+    jitter?: string;
+    loss?: number;
+    rate?: string;
+}
+/** The conditions as Isoloom's `tc` takes them, or `undefined` when none is set. */
+export declare function tcOf(c: LinkConditions | undefined): Tc | undefined;
+/** A short summary for the canvas: `40 ms ±5 · 0.5% · 10 Mbit/s`. */
+export declare function conditionsLabel(c: LinkConditions | undefined): string;
+/** The `tc` fields written as a number and a unit: two times and a rate. */
+type MeasuredField = "delay" | "jitter" | "rate";
+/** A `tc` value the editor can't read: left out of the drawing and reported, never guessed. */
+export interface TcProblem {
+    field: MeasuredField;
+    value: string;
+}
+/** A `tc` read back: the editor's numbers (none when nothing is set), and each value it couldn't read. */
+export interface ReadConditions {
+    conditions: LinkConditions | undefined;
+    problems: TcProblem[];
+}
+/** Isoloom's `tc` back to the editor's numbers: the inverse of `tcOf`, every value it can't read reported. */
+export declare function conditionsOf(tc: Tc | undefined): ReadConditions;
+/** A problem in words, for the `tc` at path `at` in the topology: where, the value, the form it takes. */
+export declare function tcProblemText(at: string, p: TcProblem): string;
+/** The conditions a field edit leaves: a positive number, or the field cleared (none when all are). */
+export declare function withCondition(value: LinkConditions | undefined, key: keyof LinkConditions, raw: string): LinkConditions | undefined;
+export {};

package/dist/types/lib/tool/create.d.ts

@@ -0,0 +1,22 @@
+import type { XYPosition } from "@xyflow/react";
+import { type LabNode, type LanData, type LanNode, type MachineNode, type NoteNode, type SwitchNode } from "./model";
+import type { Preset } from "./presets";
+/** New nodes, as the toolbar places them. */
+export declare function newNote(position: XYPosition): NoteNode;
+/** vlan10 and vlan20: a new switch's VLANs (ports 1–4 and 5–8, both on the trunk). */
+export declare function twoVlans(): SwitchNode["data"];
+/** A new switch with vlan10 on ports 1–4, vlan20 on ports 5–8, both on the trunk. */
+export declare function newSwitch(center: XYPosition, nodes: LabNode[]): SwitchNode;
+export declare function newMachine(preset: Preset, position: XYPosition, nodes: LabNode[]): MachineNode;
+/** The third number of each LAN's 10.10.<n>.0/24 block. */
+export declare function usedThirds(nodes: LabNode[]): Set<number>;
+/** A new LAN centered on `center`, with the next free 10.10.<n>.0/24. */
+export declare function newLan(center: XYPosition, nodes: LabNode[]): LanNode;
+/**
+ * A LAN that hangs under a device placed at `center` (a router or a switch): the device sits on
+ * its top edge, toward the right, so the LAN's label (top left) stays clear and clickable.
+ */
+export declare function lanBelow(center: XYPosition, nodes: LabNode[], data?: Partial<LanData>, size?: {
+    w: number;
+    h: number;
+}): LanNode;

package/dist/types/lib/tool/desktop.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The desktop app's commands (Isothrum desktop loads this editor in its window and exposes them
+ * on `window.__TAURI__`). In a browser there is no such object, and the desktop-only controls
+ * (Run, Stop, Capture) stay hidden.
+ */
+export type Invoke = <T>(command: string, args?: Record<string, unknown>) => Promise<T>;
+export declare function desktop(): Invoke | null;
+/**
+ * Whether the desktop app runs the lab on VMs (with Vagrant): it runs it on Docker whenever Isoloom
+ * generates its Docker files, which a machine drawn as a Linux VM has (its OS and steps build a
+ * container); only a lab with a machine that is a VM only (Windows, a playbook step) needs VMs.
+ */
+export declare function runsOnVms(hasVmNodes: boolean, plan: {
+    files: {
+        path: string;
+    }[];
+} | null): boolean;
+/** One machine now (desktop: `lab_live`): Docker's state, and its health when it has a check. */
+export interface MachineLive {
+    state: string;
+    health: string;
+}
+/** One machine's port on one network now: up, down, or unknown (stopped, or a Cisco OS's). */
+interface PortLive {
+    machine: string;
+    network: string;
+    up: boolean | null;
+    interface: string | null;
+}
+/** The running lab now. `probed`: the ports were read from the machines (not inferred). */
+export interface LabLive {
+    machines: Record<string, MachineLive>;
+    ports: PortLive[];
+    probed: boolean;
+}
+/** A machine at a glance: up, on its way (starting, restarting), unhealthy, or down. */
+export type Status = "up" | "starting" | "unhealthy" | "down";
+export declare function machineStatus(m: MachineLive | undefined): Status;
+/** A link cut while the lab runs: `machine`'s port on `network`, down. */
+export interface SuspendedLink {
+    network: string;
+    machine: string;
+}
+/** A machine saved as an image (desktop: `docker commit`). */
+export interface Snapshot {
+    id: string;
+    machine: string;
+    image: string;
+    label: string;
+    created: number;
+    in_use: boolean;
+}
+export interface DesktopInfo {
+    version: string;
+    docker: boolean;
+    vagrant?: boolean;
+    wireshark: boolean;
+    live_capture: boolean;
+    labs: string;
+}
+/** `docker compose ps --format json`: one JSON object per line. */
+export declare function runningServices(ps: string): number;
+export {};

package/dist/types/lib/tool/draft.d.ts

@@ -0,0 +1,20 @@
+import { type CableEdge, type Design, type Draft, type LabNode } from "./model";
+/** A lab as it is kept: in storage, in a saved project, or in a share link. */
+/** Whether `v` is one of the canvas's looks. */
+export declare const isDesign: (v: unknown) => v is Design;
+/** A lab's nodes and cables as stored: the lab only, no UI state. */
+export declare function storedNodes(nodes: LabNode[]): Pick<LabNode, "id" | "type" | "position" | "data" | "width" | "height">[];
+export declare function storedEdges(edges: CableEdge[], data?: (e: CableEdge) => CableEdge["data"]): CableEdge[];
+/**
+ * A draft from storage or a saved project, made current: LAN behavior, machines' OS names, today's cable handles.
+ * Null when it isn't a lab's shape (a node or a cable that isn't one, as a damaged store holds).
+ */
+export declare function normalizeDraft(d: unknown): Draft | null;
+/** A draft without what is only UI state (selection, drag, measured sizes): what a save keeps. */
+export declare function plainDraft(d: Draft): Draft;
+/**
+ * A lab in a link: its JSON, deflated, in base64url, after `#lab=`. The part after `#` never
+ * reaches a server, so a shared lab stays as private as the editor (the link is the only copy).
+ */
+export declare function encodeLab(draft: Draft): Promise<string>;
+export declare function decodeLab(code: string): Promise<Draft | null>;

package/dist/types/lib/tool/engine.d.ts

@@ -0,0 +1,33 @@
+import type { Addresses } from "./router-ports";
+/**
+ * The engine's JavaScript surface, from `public/wasm/isothrum_wasm.js` (built from
+ * `crates/isothrum-wasm`). Everything runs in the browser: nothing is sent to a server.
+ */
+export interface Engine {
+    default: () => Promise<unknown>;
+    plan_json: (topology: string) => string;
+    bundle: (topology: string) => Uint8Array;
+    /** The lab's own files (provisioning starters, appliance configurations), as JSON. */
+    own_files_json: (topology: string) => string;
+    bundle_target: (topology: string, targetDir: string) => Uint8Array;
+}
+export interface GeneratedFile {
+    path: string;
+    contents: string;
+}
+/** What the engine makes of a lab: isoloom.yml and every target's files, or what is wrong. */
+export interface Plan {
+    ok: boolean;
+    error: string | null;
+    isoloom_yml: string | null;
+    problems: string[];
+    files: GeneratedFile[];
+    skipped: string[];
+    addresses: Addresses;
+}
+/** Loads and starts the engine. */
+export declare function loadEngine(): Promise<Engine>;
+/** The engine's plan for a topology; an engine crash becomes a plan with `error` (from `failed`). */
+export declare function planOf(engine: Engine, topology: string, failed: (error: string) => string): Plan;
+/** The lab's own files (provisioning starters, appliance configurations). */
+export declare function ownFiles(engine: Engine, topology: string): GeneratedFile[];

package/dist/types/lib/tool/examples.d.ts

@@ -0,0 +1,11 @@
+import { type Draft } from "./model";
+/**
+ * A starting lab: an office LAN with a workstation, a servers LAN with a web server and a
+ * database, and a router cabled to both LANs.
+ */
+export declare function exampleLab(): Draft;
+/**
+ * The VLAN example: a switch with vlan10 and vlan20, two PCs on vlan10, a server on vlan20, and a
+ * router on the trunk (router-on-a-stick: one address on each VLAN).
+ */
+export declare function vlanExample(): Draft;

package/dist/types/lib/tool/export-targets.d.ts

@@ -0,0 +1,21 @@
+import type { GeneratedFile } from "./engine";
+/**
+ * The Isoloom outputs in a lab's zip, as the Export window lists them: how each is named for
+ * people, the one Isoloom command that starts it (from the unzipped folder), and the same thing
+ * with the tool itself.
+ */
+/** The words the names take (the editor's text). */
+export interface TargetText {
+    containersAndVms: string;
+    oneVmPerMachine: string;
+    dockerOnOneVm: string;
+}
+export interface Target {
+    dir: string;
+    files: GeneratedFile[];
+    name: string;
+    isoloom: string | null;
+    run: string;
+}
+/** Generated files grouped by where they run: `.isoloom/<target>[/<cloud>]/…`. */
+export declare function groupByTarget(files: GeneratedFile[], t: TargetText): Target[];

package/dist/types/lib/tool/facing.d.ts

@@ -0,0 +1,9 @@
+import { type CableEdge, type LabNode, type LanNode, type Side } from "./model";
+/** The sides ports face: an appliance's by its id, a switch's or router's ports by `<id>:<port>`. */
+export declare function facingSides(nodes: LabNode[], edges: CableEdge[], lans: LanNode[]): Record<string, Side>;
+/**
+ * The cables as drawn: each end attached where things are now (not where the cable was first
+ * drawn), and a cable on a VLAN (a switch access port, a VLAN area, a router port on it) in its
+ * color.
+ */
+export declare function shownCables(nodes: LabNode[], edges: CableEdge[], lans: LanNode[]): CableEdge[];

package/dist/types/lib/tool/geometry.d.ts

@@ -0,0 +1,36 @@
+import type { XYPosition } from "@xyflow/react";
+import { type LabNode, type LanNode, type MachineNode, type Side } from "./model";
+interface Rect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** The area a LAN covers on the canvas. */
+export declare function lanRect(l: LanNode): Rect;
+/** Whether `p` lies within `r`, borders included, give or take `slack`. */
+export declare function within(r: Rect, p: XYPosition, slack?: number): boolean;
+/**
+ * Where an appliance at `position` should go: centered on the nearest LAN border within reach
+ * (half inside, half outside), or where it is when no border is near.
+ */
+export declare function snapToLanEdge(position: XYPosition, lans: LanNode[], size?: {
+    w: number;
+    h: number;
+}): XYPosition;
+/** The LAN border an appliance sits on, if any: the side of the LAN, so its port faces out. */
+export declare function sideOnLan(m: MachineNode, lans: LanNode[]): Side | null;
+/** The LAN an appliance sits on the border of, and which border: its inside and outside. */
+export declare function lanUnder(m: MachineNode, lans: LanNode[]): {
+    lan: LanNode;
+    side: Side;
+} | null;
+/** Whether a point is inside a LAN's area (not on its border). */
+export declare function insideLan(p: XYPosition, l: LanNode): boolean;
+/**
+ * The LANs a machine sits in: its center is inside the area (or on its border). A hidden LAN's
+ * area isn't drawn, so it doesn't take machines by position, except routers and firewalls on
+ * its edge; machines join it through its switch's ports or a cable.
+ */
+export declare function lansAround(m: MachineNode, nodes: LabNode[]): LanNode[];
+export {};

package/dist/types/lib/tool/gns3-cables.d.ts

@@ -0,0 +1,17 @@
+import { type CableEdge, type LabNode, type LanNode, type MachineNode } from "./model";
+/** A GNS3 project's links as cables: machine to machine, or machine to the LAN its switch became. */
+export interface Gns3Wiring {
+    links: [string, string][];
+    /** The machines and the LANs, by GNS3 node id. */
+    machines: Map<string, MachineNode>;
+    lanOf: Map<string, LanNode>;
+    /** Every node of the lab so far (the LANs among them). */
+    nodes: LabNode[];
+    /** A GNS3 LAN's size: which side of it faces a machine goes by its proportions. */
+    lanSize: {
+        w: number;
+        h: number;
+    };
+}
+/** The cables of the project's links (each machine–LAN pair once); hides the LANs that would mislead. */
+export declare function gns3Cables(w: Gns3Wiring): CableEdge[];

package/dist/types/lib/tool/gns3-import.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Opening a GNS3 project (.gns3, the JSON GNS3 saves) as a lab. GNS3 draws switches as boxes
+ * that machines plug into; here they become LANs, the machines cabled to their edge. Docker
+ * nodes keep their image, QEMU/VirtualBox/VMware nodes become VMs (the OS guessed from the
+ * image), VPCS becomes a small container, Cisco routers (Dynamips, IOU) automatic routers, a NAT
+ * or cloud gives its LAN the internet, and text drawings become notes. What can't come across
+ * (an IOS configuration, a node type with no equivalent) is reported, not silently dropped.
+ */
+import { type Gns3Text } from "./gns3-parts";
+import { type Draft } from "./model";
+/** `text`: the editor's words for what goes wrong (warnings and errors are shown as they are). */
+export declare function fromGns3(source: string, text: Gns3Text): {
+    lab: Draft;
+    warnings: string[];
+};