EXPLORATION 03 / 06
Typed edges

What this showsCompare edge geometry and semantics without leaving the canvas. Each connection carries a type, marker, label, and optional animation.
inputIncoming payload
One event enters the flow
transformProcess event
Three connections, three meanings
sinkStore the data
Data · solid curve
sinkTrigger the next step
Control · dashed elbow
sinkCatch a failure
Error · dotted step
Svelte Flow
4 typed edges 1 animated
What this shows
Geometry is independent from meaning: data is a solid route, control is a dashed instruction, and error is a dotted recovery path. Drag any handle to add another labeled data edge.
Data
Control
Error
Under the hood SVELTE 5View source
src/routes/demo/edges/+page.svelte
<script lang="ts">
  import {
    Background,
    BackgroundVariant,
    Controls,
    MiniMap,
    Panel,
    SvelteFlow
  } from '@xyflow/svelte';
  import type { Connection } from '@xyflow/svelte';
  import DemoShell from '$lib/components/DemoShell.svelte';
  import StudioNode from '$lib/components/StudioNode.svelte';
  import TypedEdge from '$lib/components/TypedEdge.svelte';
  import { createDemoGraph, createEdge, type FlowEdge, type FlowNode } from '$lib/flow/graph';
  import source from './+page.svelte?raw';


  type PathVariant = 'bezier' | 'smoothstep' | 'straight';

  const nodeTypes = {
    input: StudioNode,
    transform: StudioNode,
    branch: StudioNode,
    sink: StudioNode,
    note: StudioNode
  };
  const edgeTypes = {
    bezier: TypedEdge,
    smoothstep: TypedEdge,
    straight: TypedEdge
  };

  const pathVariants: { value: PathVariant; label: string }[] = [
    { value: 'bezier', label: 'Bezier · expressive curve' },
    { value: 'smoothstep', label: 'Smoothstep · right-angle flow' },
    { value: 'straight', label: 'Straight · shortest route' }
  ];

  const cloneGraph = () => {
    const graph = createDemoGraph('edges');
    return {
      nodes: graph.nodes.map((node) => ({
        ...node,
        position: { ...node.position },
        data: { ...node.data, params: { ...node.data.params } }
      })),
      edges: graph.edges.map((edge) => ({
        ...edge,
        type: edge.data.kind === 'control' ? 'smoothstep' : edge.data.kind === 'error' ? 'straight' : 'bezier',
        data: { ...edge.data }
      }))
    } satisfies { nodes: FlowNode[]; edges: FlowEdge[] };
  };

  const initialGraph = cloneGraph();
  const initialAnimated = initialGraph.edges.some((edge) => edge.animated);
  let nodes = $state.raw<FlowNode[]>(initialGraph.nodes);
  let edges = $state.raw<FlowEdge[]>(initialGraph.edges);
  let pathVariant = $state<PathVariant>('bezier');
  let animateEdges = $state(initialAnimated);
  let edgeSerial = 0;

  let animatedCount = $derived(edges.filter((edge) => edge.animated).length);
  let edgeCount = $derived(edges.length);

  function resetGraph() {
    const graph = cloneGraph();
    nodes = graph.nodes;
    edges = graph.edges;
    pathVariant = 'bezier';
    animateEdges = graph.edges.some((edge) => edge.animated);
    edgeSerial = 0;
  }

  function applyPathVariant(event: Event) {
    const value = (event.currentTarget as HTMLSelectElement).value;
    if (value !== 'bezier' && value !== 'smoothstep' && value !== 'straight') return;
    pathVariant = value;
    edges = edges.map((edge) => ({ ...edge, type: pathVariant }));
  }

  function applyAnimation(event: Event) {
    animateEdges = (event.currentTarget as HTMLInputElement).checked;
    edges = edges.map((edge) => ({ ...edge, animated: animateEdges }));
  }

  function onBeforeConnect(connection: Connection): FlowEdge | false {
    if (!connection.source || !connection.target) return false;

    edgeSerial += 1;
    return {
      ...createEdge(
        `typed-connection-${edgeSerial}`,
        connection.source,
        connection.target,
        'data',
        {
          sourceHandle: connection.sourceHandle ?? null,
          targetHandle: connection.targetHandle ?? null
        }
      ),
      type: pathVariant,
      label: 'data',
      animated: animateEdges
    };
  }


  function minimapNodeColor(node: { type?: string }) {
    if (node.type === 'input') return 'var(--accent)';
    if (node.type === 'sink') return 'var(--ink)';
    if (node.type === 'transform') return 'var(--accent-soft)';
    return 'var(--muted)';
  }
</script>

<DemoShell
  slug="edges"
  title="Typed edges"
  description="Compare edge geometry and semantics without leaving the canvas. Each connection carries a type, marker, label, and optional animation."
  {source}
>
  {#snippet toolbar()}
    <div class="toolbar-group" aria-label="Typed edge controls">
      <label class="control-field" for="path-variant">
        <span>Path geometry</span>
        <select id="path-variant" class="select select-sm" onchange={applyPathVariant}>
          {#each pathVariants as variant}
            <option value={variant.value}>{variant.label}</option>
          {/each}
        </select>
      </label>
      <label class="animation-control" for="animate-edges">
        <input
          id="animate-edges"
          class="toggle toggle-sm"
          type="checkbox"
          checked={animateEdges}
          onchange={applyAnimation}
        />
        <span>Animate all</span>
      </label>
      <button class="btn btn-sm btn-outline" type="button" onclick={resetGraph}>Reset edges</button>
    </div>
  {/snippet}

  {#snippet info()}
    <div class="info-layout">
      <div>
        <p class="eyebrow">What this shows</p>
        <p class="info-copy">
          Geometry is independent from meaning: <strong>data</strong> is a solid route,
          <strong>control</strong> is a dashed instruction, and <strong>error</strong> is a dotted
          recovery path. Drag any handle to add another labeled data edge.
        </p>
      </div>
      <ul class="edge-legend" aria-label="Edge type legend">
        <li><span class="legend-line data-line" aria-hidden="true"></span><span>Data</span></li>
        <li><span class="legend-line control-line" aria-hidden="true"></span><span>Control</span></li>
        <li><span class="legend-line error-line" aria-hidden="true"></span><span>Error</span></li>
      </ul>
    </div>
  {/snippet}

  <SvelteFlow
    id="demo-edges"
    bind:nodes
    bind:edges
    {nodeTypes}
    {edgeTypes}
    onbeforeconnect={onBeforeConnect}
    fitView
    fitViewOptions={{ padding: 0.18 }}
    nodesConnectable
    nodesDraggable
    aria-label="Typed edge workflow canvas"
  >
    <Background variant={BackgroundVariant.Dots} patternColor="var(--line)" gap={24} size={1.2} />
    <Controls />
    <MiniMap nodeColor={minimapNodeColor} pannable zoomable />
    <Panel position="bottom-left">
      <div class="canvas-status">
        <span class="status-dot" aria-hidden="true"></span>
        <span>{edgeCount} typed edges</span>
        <span class="status-divider" aria-hidden="true"></span>
        <span>{animatedCount} animated</span>
      </div>
    </Panel>
  </SvelteFlow>
</DemoShell>

<style>
  .toolbar-group {
    display: flex;
    align-items: flex-end;
    flex-wrap: wrap;
    gap: 0.7rem;
  }

  .control-field,
  .animation-control {
    display: inline-flex;
    align-items: center;
    gap: 0.45rem;
    color: var(--muted);
    font-size: 0.75rem;
    font-weight: 650;
  }

  .control-field {
    flex-direction: column;
    align-items: flex-start;
    gap: 0.2rem;
  }

  .control-field select {
    min-width: 13rem;
  }

  .animation-control {
    align-self: center;
    margin: 0 0.25rem;
    white-space: nowrap;
  }

  .info-layout {
    display: flex;
    align-items: flex-start;
    justify-content: space-between;
    gap: 1.5rem;
  }

  .eyebrow {
    margin: 0;
    color: var(--accent);
    font-size: 0.7rem;
    font-weight: 700;
    letter-spacing: 0.12em;
    text-transform: uppercase;
  }

  .info-copy {
    max-width: 47rem;
    margin: 0.35rem 0 0;
    color: var(--muted);
    font-size: 0.875rem;
    line-height: 1.6;
  }

  .info-copy strong {
    color: var(--ink);
    font-weight: 700;
  }

  .edge-legend {
    display: flex;
    flex: 0 0 auto;
    flex-wrap: wrap;
    align-items: center;
    gap: 0.75rem;
    margin: 0.2rem 0 0;
    padding: 0;
    color: var(--muted);
    font-size: 0.72rem;
    list-style: none;
  }

  .edge-legend li {
    display: inline-flex;
    align-items: center;
    gap: 0.35rem;
  }

  .legend-line {
    display: inline-block;
    width: 1.6rem;
    height: 0.15rem;
    background: var(--accent);
  }

  .control-line {
    background: repeating-linear-gradient(90deg, var(--accent) 0 0.36rem, transparent 0.36rem 0.65rem);
  }

  .error-line {
    background: repeating-linear-gradient(90deg, var(--muted) 0 0.12rem, transparent 0.12rem 0.28rem);
  }

  :global(.svelte-flow__panel) {
    margin: 0.85rem;
  }

  .canvas-status {
    display: flex;
    align-items: center;
    gap: 0.45rem;
    border: 1px solid var(--line);
    border-radius: 0.5rem;
    padding: 0.45rem 0.6rem;
    color: var(--muted);
    background: var(--surface);
    box-shadow: 0 0.35rem 1rem color-mix(in srgb, var(--ink) 8%, transparent);
    font-size: 0.7rem;
    white-space: nowrap;
  }

  .status-dot {
    width: 0.45rem;
    height: 0.45rem;
    border-radius: 999px;
    background: var(--accent);
  }

  .status-divider {
    width: 1px;
    height: 0.8rem;
    background: var(--line);
  }

  @media (max-width: 620px) {
    .info-layout {
      display: block;
    }

    .edge-legend {
      margin-top: 0.9rem;
    }

    .control-field select {
      min-width: 11.5rem;
      max-width: 100%;
    }

    :global(.svelte-flow__panel) {
      margin: 0.55rem;
    }
  }
</style>
The actual route source, imported with ?raw. Shared components and graph utilities live in src/lib.