A transition carries a name, so a state needs no visible port (#52)

A state keeps its `in`/`out` exec pins in the model and the editor never draws
them. That is the whole trick: connecting, undo, deleting a state and saving all
keep working untouched, because `normalizeGraph` filters nodes and never edges,
and no edge ever checks its port key against a NodeDef. Only two places change --
`NodeView.redraw` stops drawing the row, and `portAt` refuses to hand one out, so
an invisible pin cannot be grabbed either.

Transitions are drawn by right-clicking a state, `Make transition`, then clicking
the target. The armed mode takes the same shape as a live drag, so the existing
preview draws it with no second code path, and it dies with Escape, a click on
empty canvas or a switch to another asset.

Removing the pins removed the only handle a transition had: edges have no
hit-test anywhere, and the pin right-click was the sole route to Disconnect.
The inspector's TRANSITIONS OUT / TRANSITIONS IN lists are therefore not a
convenience, they are the delete path.

`GraphEdge` gained an optional `label`, which `normalizeGraph` has to pass
through explicitly or a saved name is dropped on load. `State transition`
replaces `Next state`: it takes the machine on an input port and the name from a
picker, and resolves against the *current* state. Names are deliberately not
unique across a machine -- two states may both have an `alarm` -- so a node named
`alarm` moves whichever state has one, and an empty name follows the single
unnamed edge.

The geometry moved to a Pixi-free `transitions.ts`: a gap to the box border, and
a fan that puts a pair of opposite edges beside each other instead of on top of
each other. Keeping it as plain maths is what let a screenshot bug become a unit
test -- an earlier pin-to-pin line ran under the target node and took its
arrowhead with it, because `nodeLayer` sits above `edgeLayer`.

One limit stands and is not fixed here: `ConnectCommand` rejects a second edge
between the same two states ("Already connected"), because every transition
hangs off the same two ports. With names, `A --alarm--> B` beside
`A --seen--> B` is a sensible pair, so this is worth its own issue.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/core/graph/nodes/flow/StateTransition.ts

@@ -0,0 +1,28 @@
+import { textOf } from '../../../model/Properties';
+import { flatDef } from '../../../properties/PropertySchema';
+import type { NodeDef } from '../../NodeRegistry';
+import { machinePort, STATE_TRANSITION, TRANSITION_PARAM, transitionTo } from '../../stateMachine';
+import { asString } from '../../values';
+import { exec } from '../shared';
+
+/** What the transitions drawn in the machine are for at runtime: one step along a named arrow. */
+export const StateTransition: NodeDef = {
+  type: STATE_TRANSITION,
+  label: 'State transition',
+  category: 'action',
+  description:
+    "Takes the transition of this name out of the machine's current state, then continues. " +
+    'Nothing happens when that state has no transition of the name.',
+  inputs: [exec(), machinePort()],
+  outputs: [exec()],
+  params: [flatDef(TRANSITION_PARAM, 'text', { label: 'Transition', value: '' })],
+  run: (ctx, inputs, params, _def, _entry, lookup) => {
+    const id = asString(inputs.machine);
+    const current = ctx.states[id] ?? '';
+    const machine = current ? lookup.machine(id) : null;
+    const name = textOf(params[TRANSITION_PARAM] ?? '');
+    const target = machine ? transitionTo(machine, current, name) : '';
+    if (target) ctx.states[id] = target;
+    return { next: 'exec' };
+  },
+};

src/core/graph/nodes/index.ts

@@ -89,6 +89,7 @@ import { RunBehavior } from './flow/RunBehavior';
 import { Sequence } from './flow/Sequence';
 import { SetState } from './flow/SetState';
 import { StateBranch } from './flow/StateBranch';
+import { StateTransition } from './flow/StateTransition';
 import { PARTICLE_NODES } from '../../particles/nodes';
 import { SHADER_NODES } from '../../shader/nodes';
 import { State } from '../stateMachine';
@@ -120,6 +121,7 @@ export const BUILT_IN_NODES: readonly NodeDef[] = [
   RunBehavior,
   StateBranch,
   SetState,
+  StateTransition,
   BehaviorEnd,
   Variables,
   Self,