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/commands/assetCommands.ts

@@ -30,6 +30,8 @@ export function buildAsset(type: AssetType, name: string, id = newId()): Asset {
       return { ...base, type: 'text' };
     case 'behavior':
       return { ...base, type: 'behavior', variables: [], graph: createEmptyGraph() };
+    case 'variables':
+      return { ...base, type: 'variables', variables: [] };
     case 'collider':
       return { ...base, type: 'collider' };
     case 'container':

src/core/commands/naming.ts

@@ -1,4 +1,4 @@
-import type { BehaviorAsset } from '../model/Asset';
+import type { BehaviorAsset, VariablesAsset } from '../model/Asset';
 import type { Project } from '../model/Project';
 
 function firstFree(taken: ReadonlySet<string>, candidate: (i: number) => string, from: number): string {
@@ -15,7 +15,7 @@ export function nextAssetName(project: Project, base: string): string {
 }
 
 /** "var1", "var2", … – the first variable name not yet used by the behavior. */
-export function nextVariableName(asset: BehaviorAsset, base = 'var'): string {
+export function nextVariableName(asset: BehaviorAsset | VariablesAsset, base = 'var'): string {
   return firstFree(new Set(asset.variables.map((v) => v.key)), (i) => `${base}${i}`, 1);
 }
 

src/core/commands/portCommands.ts

@@ -14,6 +14,7 @@ import {
   OBJECT_BEHAVIOR_PARAM,
   propertyTargetOf,
   RUN_BEHAVIOR,
+  variablesSourceOf,
 } from '../graph';
 import type { PropertyValue } from '../model/Properties';
 import type { Project } from '../model/Project';
@@ -355,7 +356,11 @@ export function renameVariablePorts(project: Project, behaviorId: string, from:
 }
 
 function namesVariablesOf(node: GraphNode, graphOwner: string, behaviorId: string): boolean {
-  if (declaresVariablePorts(node.type)) return graphOwner === behaviorId;
+  if (declaresVariablePorts(node.type)) {
+    // A node naming a Variables asset follows that asset wherever it sits, not the graph around it.
+    const source = variablesSourceOf(node.params);
+    return source ? source === behaviorId : graphOwner === behaviorId;
+  }
   return (
     declaresPropertyPorts(node.type) &&
     propertyTargetOf(node.params) === 'behavior' &&

src/core/commands/require.ts

@@ -1,7 +1,7 @@
 /** Lookups that throw a `CommandError` when the target does not exist. */
 import { findNode, type Graph, type GraphNode } from '../graph/Graph';
 import { type NodeDef, nodeDef } from '../graph/NodeRegistry';
-import type { Asset, BehaviorAsset, StateMachineAsset } from '../model/Asset';
+import type { Asset, BehaviorAsset, StateMachineAsset, VariablesAsset } from '../model/Asset';
 import { findObject, type ObjectTree } from '../model/hierarchy';
 import { isTemplateContent, objectRef, type ObjectRef } from '../model/instance';
 import {
@@ -71,6 +71,14 @@ export function requireBehavior(project: Project, assetId: string): BehaviorAsse
   return asset;
 }
 
+/** An asset that declares variables: a behavior, or a Variables asset shared by the whole run. */
+export function requireVariableOwner(project: Project, assetId: string): BehaviorAsset | VariablesAsset {
+  const asset = findAsset(project, assetId);
+  if (asset?.type !== 'behavior' && asset?.type !== 'variables')
+    throw new CommandError(`Variable owner ${assetId} not found`);
+  return asset;
+}
+
 export function requireStateMachine(project: Project, assetId: string): StateMachineAsset {
   const asset = findAssetOf(project, assetId, 'statemachine');
   if (!asset) throw new CommandError(`State machine ${assetId} not found`);

src/core/commands/variableCommands.ts

@@ -7,7 +7,6 @@ import {
 } from '../model/Properties';
 import { overrideSites } from '../model/instance';
 import type { Project } from '../model/Project';
-import { type Scope, scopeOf, setScope } from '../model/Scope';
 import type { VariableKind } from '../properties/kinds';
 import {
   emptyFieldValue,
@@ -20,7 +19,7 @@ import {
 import { type Removed, removeFirst, restoreAt } from '../util/list';
 import { type Command, CommandError } from './Command';
 import { renameVariablePorts } from './portCommands';
-import { requireBehavior } from './require';
+import { requireVariableOwner } from './require';
 
 /** The variable's default value is written to `props` as well. */
 export class AddVariableCommand implements Command {
@@ -37,7 +36,7 @@ export class AddVariableCommand implements Command {
   }
 
   execute(project: Project): void {
-    const asset = requireBehavior(project, this.assetId);
+    const asset = requireVariableOwner(project, this.assetId);
     if (!isValidVariableName(this.def.key)) throw new CommandError(INVALID_NAME);
     if (asset.variables.some((v) => v.key === this.def.key))
       throw new CommandError(`Variable "${this.def.key}" already exists`);
@@ -46,7 +45,7 @@ export class AddVariableCommand implements Command {
   }
 
   undo(project: Project): void {
-    const asset = requireBehavior(project, this.assetId);
+    const asset = requireVariableOwner(project, this.assetId);
     asset.variables = asset.variables.filter((v) => v.key !== this.def.key);
     delete asset.props[this.def.key];
   }
@@ -100,7 +99,7 @@ export class RemoveVariableCommand implements Command {
   }
 
   execute(project: Project): void {
-    const asset = requireBehavior(project, this.assetId);
+    const asset = requireVariableOwner(project, this.assetId);
     const def = removeFirst(asset.variables, (v) => v.key === this.key);
     if (!def) throw new CommandError(`Variable "${this.key}" not found`);
     this.removed = { def, value: asset.props[this.key] };
@@ -110,46 +109,13 @@ export class RemoveVariableCommand implements Command {
 
   undo(project: Project): void {
     if (!this.removed) return;
-    const asset = requireBehavior(project, this.assetId);
+    const asset = requireVariableOwner(project, this.assetId);
     restoreAt(asset.variables, [this.removed.def]);
     if (this.removed.value !== undefined) asset.props[this.key] = this.removed.value;
     restoreOverrides(project, this.assetId, this.key, this.overrides);
   }
 }
 
-/**
- * A shared variable has no per-instance value, so going `global` takes the deviations placed objects
- * kept for it. Undo gives them back.
- */
-export class SetVariableScopeCommand implements Command {
-  readonly label: string;
-  private previous: Scope = 'local';
-  private overrides: TakenOverride[] = [];
-
-  constructor(
-    private readonly assetId: string,
-    private readonly key: string,
-    private readonly scope: Scope,
-  ) {
-    this.label = `Make variable ${key} ${scope}`;
-  }
-
-  execute(project: Project): void {
-    const def = variableOf(project, this.assetId, this.key);
-    if (!def) throw new CommandError(`Variable "${this.key}" not found`);
-    this.previous = scopeOf(def);
-    setScope(def, this.scope);
-    this.overrides = this.scope === 'global' ? takeOverrides(project, this.assetId, this.key) : [];
-  }
-
-  undo(project: Project): void {
-    const def = variableOf(project, this.assetId, this.key);
-    if (!def) return;
-    setScope(def, this.previous);
-    restoreOverrides(project, this.assetId, this.key, this.overrides);
-  }
-}
-
 /** Renames everywhere: definition, default, instance overrides and the graph nodes referring to it. */
 export class RenameVariableCommand implements Command {
   readonly label: string;
@@ -171,7 +137,7 @@ export class RenameVariableCommand implements Command {
   }
 
   private rename(project: Project, from: string, to: string): void {
-    const asset = requireBehavior(project, this.assetId);
+    const asset = requireVariableOwner(project, this.assetId);
     if (from === to) return;
     if (!isValidVariableName(to)) throw new CommandError(INVALID_NAME);
     const def = asset.variables.find((v) => v.key === from);
@@ -202,7 +168,7 @@ interface FieldOwner {
 }
 
 function variableOf(project: Project, assetId: string, key: string): PropertyDef | undefined {
-  return requireBehavior(project, assetId).variables.find((v) => v.key === key);
+  return requireVariableOwner(project, assetId).variables.find((v) => v.key === key);
 }
 
 function requireFieldOwner(project: Project, assetId: string, key: string): FieldOwner {
@@ -244,7 +210,7 @@ interface ValueHolder {
 }
 
 function valueHolders(project: Project, assetId: string, key: string): ValueHolder[] {
-  const asset = requireBehavior(project, assetId);
+  const asset = requireVariableOwner(project, assetId);
   const def = asset.variables.find((v) => v.key === key);
   const holders: ValueHolder[] = [];
   if (def)

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;
-}

src/core/model/Asset.ts

@@ -36,6 +36,16 @@ export interface BehaviorAsset extends AssetBase {
   graph: Graph;
 }
 
+/**
+ * Declarations shared by the whole run: a `Variables` node naming this asset reads and writes one
+ * value per key, however many graphs point at it. Nothing is placed, so nothing overrides it –
+ * `props` holds the starting values, as a behavior's does for its own variables.
+ */
+export interface VariablesAsset extends AssetBase {
+  type: 'variables';
+  variables: PropertyDef[];
+}
+
 /** Placed as a child of the object it belongs to; its position is the offset from that body. */
 export interface ColliderAsset extends AssetBase {
   type: 'collider';
@@ -129,6 +139,7 @@ export type Asset =
   | TextAsset
   | SceneAsset
   | BehaviorAsset
+  | VariablesAsset
   | ColliderAsset
   | ContainerAsset
   | TextureAsset

src/core/model/AssetTypes.ts

@@ -4,6 +4,7 @@ export const ASSET_TYPES = [
   'sprite',
   'text',
   'behavior',
+  'variables',
   'collider',
   'container',
   'texture',
@@ -22,6 +23,7 @@ export const ASSET_TYPE_LABELS: Record<AssetType, string> = {
   sprite: 'Sprite',
   text: 'Text',
   behavior: 'Behavior',
+  variables: 'Variables',
   collider: 'Collider',
   container: 'Container',
   texture: 'Texture',
@@ -35,11 +37,11 @@ export const ASSET_TYPE_LABELS: Record<AssetType, string> = {
 /**
  * Textures and animations are not placeable: they are pictures a sprite wears through `texture`,
  * as a shader is worn through `shader` and a font through `font`. A state machine is not either:
- * a behavior refers to it by id.
+ * a behavior refers to it by id, and a Variables asset is declarations a graph reads by id.
  */
 export type PlaceableAssetType = Exclude<
   AssetType,
-  'scene' | 'texture' | 'animation' | 'statemachine' | 'shader' | 'font'
+  'scene' | 'texture' | 'animation' | 'statemachine' | 'shader' | 'font' | 'variables'
 >;
 
 const NOT_PLACEABLE: ReadonlySet<AssetType> = new Set([
@@ -49,6 +51,7 @@ const NOT_PLACEABLE: ReadonlySet<AssetType> = new Set([
   'statemachine',
   'shader',
   'font',
+  'variables',
 ]);
 
 export function isPlaceableType(type: AssetType): type is PlaceableAssetType {

src/core/model/Scope.ts

@@ -1,7 +1,7 @@
 /**
- * Whether a declaration keeps a value per behavior instance or shares one for the whole run.
- * Everything was `local` before scopes existed, so a missing field means `local` and old projects
- * load unchanged.
+ * Whether a state machine keeps its current state per behavior instance or shares one for the whole
+ * run. Everything was `local` before scopes existed, so a missing field means `local` and old
+ * projects load unchanged. Variables are shared by living on a Variables asset instead (#91).
  */
 export type Scope = 'local' | 'global';
 

src/core/model/graphLookup.ts

@@ -1,5 +1,4 @@
 import type { GraphLookup } from '../graph/lookup';
-import { withoutGlobals } from '../graph/sharedState';
 import { statesOf, transitionsOf } from '../graph/stateMachine';
 import { resolveAssetProps } from '../properties/resolve';
 import { findAssetOf, type Project } from './Project';
@@ -13,8 +12,7 @@ export function graphLookup(project: Project): GraphLookup {
     behavior: (assetId) => {
       const asset = findAssetOf(project, assetId, 'behavior');
       if (!asset) return null;
-      const defaults = withoutGlobals(resolveAssetProps(project, asset), asset);
-      return { name: asset.name, graph: asset.graph, defaults };
+      return { name: asset.name, graph: asset.graph, defaults: resolveAssetProps(project, asset) };
     },
     machine: (assetId) => {
       const asset = findAssetOf(project, assetId, 'statemachine');

src/core/properties/PropertySchema.ts

@@ -20,7 +20,6 @@ import {
   type VariableKind,
 } from './kinds';
 import { findAssetOf, type Project } from '../model/Project';
-import { isGlobal, type Scope } from '../model/Scope';
 import type { SceneObject } from '../model/SceneObject';
 import { flatListOf, listItemOf } from './listItems';
 import { FONT_KEY } from './fonts';
@@ -58,14 +57,10 @@ type Extras<K extends FlatKind> = K extends 'number'
 
 /** The definition of a flat kind: its default is a value of that kind, as the table says. */
 export type FlatDef<K extends FlatKind = FlatKind> = {
-  [P in K]: { key: string; label: string; kind: P; default: ValueOf<P>; scope?: Scope } & Extras<P>;
+  [P in K]: { key: string; label: string; kind: P; default: ValueOf<P> } & Extras<P>;
 }[K];
 
-/**
- * The inspector is generated from these entries, so a new property is one line in a schema below.
- * `scope` is only ever set on a behavior's own variables; the fixed schemas below leave it off, which
- * reads as `local`.
- */
+/** The inspector is generated from these entries, so a new property is one line in a schema below. */
 export type PropertyDef =
   | FlatDef
   /**
@@ -74,7 +69,7 @@ export type PropertyDef =
    * item kind: a list is stored in the project file, and an object is a live handle that no reload
    * survives.
    */
-  | { key: string; label: string; kind: 'list'; default: ListValue; scope?: Scope }
+  | { key: string; label: string; kind: 'list'; default: ListValue }
   /**
    * `fields` is the declaration; the value carries exactly those keys, which is what lets a struct
    * keep its shape while single fields are written (`mergeStruct`).
@@ -85,7 +80,6 @@ export type PropertyDef =
       kind: 'struct';
       default: StructValue;
       fields: readonly StructFieldDef[];
-      scope?: Scope;
     };
 
 export interface PrimitiveFieldDef {
@@ -220,6 +214,8 @@ const ASSET_SCHEMAS: Record<AssetType, PropertySchema> = {
   ],
   // Behaviors declare their own properties (variables) per asset too – see `schemaForAsset`.
   behavior: [{ key: 'runInEditor', label: 'Run in editor', kind: 'boolean', default: false }],
+  // Every row is declared on the asset itself – see `schemaForBag`.
+  variables: [],
   // The states are the asset's graph (see StateMachineAsset), not a property.
   statemachine: [],
   // The nodes are the asset's graph (see ShaderAsset); its parameters are rows of the sprites wearing it.
@@ -311,19 +307,16 @@ export function schemaForAsset(project: Project, asset: Asset): PropertySchema {
   return schemaForBag(project, asset, asset.props);
 }
 
-/**
- * A placed object's rows: an object overriding its shader has that shader's parameters. A global
- * variable is not among them – it belongs to the run, not to this object, so it shows no row here
- * and never reaches `entity.props` (which is what lets the shared bag answer for it instead).
- */
+/** A placed object's rows: an object overriding its shader has that shader's parameters. */
 export function schemaForObject(project: Project, asset: Asset, object: SceneObject): PropertySchema {
   const shader = object.overrides[SHADER_KEY];
-  const rows = schemaForBag(project, asset, shader === undefined ? asset.props : { [SHADER_KEY]: shader });
-  return rows.some(isGlobal) ? rows.filter((def) => !isGlobal(def)) : rows;
+  return schemaForBag(project, asset, shader === undefined ? asset.props : { [SHADER_KEY]: shader });
 }
 
 function schemaForBag(project: Project, asset: Asset, bag: PropertyBag): PropertySchema {
   if (asset.type === 'behavior') return [...FULL_SCHEMAS.behavior, ...asset.variables];
+  // Nothing but declarations: the starting values live in `props` under the very same keys.
+  if (asset.type === 'variables') return asset.variables;
   if (asset.type === 'sprite') return [...FULL_SCHEMAS.sprite, ...shaderParamRows(project, shaderOf(bag))];
   // Unlike a sprite's shader, a source's graph is its own asset's, so no id has to be looked up.
   if (asset.type === 'particles') {

src/core/properties/deviation.ts

@@ -11,7 +11,10 @@ import { deviatesFromAsset, isModified } from './resolve';
  * default is declared on the variable itself, so the asset value cannot differ from it.
  */
 export function markedAssetSchema(project: Project, asset: Asset): PropertySchema {
-  return asset.type === 'behavior' ? schemaFor('behavior') : schemaForAsset(project, asset);
+  // Declared variables are drawn by the inspector's own section, not as asset rows.
+  return asset.type === 'behavior' || asset.type === 'variables'
+    ? schemaFor(asset.type)
+    : schemaForAsset(project, asset);
 }
 
 /** Whether any asset property the inspector would mark gold differs from its default. */

src/core/store/serialize.ts

@@ -73,12 +73,12 @@ export function deserializeProject(raw: unknown, fallbackId = ''): Project {
     if (typeof a.id !== 'string' || !a.id || !isAssetType(a.type)) continue;
     rawProps.set(a.id, asRecord(a.props));
     if (a.type === 'sprite' || a.type === 'particles') wearers.set(a.id, a.type);
-    if (a.type === 'behavior') {
+    if (a.type === 'behavior' || a.type === 'variables') {
       const vars = normalizeVariables(a.variables);
       variables.set(a.id, vars);
       // The full schema, not just the common rows: this is what pass 2 coerces `props` against, and
       // a behavior's own `runInEditor` would be dropped as undeclared.
-      schemas.set(a.id, [...schemaFor('behavior'), ...vars]);
+      schemas.set(a.id, [...schemaFor(a.type), ...vars]);
     } else if (a.type === 'particles') {
       // A source's rows end with its own graph's parameters, so the graph is needed before the
       // overrides of the objects placed from it can be coerced.
@@ -130,6 +130,8 @@ export function deserializeProject(raw: unknown, fallbackId = ''): Project {
         variables: variables.get(id) ?? [],
         graph: normalizeGraph(a.graph),
       });
+    } else if (type === 'variables') {
+      assets.push({ id, type, name, props, variables: variables.get(id) ?? [] });
     } else if (type === 'statemachine') {
       const machine: StateMachineAsset = {
         id,
@@ -260,8 +262,6 @@ function normalizeVariables(raw: unknown): PropertyDef[] {
     const fields = normalizeStructFields(v.fields);
     const def = variableDef(key, kind, undefined, fields);
     def.default = coerceValue(def, (v.default ?? def.default) as PropertyValue);
-    // Written only when shared, so every project made before scopes existed saves back unchanged.
-    if (readScope(v.scope) === 'global') def.scope = 'global';
     defs.push(def);
   }
   return defs;

src/editor/Editor.ts

@@ -164,6 +164,9 @@ export class Editor implements PlayHost {
 
     this.graphEditor.canvas.traceProvider = (assetId) => this.play.traceFor(assetId);
     this.graphEditor.canvas.timeProvider = () => this.play.time;
+    // Only one of the two ever runs a given asset: playing stops the editor run (see `EditorRun.tick`).
+    this.inspector.liveVariables = (assetId) =>
+      this.play.liveVariables(assetId) ?? this.editorRun.liveVariables(assetId);
 
     this.toolbar = new Toolbar(state, {
       openProjectMenu: (anchor) => this.projects.openProjectMenu(anchor),

src/editor/EditorRun.ts

@@ -1,4 +1,6 @@
 /** Runs "run in editor" behaviors outside play mode, on a world built from the saved model, not a copy. */
+import { findAsset } from '../core/model/Project';
+import type { PropertyBag } from '../core/model/Properties';
 import { hasEditorRun, runsInEditor } from '../core/properties/editorRun';
 import { addGameSystems, type BehaviorSystem, behaviorError } from '../runtime/systems/BehaviorSystem';
 import { Input } from '../runtime/systems/Input';
@@ -60,7 +62,22 @@ export class EditorRun {
     world.tick(step);
     this.input.endFrame();
     if (this.control(world)) return;
-    this.commit(world.syncToModel());
+    const write = world.syncToModel();
+    this.commit(write);
+    // A shared value belongs to no object, so a frame that only moved one writes nothing here and
+    // the panels would never hear of it. Asking who is looking keeps that to the frames it helps.
+    if (!write.values && !write.structure && this.showsVariables()) this.state.runtimeTick();
+  }
+
+  /** The values a Variables asset shares in this run; null when no editor run is on. */
+  liveVariables(assetId: string): PropertyBag | null {
+    return this.behaviors?.liveVariables(assetId) ?? null;
+  }
+
+  private showsVariables(): boolean {
+    const selection = this.state.selection;
+    if (selection?.kind !== 'asset') return false;
+    return findAsset(this.state.project, selection.assetId)?.type === 'variables';
   }
 
   /** Facts for the check scripts: object ids of the behaviors currently running without Play. */
@@ -83,6 +100,7 @@ export class EditorRun {
     const world = this.world;
     if (world && world.project === this.state.project && world.sceneId === scene.id) {
       world.syncFromModel();
+      this.behaviors?.syncDeclarations();
       return;
     }
     this.stop();

src/editor/PlaySession.ts

@@ -11,6 +11,7 @@ import {
   type Trace,
 } from '../runtime/systems/BehaviorSystem';
 import type { AnimationClock } from '../runtime/Entity';
+import type { PropertyBag } from '../core/model/Properties';
 import { gameClock } from '../core/time';
 import { Input } from '../runtime/systems/Input';
 import { World } from '../runtime/World';
@@ -82,6 +83,12 @@ export class PlaySession {
 
   syncFromModel(): void {
     this.world?.syncFromModel();
+    this.behaviors?.syncDeclarations();
+  }
+
+  /** The values a Variables asset shares in this run; null when nothing is playing. */
+  liveVariables(assetId: string): PropertyBag | null {
+    return this.behaviors?.liveVariables(assetId) ?? null;
   }
 
   play(): void {

src/editor/inspector/Inspector.ts

@@ -1,3 +1,4 @@
+import type { PropertyBag } from '../../core/model/Properties';
 import { Label, Panel, ScrollContainer, Theme, ui, VStack } from '../../ui';
 import { type EditorState, sameSelection, type Selection } from '../state';
 import { assetSignature, buildAssetSection, refreshAssetSection } from './assetSection';
@@ -27,6 +28,8 @@ export class Inspector extends Panel {
   /** A rebuild that was due while a field in here had focus (see `refreshValues`). */
   private rebuildWhenLeft = false;
   private rebuilds = 0;
+  /** A Variables asset's live values, set by the editor – the only place that knows the running worlds. */
+  liveVariables: (assetId: string) => PropertyBag | null = () => null;
 
   constructor(private readonly state: EditorState) {
     super({ title: 'Inspector', padding: 0, gap: 0 });
@@ -53,6 +56,7 @@ export class Inspector extends Panel {
       state: this.state,
       // Read through the state on every call: load and play mode replace the project object.
       project: () => this.state.project,
+      liveVariables: (assetId) => this.liveVariables(assetId),
       body: new VStack({ padding: Theme.padding, gap: Theme.gap }),
       fields: new Map(),
       nameField: null,

src/editor/inspector/assetSection.ts

@@ -12,13 +12,12 @@ import {
   RemoveVariableCommand,
   RenameStructFieldCommand,
   RenameVariableCommand,
-  SetVariableScopeCommand,
 } from '../../core/commands/variableCommands';
 import type { Command } from '../../core/commands/Command';
-import type { Asset, BehaviorAsset, StateMachineAsset } from '../../core/model/Asset';
-import { globalConflicts } from '../../core/graph/sharedState';
+import type { Asset, BehaviorAsset, StateMachineAsset, VariablesAsset } from '../../core/model/Asset';
 import { findAsset, type Project } from '../../core/model/Project';
-import { isGlobal, type Scope, scopeOf } from '../../core/model/Scope';
+import type { PropertyBag, PropertyValue } from '../../core/model/Properties';
+import { isGlobal, readScope, scopeOf } from '../../core/model/Scope';
 import { type StructFieldKind, VARIABLE_KINDS } from '../../core/properties/kinds';
 import { type PropertyDef, schemaForAsset, type StructFieldDef } from '../../core/properties/PropertySchema';
 import { markedAssetSchema } from '../../core/properties/deviation';
@@ -26,7 +25,7 @@ import { isModified, resolveAssetProps } from '../../core/properties/resolve';
 import { Dropdown, HStack, Label, Menu, Theme } from '../../ui';
 import { FontPreview } from '../font/FontPreview';
 import { aspectActions, sizeCommand } from './aspectAction';
-import { actionIf, createFieldRow, type FieldHandlers, NAME_WIDTH } from './fieldFactory';
+import { actionIf, createFieldRow, type FieldHandlers } from './fieldFactory';
 import { addNameField, addNote, addTitle, type InspectorHost } from './host';
 import { buildVariable, kindMenu, type VariableEditing } from './variableRows';
 import { listOpener, previewingHandlers, structFields } from './previewHandlers';
@@ -49,7 +48,7 @@ export function assetSignature(project: Project, assetId: string): string {
 export function defSignature(def: PropertyDef): string {
   // Only a struct has rows of its own; a list is one row whatever its items are.
   const fields = def.kind === 'struct' ? def.fields.map((f) => `${f.key}:${f.kind}`).join('+') : '';
-  return `${def.key}:${def.kind}${fields ? `(${fields})` : ''}@${scopeOf(def)}`;
+  return `${def.key}:${def.kind}${fields ? `(${fields})` : ''}`;
 }
 
 /** Name, properties (asset values marked when they differ from the default) and, for behaviors, the variables. */
@@ -65,7 +64,12 @@ export function buildAssetSection(host: InspectorHost, assetId: string): void {
   });
 
   buildProps(host, asset, markedAssetSchema(host.state.project, asset));
-  if (asset.type === 'behavior') buildVariables(host, asset);
+  if (asset.type === 'behavior' || asset.type === 'variables') buildVariables(host, asset);
+  // Two lines rather than one: the panel is narrow enough to cut a longer note off mid-sentence.
+  if (asset.type === 'variables') {
+    addNote(host, 'One value each for the whole run.', 'small');
+    addNote(host, 'Every graph pointing here shares them.', 'small');
+  }
   if (asset.type === 'statemachine') buildMachineScope(host, asset);
   // A font has no properties at all, so without this its inspector would be the name and nothing.
   if (asset.type === 'font')
@@ -80,7 +84,7 @@ export function refreshAssetSection(host: InspectorHost, assetId: string): boole
   if (!asset) return false;
   host.nameField?.setValue(asset.name);
   const project = host.state.project;
-  const values = resolveAssetProps(project, asset);
+  const values = shownValues(host, asset);
   for (const [key, row] of host.fields) {
     row.setValue(values[key] ?? 0);
     row.setModified(isModified(project, asset, key));
@@ -135,15 +139,25 @@ function assetHandlers(host: InspectorHost, assetId: string, def: PropertyDef):
   };
 }
 
-/** Variables of a behavior, each with its declaration editable – plus an "add" menu. */
-function buildVariables(host: InspectorHost, asset: BehaviorAsset): void {
+/**
+ * What the rows show: the values of the run while one is on, else what the document declares – so a
+ * value a graph counts up is visible without ever being saved.
+ */
+export function shownValues(host: InspectorHost, asset: Asset): PropertyBag {
+  const values = resolveAssetProps(host.state.project, asset);
+  const live = asset.type === 'variables' ? host.liveVariables(asset.id) : null;
+  return live ? { ...values, ...live } : values;
+}
+
+/** Declared variables, each with its declaration editable – plus an "add" menu. */
+function buildVariables(host: InspectorHost, asset: BehaviorAsset | VariablesAsset): void {
   const header = new HStack({ gap: Theme.gap, align: 'center' });
   header.add(new Label('VARIABLES', { style: 'title' }), 1);
   const add = new Dropdown('+ Variable', { variant: 'ghost' });
   add.onClick = () => {
     const items = kindMenu(VARIABLE_KINDS, (kind) => {
       const current = findAsset(host.state.project, asset.id);
-      if (current?.type === 'behavior')
+      if (current?.type === 'behavior' || current?.type === 'variables')
         host.state.execute(new AddVariableCommand(asset.id, nextVariableName(current), kind));
     });
     new Menu(items).openBelow(add);
@@ -152,7 +166,7 @@ function buildVariables(host: InspectorHost, asset: BehaviorAsset): void {
   host.body.add(header);
 
   if (asset.variables.length === 0) addNote(host, 'No variables yet.');
-  const values = resolveAssetProps(host.state.project, asset);
+  const values = shownValues(host, asset);
   const run = (command: Command): void => void host.state.execute(command);
   for (const def of asset.variables) {
     const edit: VariableEditing = {
@@ -160,7 +174,6 @@ function buildVariables(host: InspectorHost, asset: BehaviorAsset): void {
       remove: () => run(new RemoveVariableCommand(asset.id, def.key)),
       renameField: (field, next) => run(new RenameStructFieldCommand(asset.id, def.key, field.key, next)),
       removeField: (field) => run(new RemoveStructFieldCommand(asset.id, def.key, field.key)),
-      setScope: (scope) => run(new SetVariableScopeCommand(asset.id, def.key, scope)),
       addField: (kind) =>
         run(
           new AddStructFieldCommand(
@@ -173,30 +186,26 @@ function buildVariables(host: InspectorHost, asset: BehaviorAsset): void {
     const value = values[def.key] ?? def.default;
     host.fields.set(def.key, buildVariable(host, def, value, assetHandlers(host, asset.id, def), { edit }));
   }
-
-  // The mark alone says nothing to someone meeting it for the first time.
-  if (asset.variables.some(isGlobal))
-    addNote(host, '⊕ is one value for the whole run, shared by name.', 'small');
-
-  // A global name is shared with every other behavior declaring it, so the disagreement shows here.
-  const own = new Set(asset.variables.map((v) => v.key));
-  for (const conflict of globalConflicts(host.state.project))
-    if (own.has(conflict.key)) addNote(host, conflict.message, 'warning');
 }
 
+/** Not in the schema table: the scope lives on the asset itself, not in its property bag. */
+const MACHINE_SCOPE: PropertyDef = {
+  key: 'scope',
+  label: 'Scope',
+  kind: 'enum',
+  default: 'local',
+  options: [
+    { value: 'local', label: 'Local' },
+    { value: 'global', label: 'Global' },
+  ],
+};
+
 /** A state machine has no properties of its own, so the inspector shows just its name and this. */
 function buildMachineScope(host: InspectorHost, asset: StateMachineAsset): void {
-  const row = new HStack({ gap: Theme.gap, align: 'center' });
-  row.add(new Label('Scope', { style: 'muted', width: NAME_WIDTH, padding: Theme.fieldPadding }));
-  const pick = new Dropdown(isGlobal(asset) ? 'Global' : 'Local', { variant: 'ghost' });
-  const set = (scope: Scope) => () => void host.state.execute(new SetMachineScopeCommand(asset.id, scope));
-  pick.onClick = () =>
-    new Menu([
-      { label: 'Local \u2013 one current state per object', onSelect: set('local') },
-      { label: 'Global \u2013 one current state for the whole run', onSelect: set('global') },
-    ]).openBelow(pick);
-  row.add(pick, 1);
-  host.body.add(row);
+  const set = (value: PropertyValue): void =>
+    void host.state.execute(new SetMachineScopeCommand(asset.id, readScope(value)));
+  const row = createFieldRow(host, MACHINE_SCOPE, scopeOf(asset), { onInput: set, onChange: set });
+  host.body.add(row.row);
   addNote(
     host,
     isGlobal(asset)

src/editor/inspector/host.ts

@@ -1,3 +1,4 @@
+import type { PropertyBag } from '../../core/model/Properties';
 import { Label, TextField, type TextFieldOptions, type VStack } from '../../ui';
 import type { EditorState } from '../state';
 import { type FieldContext, type FieldRow, labelledRow } from './fieldFactory';
@@ -5,6 +6,8 @@ import { type FieldContext, type FieldRow, labelledRow } from './fieldFactory';
 /** What the inspector sections build into: the panel body and the registry of rows. */
 export interface InspectorHost extends FieldContext {
   readonly state: EditorState;
+  /** The values a Variables asset shares in the run going on, null when none is (see `Inspector`). */
+  liveVariables(assetId: string): PropertyBag | null;
   readonly body: VStack;
   /** Rows by key; live refreshes and highlight updates find them here. */
   readonly fields: Map<string, FieldRow>;

src/editor/inspector/nodeSection.ts

@@ -19,6 +19,7 @@ import {
   STATE_TRANSITION,
   stateName,
   TRANSITION_PARAM,
+  variablesSourceOf,
 } from '../../core/graph';
 import type { GraphAsset } from '../../core/model/Asset';
 import { graphLookup } from '../../core/model/graphLookup';
@@ -28,7 +29,12 @@ import type { PropertyDef } from '../../core/properties/PropertySchema';
 import { Label } from '../../ui';
 import { createFieldRow, type FieldHandlers } from './fieldFactory';
 import { addNote, addTitle, type InspectorHost } from './host';
-import { buildPortSection, buildPropertyPortSection, buildVariablePortSection } from './portSection';
+import {
+  buildPortSection,
+  buildPropertyPortSection,
+  buildVariablePortSection,
+  variableChoices,
+} from './portSection';
 import { listOpener, previewingHandlers } from './previewHandlers';
 import { buildTransitionPicker, buildTransitionSection } from './transitionSection';
 import { currentNode, nodeParamValue } from './valueSpecs';
@@ -56,11 +62,14 @@ export function nodeSignature(project: Project, assetId: string, nodeId: string)
         .map((e) => `${e.id}:${e.label ?? ''}:${farStateName(asset.graph, e, node.id)}`)
         .join(',')
     : `${textOf(node.params[TRANSITION_PARAM] ?? '')}:${textOf(node.params[MACHINE_PORT] ?? '')}`;
-  return `${portSignature(node, asset.graph, lookup, assetId)}|${declared}|${connected.join(',')}|${variablesOf(
-    asset,
-  )
+  // The source names which declarations the port menu offers, so switching it has to rebuild.
+  const source = variablesSourceOf(node.params);
+  const choices = variableChoices(project, assetId, node)
     .map((v) => v.key)
-    .join(',')}|${target}|${transitions}`;
+    .join(',');
+  return `${portSignature(node, asset.graph, lookup, assetId)}|${declared}|${connected.join(
+    ',',
+  )}|${source}:${choices}|${target}|${transitions}`;
 }
 
 /** The name of the state at the other end of an edge – what a transition row is labelled with. */
@@ -95,8 +104,9 @@ export function buildNodeSection(host: InspectorHost, assetId: string, nodeId: s
     host.fields.set(`param:${param.key}`, row);
     host.body.add(row.row);
   };
-  const ownSettings = declaresPropertyPorts(node.type);
-  if (declaresVariablePorts(node.type)) buildVariablePortSection(host, assetId, node, variablesOf(asset));
+  // Both draw their settings inside the port section: a setting decides what the menu offers.
+  const ownSettings = declaresPropertyPorts(node.type) || declaresVariablePorts(node.type);
+  if (declaresVariablePorts(node.type)) buildVariablePortSection(host, assetId, node, addSetting);
   else if (ownSettings) buildPropertyPortSection(host, assetId, node, addSetting);
   else if (def.declaresPorts) buildPortSection(host, assetId, node, variablesOf(asset));
 

src/editor/inspector/objectSection.ts

@@ -24,7 +24,6 @@ import {
 } from '../../core/model/instance';
 import type { PropertyValue } from '../../core/model/Properties';
 import { findAsset, findObjectHolder, type Project } from '../../core/model/Project';
-import { isGlobal } from '../../core/model/Scope';
 import type { SceneObject } from '../../core/model/SceneObject';
 import {
   COMMON_PROPS,
@@ -55,12 +54,11 @@ import { componentRow, OFFSET_AXES, offsetKey, POSITION_AXES } from './vectorRow
 
 /**
  * The rows a placed object shows for what it was placed from: a behavior's declared variables, any
- * other asset's schema minus the common switches. A global variable is none of them – it belongs to
- * the run, so this object has no value of its own to show or override.
+ * other asset's schema minus the common switches.
  */
 export function objectRows(project: Project, asset: Asset, object: SceneObject): PropertyDef[] {
   return asset.type === 'behavior'
-    ? asset.variables.filter((def) => !isGlobal(def))
+    ? asset.variables
     : schemaForObject(project, asset, object).filter((def) => !isCommonProp(def.key));
 }
 
@@ -201,14 +199,8 @@ export function buildObjectSection(host: InspectorHost, holderId: string, object
   const own = objectRows(host.state.project, asset, object);
   if (own.length > 0 || asset.type === 'behavior')
     addTitle(host, asset.type === 'behavior' ? 'VARIABLES' : 'PROPERTIES');
-  // A global variable is missing from the rows above but not from the behavior, so saying it
-  // declares none would be untrue – name it instead, and where it went.
-  const shared = asset.type === 'behavior' ? asset.variables.filter(isGlobal) : [];
-  if (own.length === 0 && shared.length === 0 && asset.type === 'behavior')
-    addNote(host, 'The behavior declares no variables.');
+  if (own.length === 0 && asset.type === 'behavior') addNote(host, 'The behavior declares no variables.');
   for (const def of own) propertyRow(host, holderId, objectId, asset, def, values, asset.type === 'behavior');
-  if (shared.length > 0)
-    addNote(host, `Shared by the whole run: ${shared.map((def) => def.key).join(', ')}.`, 'small');
   markObjectRows(host, object, asset, target);
 
   if (asset.type === 'container') contentSection(host, holderId, object, asset.objects.length);

src/editor/inspector/portSection.ts

@@ -18,12 +18,14 @@ import {
   OBJECT_BEHAVIOR_SETTING,
   OBJECT_TYPE_SETTING,
   portKindOf,
+  VARIABLES_SETTING,
+  variablesSourceOf,
   propertyTargetOf,
   structShapeOf,
   targetLabel,
   targetProperties,
 } from '../../core/graph';
-import { findAssetOf } from '../../core/model/Project';
+import { findAssetOf, findGraphAsset, type Project } from '../../core/model/Project';
 import { textOf } from '../../core/model/Properties';
 import { DECLARED_PORT_KINDS, kindMark, VARIABLE_KINDS } from '../../core/properties/kinds';
 import { allShaderParamRows, type PropertyDef, schemaForAsset } from '../../core/properties/PropertySchema';
@@ -43,21 +45,37 @@ import { NAME_WIDTH, removeButton } from './fieldFactory';
 import { addNote, type InspectorHost } from './host';
 import { kindMenu, markLabel } from './variableRows';
 
+/** Whose declarations a Variables node picks its ports from: the asset it names, else the behavior. */
+export function variableChoices(project: Project, assetId: string, node: GraphNode): PropertyDef[] {
+  const source = variablesSourceOf(node.params);
+  if (source) return findAssetOf(project, source, 'variables')?.variables ?? [];
+  const asset = findGraphAsset(project, assetId);
+  // A state machine declares no variables; its one node type has none to name.
+  return asset?.type === 'behavior' ? asset.variables : [];
+}
+
 /**
- * The ports of a Variables node: each one *is* a variable of the behavior, so it is picked from that
- * list rather than named, and its kind follows the variable's declaration. Set makes it written too.
+ * The ports of a Variables node: each one *is* a declared variable, so it is picked from a list
+ * rather than named, and its kind follows the declaration. Set makes it written too.
  */
 export function buildVariablePortSection(
   host: InspectorHost,
   assetId: string,
   node: GraphNode,
-  variables: readonly PropertyDef[],
+  addSetting: (def: PropertyDef) => void,
 ): void {
+  addSetting(VARIABLES_SETTING);
+  const source = variablesSourceOf(node.params);
+  const shared = source ? findAssetOf(host.state.project, source, 'variables') : undefined;
   buildPickedPortSection(host, assetId, node, {
     noun: 'Variable',
-    choices: variables,
-    owner: 'this behavior',
-    empty: 'This behavior has no variables yet.',
+    choices: variableChoices(host.state.project, assetId, node),
+    owner: shared ? `"${shared.name}"` : 'this behavior',
+    empty: source
+      ? shared
+        ? `"${shared.name}" declares no variables yet.`
+        : 'That Variables asset is gone.'
+      : 'This behavior has no variables yet.',
   });
 }
 

src/editor/inspector/variableRows.ts

@@ -1,5 +1,4 @@
 import type { PropertyValue } from '../../core/model/Properties';
-import { type Scope, scopeOf } from '../../core/model/Scope';
 import { kindLabel, kindMark, STRUCT_FIELD_KINDS, type StructFieldKind } from '../../core/properties/kinds';
 import type { PropertyDef, StructDef, StructFieldDef } from '../../core/properties/PropertySchema';
 import {
@@ -40,21 +39,11 @@ export function kindMenu<K extends string>(kinds: readonly K[], pick: (kind: K)
 export interface VariableEditing {
   rename: (next: string) => void;
   remove: () => void;
-  setScope: (scope: Scope) => void;
   renameField: (field: StructFieldDef, next: string) => void;
   removeField: (field: StructFieldDef) => void;
   addField: (kind: StructFieldKind) => void;
 }
 
-const SCOPE_MARK: Record<Scope, string> = { local: '◦', global: '⊕' };
-
-function scopePicker(def: PropertyDef, edit: VariableEditing): Button {
-  return markPicker(SCOPE_MARK[scopeOf(def)], [
-    { label: 'Local – one value per object', onSelect: () => edit.setScope('local') },
-    { label: 'Global – one value for the whole run', onSelect: () => edit.setScope('global') },
-  ]);
-}
-
 export interface VariableOptions {
   edit?: VariableEditing;
   /** ↺/↑ on the first row: an override covers a whole struct, so its fields share them. */
@@ -82,7 +71,6 @@ export function buildVariable(
   } else {
     setValue = addValue(head, createField(host, def, value, handlers));
   }
-  if (edit) head.add(scopePicker(def, edit));
   if (edit) head.add(removeButton(edit.remove));
   const refreshActions = actions ? attachRowActions(head, actions) : () => {};
   host.body.add(head);

src/runtime/systems/BehaviorSystem.ts

@@ -1,8 +1,9 @@
 import {
+  adoptDeclarations,
   asNumber,
   buildSharedState,
+  declaredVariables,
   emptySharedState,
-  globalConflicts,
   type EntityHandle,
   type Graph,
   type GraphNode,
@@ -88,6 +89,8 @@ export class BehaviorSystem implements System {
   private instances: Instance[] = [];
   private world: World | null = null;
   private sharedState: SharedState = emptySharedState();
+  /** The declarations as last read; an edit is what differs from these (see `syncDeclarations`). */
+  private declared: Record<string, PropertyBag> = {};
   private readonly collisions: CollisionSystem | null;
   private readonly animations: AnimationSystem | null;
 
@@ -110,19 +113,24 @@ export class BehaviorSystem implements System {
     return this.sharedState;
   }
 
+  /** The values a Variables asset shares this run; null when this run holds none for it. */
+  liveVariables(assetId: string): PropertyBag | null {
+    return this.sharedState.variables[assetId] ?? null;
+  }
+
+  /** An edit to a declaration while the run is on reaches the running values through here. */
+  syncDeclarations(): void {
+    const now = declaredVariables(this.project);
+    adoptDeclarations(this.sharedState.variables, this.declared, now);
+    this.declared = now;
+  }
+
   start(world: World): void {
     this.world = world;
     this.instances = [];
     // Built fresh for every run: a shared variable starts at its declared value each time Play does.
     this.sharedState = buildSharedState(this.project);
-    // Two behaviors declaring one global name with different kinds: whichever ran second would read
-    // a value of a type it never declared, so nothing runs until that is settled.
-    const blocking = globalConflicts(this.project).filter((c) => c.severity === 'error');
-    if (blocking.length > 0) {
-      for (const conflict of blocking) world.log.push(`${ERROR_PREFIX}: ${conflict.message}`);
-      world.stopRequested = true;
-      return;
-    }
+    this.declared = declaredVariables(this.project);
     this.syncInstances(world);
   }