A shared value belongs to no behavior, so it becomes an asset of its own (#91)

This reverses the design of the previous commit. `PropertyDef.scope` is gone
without replacement: a behavior variable is an object property again, without
exception, and sharing is something you point at rather than something you
declare twice.

A **Variables asset** is declarations and nothing else -- no graph, no position,
never placed, no tab of its own (`TAB_OF_ASSET` is already `Partial<>`, so that
costs no line). A `Variables` node names one through its new `variablesAsset`
setting, empty meaning the behavior's own variables as before, and then reads
and writes one value per key for the whole run. Its property list follows the
chosen source, which was the actual request: a value another graph declared is
now offerable, where before every participant had to declare the name itself.

That deletes more than it adds (-72 lines net): `globalConflicts` and its
run-stopping kind clash, `SetVariableScopeCommand`, the scope picker, both
object-inspector filters and the "shared by the whole run" note on the placed
object. A typo is no longer a silent second variable -- naming an asset is
picking from a list. And two Variables assets may carry the same key without
meeting, because the asset is the key, not the name. The one shape it copies is
the one that already existed: `Set state` picks its machine the same way.

Lifetime is unchanged. The bag is built at `BehaviorSystem.start()` from the
declarations and never written back, so playing in the editor cannot change the
project -- which is the whole reason a counter must not be an object property
(`World.syncToModel` would `commit()` it, and the coin counter would stand at 7
for good).

Full symmetry across that gap, without mirroring anything. Two named wires:
`Inspector.liveVariables` shows the values as they stand while a run is on and
falls back to the declarations when it ends, and `adoptDeclarations()` takes a
key into the run *only where the document changed it since the last sync*.
Without that condition any unrelated project edit would snap a running counter
back to its starting value; a counter-test bends exactly that and falls over.
Nothing was ever cached, incidentally: `GraphInterpreter` only pulse-caches
nodes without a `read`, and the variable node has one. The wire was missing.

The state machine `Scope` row is now an ordinary `enum` row through
`createFieldRow`. It was hand-built from an `HStack` with a ghost dropdown and
began ~34px left of every value above it; the explanations beside `Local` and
`Global` are gone from the menu, the sentence below the row keeps saying it.
Machine scope is otherwise untouched -- `StateMachineAsset.scope`,
`SetMachineScopeCommand`, `stateBag()` and its persistence all stand, so #59
stays closed as built and `Scope` as a type now carries machines alone.

Six counter-proofs, each biting at its own guard. One of them did not bite at
first: the suggestion list was computed twice, in `nodeSection` and
`portSection`, so only the browser test covered the request itself. It is one
named function now, `variableChoices`, with a unit test of its own.

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

src/core/graph/NodeContext.ts

@@ -70,12 +70,12 @@ export interface PointerState {
 }
 
 /**
- * What `global` declarations share for the length of one run: one value per variable name, one
- * current state per machine. A key that is not in here is not shared – which is what lets a behavior
- * declaring the same name for itself keep its own value (see `graph/sharedState.ts`).
+ * What is shared for the length of one run: the values of each Variables asset, keyed by its id,
+ * and the current state of each `global` machine. Two Variables assets may declare the same name
+ * without meeting, since a node names the asset it reads (see `graph/sharedState.ts`).
  */
 export interface SharedState {
-  variables: PropertyBag;
+  variables: Record<string, PropertyBag>;
   states: Record<string, string>;
 }
 

src/core/graph/nested.ts

@@ -1,6 +1,6 @@
-import { textOf } from '../model/Properties';
+import { type PropertyBag, textOf } from '../model/Properties';
 import { isTaggedKind } from '../properties/kinds';
-import { flatDef, isValidFieldName } from '../properties/PropertySchema';
+import { flatDef, isValidFieldName, type PropertyDef } from '../properties/PropertySchema';
 import { type DeclaredPort, declaredPortType, type Graph, type GraphEdge, type GraphNode } from './Graph';
 import type { GraphLookup } from './lookup';
 import { nodeDef, type NodeDef, type PortDef } from './NodeRegistry';
@@ -12,6 +12,20 @@ export const VARIABLES = 'Variables';
 export const PROPERTIES = 'Properties';
 
 export const BEHAVIOR_PARAM = 'behavior';
+export const VARIABLES_PARAM = 'variablesAsset';
+
+/** Whose declarations a `Variables` node reads; empty is the behavior the node sits in. */
+export const VARIABLES_SETTING: PropertyDef = {
+  key: VARIABLES_PARAM,
+  label: 'Variables',
+  kind: 'asset',
+  default: '',
+  assetTypes: ['variables'],
+};
+
+export function variablesSourceOf(params: PropertyBag): string {
+  return textOf(params[VARIABLES_PARAM] ?? '');
+}
 
 /**
  * Nodes whose declared ports are not names of their own but variables of the behavior around them.

src/core/graph/nodes/variable/Variables.ts

@@ -1,6 +1,6 @@
-import { collapsedTitle, portDefOf, VARIABLES } from '../../nested';
+import { collapsedTitle, portDefOf, VARIABLES, VARIABLES_SETTING, variablesSourceOf } from '../../nested';
 import { type NodeDef, withInlineDefault } from '../../NodeRegistry';
-import { readableVariables, variableBag } from '../../sharedState';
+import { variableBag } from '../../sharedState';
 import { writeTyped } from '../../values';
 import { exec } from '../shared';
 
@@ -13,11 +13,11 @@ export const Variables: NodeDef = {
   label: 'Variables',
   category: 'variable',
   description:
-    "Reads this behavior's variables at any time. Those switched to Set are written together when " +
-    'the flow arrives, and a read after that sees the new value.',
+    "Reads variables at any time: this behavior's own, or those of a Variables asset, which every " +
+    'graph pointing at it shares. Those switched to Set are written when the flow arrives.',
   inputs: [],
   outputs: [],
-  params: [],
+  params: [VARIABLES_SETTING],
   declaresPorts: 'both',
   declaredPort: (port) => withInlineDefault(portDefOf(port)),
   derivePorts: ({ node }) => {
@@ -25,10 +25,10 @@ export const Variables: NodeDef = {
     const shape = ports.some((p) => p.write) ? { inputs: [exec()], outputs: [exec()] } : {};
     return node.collapsed ? { ...shape, label: collapsedTitle(ports, 'variables') } : shape;
   },
-  read: (ctx) => readableVariables(ctx),
-  run: (ctx, inputs, _params, def) => {
-    for (const port of def.inputs)
-      if (port.type !== 'exec') writeTyped(variableBag(ctx, port.key), port.key, inputs[port.key]);
+  read: (ctx, params) => variableBag(ctx, variablesSourceOf(params)),
+  run: (ctx, inputs, params, def) => {
+    const bag = variableBag(ctx, variablesSourceOf(params));
+    for (const port of def.inputs) if (port.type !== 'exec') writeTyped(bag, port.key, inputs[port.key]);
     return { next: 'exec' };
   },
 };

src/core/graph/sharedState.ts

@@ -1,115 +1,70 @@
-import type { Asset } from '../model/Asset';
-import type { PropertyBag, PropertyValue } from '../model/Properties';
+import type { PropertyBag } from '../model/Properties';
 import type { Project } from '../model/Project';
 import { isGlobal } from '../model/Scope';
-import type { PropertyDef } from '../properties/PropertySchema';
 import type { NodeContext, SharedState } from './NodeContext';
 
 export function emptySharedState(): SharedState {
   return { variables: {}, states: {} };
 }
 
+/** What every Variables asset declares right now: the value set on the asset, else the default. */
+export function declaredVariables(project: Project): Record<string, PropertyBag> {
+  const declared: Record<string, PropertyBag> = {};
+  for (const asset of project.assets) {
+    if (asset.type !== 'variables') continue;
+    const bag: PropertyBag = {};
+    for (const def of asset.variables) bag[def.key] = asset.props[def.key] ?? def.default;
+    declared[asset.id] = bag;
+  }
+  return declared;
+}
+
 /**
- * Built once per run, from the declarations rather than from any instance: a global variable exists
- * even before the behavior declaring it is placed. Two behaviors declaring the same name mean the
- * same variable – the first declaration sets the starting value (see `globalConflicts`).
+ * Built once per run, from the declarations rather than from any instance: a Variables asset holds
+ * its values whether or not a graph ever reads them, and nothing is written back when the run ends.
  */
 export function buildSharedState(project: Project): SharedState {
-  const shared = emptySharedState();
-  for (const asset of project.assets) {
-    if (asset.type === 'behavior') {
-      for (const def of asset.variables)
-        if (isGlobal(def) && !(def.key in shared.variables))
-          shared.variables[def.key] = asset.props[def.key] ?? def.default;
-    } else if (asset.type === 'statemachine' && isGlobal(asset)) {
-      shared.states[asset.id] = '';
-    }
-  }
+  const shared: SharedState = { variables: declaredVariables(project), states: {} };
+  for (const asset of project.assets)
+    if (asset.type === 'statemachine' && isGlobal(asset)) shared.states[asset.id] = '';
   return shared;
 }
 
 /**
- * Where two behaviors disagree about the same global name. A different kind is an error – one of the
- * two would silently read a value of a type it never declared – while a different starting value is
- * only a warning, since the first declaration decides and the run is well defined either way.
+ * Moves edits made to the declarations during a run into the values it shares. A key is taken over
+ * only where the document changed it since `seen`, which is what leaves a value a graph has moved
+ * on alone – the panel can show the running value and set it without the two fighting.
  */
-export interface GlobalConflict {
-  key: string;
-  severity: 'error' | 'warning';
-  message: string;
-}
-
-export function globalConflicts(project: Project): GlobalConflict[] {
-  const first = new Map<string, { def: PropertyDef; asset: string; value: PropertyValue }>();
-  const conflicts: GlobalConflict[] = [];
-  const seen = new Set<string>();
-  for (const asset of project.assets) {
-    if (asset.type !== 'behavior') continue;
-    for (const def of asset.variables) {
-      if (!isGlobal(def)) continue;
-      const value = asset.props[def.key] ?? def.default;
-      const held = first.get(def.key);
-      if (!held) {
-        first.set(def.key, { def, asset: asset.name, value });
-        continue;
-      }
-      // One report per name: a third behavior disagreeing adds nothing the first line does not say.
-      if (seen.has(def.key)) continue;
-      if (held.def.kind !== def.kind) {
-        seen.add(def.key);
-        conflicts.push({
-          key: def.key,
-          severity: 'error',
-          message: `Global variable "${def.key}" is a ${held.def.kind} in ${held.asset} and a ${def.kind} in ${asset.name}.`,
-        });
-      } else if (!sameValue(held.value, value)) {
-        seen.add(def.key);
-        conflicts.push({
-          key: def.key,
-          severity: 'warning',
-          message: `Global variable "${def.key}" starts at ${display(held.value)} in ${held.asset} and at ${display(value)} in ${asset.name}; the first is used.`,
-        });
-      }
+export function adoptDeclarations(
+  live: Record<string, PropertyBag>,
+  seen: Record<string, PropertyBag>,
+  now: Record<string, PropertyBag>,
+): void {
+  for (const [assetId, declared] of Object.entries(now)) {
+    const bag = live[assetId];
+    if (!bag) {
+      live[assetId] = { ...declared };
+      continue;
     }
+    const before = seen[assetId] ?? {};
+    for (const [key, value] of Object.entries(declared))
+      if (!(key in bag) || before[key] !== value) bag[key] = value;
+    for (const key of Object.keys(bag)) if (!(key in declared)) delete bag[key];
   }
-  return conflicts;
+  for (const assetId of Object.keys(live)) if (!(assetId in now)) delete live[assetId];
 }
 
-/** Structs and lists compare by their stored shape, which is what the project file holds anyway. */
-function sameValue(a: PropertyValue | undefined, b: PropertyValue | undefined): boolean {
-  return a === b || JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
-}
-
-function display(value: PropertyValue | undefined): string {
-  return typeof value === 'string' ? `"${value}"` : JSON.stringify(value ?? null);
-}
-
-/** The bag a variable is written to: its own when the behavior declares it, else the shared one. */
-export function variableBag(ctx: NodeContext, key: string): PropertyBag {
-  if (key in ctx.variables) return ctx.variables;
-  return key in ctx.shared.variables ? ctx.shared.variables : ctx.variables;
-}
-
-/** Everything the behavior can read under one name, its own declaration winning over a shared one. */
-export function readableVariables(ctx: NodeContext): PropertyBag {
-  const shared = ctx.shared.variables;
-  return isEmpty(shared) ? ctx.variables : { ...shared, ...ctx.variables };
+/**
+ * The values a `Variables` node reads and writes: those of the asset it names, else the behavior's
+ * own. A name that no asset answers to is a fresh bag, so a node left pointing at a deleted asset
+ * writes nowhere instead of into the behavior it sits in.
+ */
+export function variableBag(ctx: NodeContext, source: string): PropertyBag {
+  if (!source) return ctx.variables;
+  return ctx.shared.variables[source] ?? {};
 }
 
 /** Where a machine's current state is kept: shared when the machine is `global`, else per instance. */
 export function stateBag(ctx: NodeContext, machineId: string): Record<string, string> {
   return machineId in ctx.shared.states ? ctx.shared.states : ctx.states;
 }
-
-/** The defaults a behavior instance starts with: a shared variable is not one of them. */
-export function withoutGlobals(defaults: PropertyBag, asset: Asset): PropertyBag {
-  if (asset.type !== 'behavior') return defaults;
-  const own = { ...defaults };
-  for (const def of asset.variables) if (isGlobal(def)) delete own[def.key];
-  return own;
-}
-
-function isEmpty(bag: PropertyBag): boolean {
-  for (const key in bag) if (Object.hasOwn(bag, key)) return false;
-  return true;
-}