Let a Sequence grow an output as you connect the last one

The Outputs setting is gone. A Sequence now keeps one free output below the
last connected one: nothing plugged in is one output, connecting the spare
grows a new one, unplugging the bottom edge shrinks it back.

It counts the last *connected* port rather than the number of edges, so
unplugging a middle one leaves a gap instead of silently dropping an edge.

Removing the setting also removes a bug it caused. Typing in the Outputs field
did nothing and the arrow keys did nothing, while dragging the value worked:
onInput fires per keystroke, the preview writes into node.params, that emits
'project', and Inspector.refreshValues() sees the node's signature change --
the port list is part of it -- so it rebuilds and destroys the row being typed
in. A drag survives because it keeps receiving globalpointermove on the old
widget. refreshValues() has no focus guard where refreshLive() does; the trap
is still there for the next typed field that changes a node's shape.

Ports that depend on the edges around a node mean derivePorts needs the graph,
not just the params, so resolveDef and portSignature take it too. And a node
whose ports are derived cannot know how many it has from its type, so run is
handed the definition resolved for it.

src/core/graph/GraphInterpreter.ts

@@ -95,7 +95,7 @@ export class GraphInterpreter {
     const def = this.def(node);
     if (!def?.run) return;
     const inputs = this.collectInputs(node, ctx);
-    const result = def.run(ctx, inputs, node.params);
+    const result = def.run(ctx, inputs, node.params, def);
     const returned = result.call ? this.call(result.call, ctx, depth) : {};
     this.frame.outputCache.set(node.id, { ...result.outputs, ...returned });
     this.trace?.onNode(node.id);
@@ -174,14 +174,14 @@ export class GraphInterpreter {
       throw new Error('Behavior graph exceeded the step limit (data cycle?)');
     // Mark before evaluating so a data cycle reads null instead of recursing forever.
     this.frame.dataCache.set(nodeId, {});
-    const outputs = def.run(ctx, this.collectInputs(source, ctx), source.params).outputs ?? {};
+    const outputs = def.run(ctx, this.collectInputs(source, ctx), source.params, def).outputs ?? {};
     this.frame.dataCache.set(nodeId, outputs);
     this.trace?.onNode(nodeId);
     return outputs[port] ?? null;
   }
 
   private def(node: GraphNode) {
-    return resolveDef(node, this.behaviors);
+    return resolveDef(node, this.frame.graph, this.behaviors);
   }
 
   private node(id: string): GraphNode | undefined {

src/core/graph/NodeRegistry.ts

@@ -1,6 +1,6 @@
 import type { PropertyBag, PropertyValue } from '../model/Properties';
 import type { PropertyDef } from '../properties/PropertySchema';
-import type { PortType } from './Graph';
+import type { Graph, GraphNode, PortType } from './Graph';
 import type { BehaviorLookup } from './lookup';
 import type { NodeContext } from './NodeContext';
 import { asBoolean, asNumber, asString, type Value } from './values';
@@ -42,9 +42,10 @@ export interface RunResult {
   call?: CallResult;
 }
 
-/** What a node may compute its ports from: its own settings, and the behaviors around it. */
+/** What a node may compute its ports from: itself, the graph it sits in, and the behaviors around it. */
 export interface PortSource {
-  params: PropertyBag;
+  node: GraphNode;
+  graph: Graph;
   behaviors: BehaviorLookup;
 }
 
@@ -83,8 +84,10 @@ export interface NodeDef {
   /**
    * Pure data nodes are evaluated on demand when a downstream input needs their value; exec nodes
    * run when the flow reaches them. Event nodes have no `run` – the interpreter seeds their outputs.
+   * `def` is this definition as resolved for the node at hand, which is the only way a node with
+   * derived ports can know how many it has.
    */
-  run?(ctx: NodeContext, inputs: Record<string, Value>, params: PropertyBag): RunResult;
+  run?(ctx: NodeContext, inputs: Record<string, Value>, params: PropertyBag, def: NodeDef): RunResult;
 }
 
 const defs = new Map<string, NodeDef>();

src/core/graph/dropTarget.ts

@@ -12,7 +12,7 @@ export interface PortSide {
 
 export function portTypeOf(graph: Graph, side: PortSide, lookup: BehaviorLookup): PortType | undefined {
   const node = findNode(graph, side.nodeId);
-  const def = node && resolveDef(node, lookup);
+  const def = node && resolveDef(node, graph, lookup);
   const list = side.isOutput ? def?.outputs : def?.inputs;
   return list?.find((p) => p.key === side.port)?.type;
 }
@@ -40,7 +40,7 @@ export function dropTargetPort(
 ): PortSide | null {
   if (nodeId === from.nodeId) return null;
   const node = findNode(graph, nodeId);
-  const def = node && resolveDef(node, lookup);
+  const def = node && resolveDef(node, graph, lookup);
   const fromType = portTypeOf(graph, from, lookup);
   if (!def || fromType === undefined) return null;
   const candidates = compatiblePorts(def, fromType, from.isOutput)

src/core/graph/nested.ts

@@ -41,12 +41,12 @@ export function declaredPorts(graph: Graph | undefined, type: string): PortDef[]
  * The node definition as it applies to *this* node: identical to the registered one, unless the
  * type declares ports per node (`declaresPorts`) or computes them (`derivePorts`).
  */
-export function resolveDef(node: GraphNode, lookup: BehaviorLookup): NodeDef | undefined {
+export function resolveDef(node: GraphNode, graph: Graph, lookup: BehaviorLookup): NodeDef | undefined {
   const def = nodeDef(node.type);
   if (!def || (!def.declaresPorts && !def.derivePorts)) return def;
   const own = def.declaresPorts ? (node.ports ?? []).map(portDefOf) : [];
   const side = (which: 'inputs' | 'outputs') => (def.declaresPorts === which ? own : []);
-  const grown = def.derivePorts?.({ params: node.params, behaviors: lookup }) ?? {};
+  const grown = def.derivePorts?.({ node, graph, behaviors: lookup }) ?? {};
   return {
     ...def,
     label: grown.label ?? def.label,
@@ -74,8 +74,8 @@ export function callProblem(node: GraphNode, lookup: BehaviorLookup, ownerId = '
  * Everything that changes how a node looks, as one string. Views and the inspector rebuild when it
  * changes – a port list that is derived rather than fixed has no other way of being noticed.
  */
-export function portSignature(node: GraphNode, lookup: BehaviorLookup, ownerId = ''): string {
-  const def = resolveDef(node, lookup);
+export function portSignature(node: GraphNode, graph: Graph, lookup: BehaviorLookup, ownerId = ''): string {
+  const def = resolveDef(node, graph, lookup);
   if (!def) return 'missing';
   const list = (ports: PortDef[]) => ports.map((p) => `${p.key}:${p.type}`).join(',');
   return `${node.type}|${def.label}|${list(def.inputs)}|${list(def.outputs)}|${

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

@@ -18,8 +18,8 @@ export const RunBehavior: NodeDef = {
   inputs: [exec()],
   outputs: [exec()],
   params: [{ key: BEHAVIOR_PARAM, label: 'Behavior', kind: 'asset', default: '', assetTypes: ['behavior'] }],
-  derivePorts: (source) => {
-    const program = source.behaviors(textOf(source.params[BEHAVIOR_PARAM] ?? ''));
+  derivePorts: ({ node, behaviors }) => {
+    const program = behaviors(textOf(node.params[BEHAVIOR_PARAM] ?? ''));
     return {
       // The graph reads as what it does, not as a row of identical "Run behavior" boxes.
       label: program?.name,

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

@@ -1,21 +1,28 @@
-import type { PropertyBag } from '../../../model/Properties';
+import type { Graph, GraphNode } from '../../Graph';
 import type { NodeDef } from '../../NodeRegistry';
-import { asNumber } from '../../values';
 import { exec } from '../shared';
 
-const COUNT = 'count';
-/** Below two outputs a Sequence is just a link, so two are fixed and the rest are derived. */
-const FIXED = 2;
 /** One letter per output, so `a` stays `a` – the alphabet is what sets the ceiling. */
 const MAX = 26;
 
-export function sequenceKey(index: number): string {
+function sequenceKey(index: number): string {
   return String.fromCharCode(97 + index);
 }
 
-export function sequenceCount(params: PropertyBag): number {
-  const count = Math.round(asNumber(params[COUNT] ?? 3));
-  return Math.max(FIXED, Math.min(MAX, count));
+function sequenceIndex(key: string): number {
+  return key.length === 1 ? key.charCodeAt(0) - 97 : -1;
+}
+
+/**
+ * One free output below the last connected one: plugging into the spare grows the node, unplugging
+ * the bottom edge shrinks it again. No output can vanish while an edge hangs on it, which is why
+ * this counts the last *connected* port rather than the connected ones.
+ */
+function outputCount(node: GraphNode, graph: Graph): number {
+  let last = -1;
+  for (const edge of graph.edges)
+    if (edge.from.node === node.id) last = Math.max(last, sequenceIndex(edge.from.port));
+  return Math.min(MAX, last + 2);
 }
 
 function outputAt(index: number) {
@@ -23,23 +30,19 @@ function outputAt(index: number) {
 }
 
 /**
- * The keys are `a`, `b`, `c`, … rather than `out1`…`outN`: those three are what every Sequence
- * saved so far names its outputs, and renaming them would drop the edges hanging on them.
+ * The keys are `a`, `b`, `c`, … rather than `out1`…`outN`: that is what every Sequence saved so far
+ * names its outputs, and renaming them would drop the edges hanging on them.
  */
 export const Sequence: NodeDef = {
   type: 'Sequence',
   label: 'Sequence',
   category: 'flow',
-  description: 'Runs its outputs one after another.',
+  description: 'Runs its outputs one after another. A new output appears as you connect the last one.',
   inputs: [exec()],
-  outputs: [outputAt(0), outputAt(1)],
-  params: [
-    { key: COUNT, label: 'Outputs', kind: 'number', default: 3, min: FIXED, max: MAX, step: 1, decimals: 0 },
-  ],
-  derivePorts: ({ params }) => ({
-    outputs: Array.from({ length: sequenceCount(params) - FIXED }, (_, i) => outputAt(FIXED + i)),
-  }),
-  run: (_ctx, _inputs, params) => ({
-    next: Array.from({ length: sequenceCount(params) }, (_, i) => sequenceKey(i)),
+  outputs: [outputAt(0)],
+  params: [],
+  derivePorts: ({ node, graph }) => ({
+    outputs: Array.from({ length: outputCount(node, graph) - 1 }, (_, i) => outputAt(i + 1)),
   }),
+  run: (_ctx, _inputs, _params, def) => ({ next: def.outputs.map((p) => p.key) }),
 };