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/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');