@neocompose/cli 0.87.1 → 0.88.0

package/skills/neocompose-cli/references/animation-and-world-authoring.md

@@ -1,582 +0,0 @@
-# Animation and world authoring
-
-Use this reference for world objects, structured leaves, animation, and
-NeoFlow dialogue graphs.
-
-## Contents
-
-- World object contracts
-- Cell patterns and grid queries
-- Sorting and optional children
-- Structured leaves
-- Object variants and lookup folders
-- Animation overrides
-- Segments and tracks
-- NeoFlow dialogues
-
-## World object contracts
-
-Extend visible system world classes with ordinary project-authored classes and
-overrides. Never copy the system schema's `@system` provenance annotation into
-project source.
-
-For world layer links, derive a concrete project class from
-`NeoTileLayerLink` or `NeoObjectLayerLink` and resolve exactly one
-`targetLayer` relation. Do not add value-level target metadata or ask painting
-operations to create/repair relation targets.
-
-## Cell patterns and grid queries
-
-`NeoCellPattern` stores an immutable ordered list of `Vector2Int` offsets.
-Its constructor copies the input list and preserves duplicates. Use `Box`,
-`Cross`, `Ring`, `Rect`, or `Line` for common shapes, and `Center`,
-`FourNeighbors`, `EightNeighbors`, or `Empty` for presets. `Cells(origin)`
-returns absolute cells in pattern order.
-
-```neo
-NeoCellPattern neighbors = NeoCellPattern.Box(1, excluding: .Center);
-NeoCellPattern custom = new(offsets: [new(-1, 0), new(2, 1)]);
-```
-
-`NeoCellPattern` is an ordinary stored class, and the presets are stored
-static values. A field that owns its pattern can't default to a preset or any
-other stored static, because the static already owns that row. `neo status`
-and push refuse `= NeoCellPattern.EightNeighbors` there. Call `.Clone()` to
-give each instance its own copy, or declare `Reference<NeoCellPattern>` to
-share the preset or any stored pattern:
-
-```neo
-class Sprinkler : NeoObject {
-  public NeoCellPattern Reach = NeoCellPattern.EightNeighbors.Clone();
-  public Reference<NeoCellPattern> Splash = NeoCellPattern.Center;
-}
-```
-
-On a placed `NeoObject`, `this.Cell` returns its grid cell.
-`this.GetObjects<Plant>(neighbors)` returns matching placed objects in the
-same grid, filtered to `Plant` and subclasses. `this.GetTile(neighbors)`
-returns the first tile found in pattern order, or null.
-`this.GetTiles(neighbors)` returns the tile at each occupied cell in pattern
-order and skips empty cells. A type argument filters each cell's top tile:
-`this.GetTiles<DirtDryTile>(neighbors)` returns `List<DirtDryTile>` and skips
-a cell whose top tile is something else, even when a dry tile sits under it. Each query takes an optional `offset` that shifts
-the whole pattern, so `this.GetTiles(neighbors, new(0, 2))` queries around the
-cell two rows up without building a translated pattern. These queries track
-empty cells as well as hits, so a getter updates when a new neighbor appears.
-Calling them on an unplaced object is an error.
-
-`this.GetArea()` returns the nearest `NeoTileGrid` that owns the object or
-tile, or null when no grid owns it. It works on any `NeoObjectBase` or
-`NeoTile`: a sprite child, an object held in another object's field, or a tile
-in a nested layer link answers with its placed root's grid. A type argument
-filters the answer, so `this.GetArea<FarmGrid>()` is null in any other grid.
-It sees spawns, moves, and removals made earlier in the same evaluation.
-
-`WithCenter`, `WithoutCenter`, `Translate`, and `Union` return patterns.
-`Union` removes duplicate offsets while preserving first occurrence order.
-Box, Cross, and Line include the origin by default. Use `excluding: .Center`
-to omit it. Line's `length` is the number of steps beyond the origin, so
-`Line(new(1, 0), 3)` contains four cells.
-
-In C#, the generated `NeoCellPattern` implements `INeoCellPattern`, an
-`IReadOnlyList<Vector2Int>` of offsets, and SDK grid helpers accept any
-`INeoCellPattern`. Replace old boolean factory arguments with
-`NeoCellPatternExcluding.None` or `.Center`. To retain Line's old default,
-pass `excluding: NeoCellPatternExcluding.Center` explicitly.
-
-## Tile placements
-
-A placement is an ordinary concrete `NeoTile` value with a `Cell`:
-
-```neo
-new GlassFloorTile { Cell = new(9, -4) }
-```
-
-Layer-link `Tiles` lists contain these values directly. `NeoTileInstance` and
-`@tile(...)` are removed. A tile's `Name`, `Sprite`, and `SmartTile` are
-class-level `readonly` members: tiles render per class, so override them on a
-subclass. Push rejects a placement that sets them. `Cell` is the placement's
-writable field.
-
-Object `PlacementTiles` is a `List<NeoPlacementTile>`. Each entry marks a
-footprint cell with its own `Cell` member. It is independent of `NeoTile`. Rendered
-tile classes do not belong in this list. An object with no placement tiles
-occupies no cells. It doesn't block other placements, and cell queries don't
-return it. A placed object with no tiles still has a `Cell`.
-
-`NeoSpriteObject` extends `NeoObject`. Place a sprite class like any object,
-give it `Children`, and override `OnObjectSpawned`/`OnObjectDespawned` on it.
-Hooks fire on every object in a placed hierarchy, parent first; despawn runs
-children first. `NeoObjectBehaviour.IsRoot` is true only on the placed root.
-
-Convert a writable placement without changing its row identity or cell:
-
-```neo
-tile.TryConvert<GlassFloorTile>();
-tile.TryConvert(nextTile);
-```
-
-The second form uses the target value's runtime class. It does not copy the
-target's fields. Both forms return `false` when placement validation rejects
-the new class. The grid's imports and compatible-layer relations still apply.
-
-`Tiles.Add` and `Tiles.Remove` change placement data directly. The SDK validates
-placement writes and updates live rendering from the resulting data changes,
-including script writes and remote batches. For flattened SDK layers,
-`TrySetTile<T>(cell)` remains available. Spawn objects with
-`TrySpawn(cell, constructedObject)`; successful adoption preserves the object's
-identity. Clone an existing owned object explicitly before placing another copy.
-
-Use an object's real `ToVariant` API to apply a variant of its class. The
-object inspector lists variants and their folders. Painting a different object
-class replaces the placement with a new row; it does not change the old object's
-class in place. The old `TrySwapVariant` class-swap APIs are removed.
-
-## Object variants
-
-A variant is a named configuration of one `NeoObject`-derived class: how to
-construct a fresh instance, and how to move an existing one into the
-configuration. Variants are records parented to their class, never values
-inside it, so they live in their own `Variants/` family rather than in the
-class file.
-
-```neo
-// Variants/ExampleObject.neo
-@id("5f0c2b9e-7d41-4a58-9b1a-3f6f0e2d8c11")
-NeoVariant<ExampleObject> Down = new(
-  initialize: () => { return new ExampleObject(.Down); },
-  apply: (source) => { source.FacingDir = .Down; },
-);
-```
-
-- `initialize` takes no parameters and returns the target class. It is
-  required: it is the only way to construct through the variant.
-- `apply` takes exactly one parameter of the target class and is void. Omit it
-  for a variant that is only ever constructed.
-- Both are ordinary delegate closures: parenthesized parameter list, then
-  either a block body or an expression body. `initialize` returns, so
-  `() => new ExampleObject(.Down)` works; `apply` is void, so its expression
-  body must be a call or an assignment, as in
-  `(source) => source.FacingDir = .Down`. The server compiles them, so authored
-  source carries only the code. Each closure has its own lexical scope, so
-  local names may be reused between `initialize` and `apply`.
-- `overrides` and each child override's `overrides` value are `Partial<T>`
-  deltas over existing instances. They may use inferred `new { ... }` or
-  explicit `new Partial<T> { ... }`, and never pass arguments to or invoke
-  `T`'s constructor—even when `T` has a required constructor.
-- `Variants.X.Initialize()` runs `initialize`, then `overrides` and child
-  overrides. `ToVariant` runs `apply`, then `overrides` and child overrides; it
-  never reruns `initialize`. An instance remembers both: the variant that built
-  it and the variant last applied. The applied variant's overrides win where
-  they answer, `apply` writes stay as instance overrides, and
-  `ToVariant(Base)` removes the applied layer. On an object nested inside
-  another instance's construction, `ToVariant` applies the layers in place and
-  records nothing.
-
-Folders are records too, declared as their own globals and assigned per
-variant. Nesting is spelled in the path with `/`; intermediate segments are
-implicit, so `new("Trees/Oak")` needs no `Trees` record.
-
-```neo
-// Variants/ExampleObject/Inverted.neo
-@id("b7d2e9f0-3c15-4a68-8b24-9e0f1a2c3d44")
-NeoVariantFolder<ExampleObject> Inverted = new("Inverted");
-
-@id("e3b9c0d1-4a26-4f81-92e7-6b5a4c3d2e66")
-@settings(folder: Inverted)
-NeoVariant<ExampleObject> Down = new(
-  initialize: () => { return new ExampleObject(.Down); },
-);
-```
-
-Rules push enforces, and the language service reports live:
-
-- A variant or folder belongs to the class its single type argument names, and
-  a variant may only reference a folder of its own class.
-- Variant names and folder path segments share one generated static scope per
-  folder, and are unique within it case-insensitively. Two classes may each
-  declare a `Down`.
-- `Base` is reserved case-insensitively: `<Class>.Variants.Base` denotes the
-  class with no variant applied.
-- Every name must survive C# identifier normalization, since each becomes a
-  member of the generated `Variants` tree.
-
-Push is folder-agnostic as it is for every other record family: a variant
-declared in any `.neo` file anywhere pushes identically. `Variants/<Class>.neo`
-and `Variants/<Class>/<Folder path>.neo` are the canonical layout `neo pull`
-materializes, one file per (class, folder), folder record first and variants
-ordered by name.
-
-A lookup folder binds one concrete list value and enumerates the same authored
-variants for every row in that list. Its second type argument is the list entry
-class. An empty path binds the class root; ordinary folders still require a
-non-empty path.
-
-```neo
-// Variants/ExampleObject.neo
-@id("18b93b80-5733-4747-bf5f-3609336e4f17")
-NeoLookupVariantFolder<ExampleObject, NeoSortingLayer> Root = new(
-  path: "",
-  collection: Assets.SortingLayers,
-  collectionValue: Reference(root.Assets.SortingLayers),
-);
-
-@id("736dddf8-2881-47e1-a1d3-55fb65ea9f2a")
-@settings(folder: Root)
-NeoLookupVariant<ExampleObject, NeoSortingLayer> Layered = new(
-  initialize: (value) => { return new ExampleObject(); },
-);
-```
-
-- `collection` names the eligible list member; `collectionValue` names the
-  concrete stored list whose rows the folder enumerates. Prefer the canonical
-  `Reference(root...)` path emitted by pull; an explicit ID remains valid.
-- Lookup `initialize` receives the selected row and returns the target class.
-  Lookup `apply` receives the target object followed by the selected row.
-- `NeoLookupVariant<TObject, TValue>` members retain an unbound lookup handle.
-  A plain `NeoVariant<TObject>` member may select one concrete row with
-  `.Bind(Reference(...))`; do not bind a row to the lookup-handle member type.
-- Variant selections compare equal with `==` when their target class, variant,
-  and bound lookup row match; repeated reads of `Variants.Base` are equal.
-  `!=` is the inverse, and an unset optional selection remains distinct from Base.
-- `NeoVariantFolder` and `NeoLookupVariantFolder` are top-level authoring
-  records, never member or parameter types. Variant handle types are supported
-  as the dedicated Variant member kind, but remain invalid as collection entry,
-  lookup target, parameter, or generic-binding types.
-
-## Sorting and optional children
-
-Attach `NeoSortingGroup` as an optional nested member on the project object
-classes that need it:
-
-```neo
-class Tree : NeoObject {
-  public virtual NeoSortingGroup? SortingGroup = null;
-}
-```
-
-Presence of a non-null group makes the object and descendants sort as one unit.
-`SortAtRoot` hoists a nested group against the scene root. `SortPoint` is the
-point the group Y-sorts at, in cells from the object's origin-cell corner
-(default `(0.5, 0)`, the origin cell's bottom center). Moving it never moves
-art. Set it per class, variant, or animation frame, like any other value.
-
-Objects sort by sorting layer, then order in layer, then sort-point Y (lower
-draws in front), then document order. `NeoSpriteObject` exposes `FlipX`,
-`FlipY`, `MaskInteraction`, and optional `SortingOrder`. Treat `SortingOrder`
-as an offset added to the layer's sorting order; it is not an absolute
-replacement.
-
-Use `NeoObjectBase.Enabled` to hide an object and its entire subtree without
-removing its authored `Children` row. A disabled object is not rendered or
-collided with, but its live values and running animation continue. Prefer this
-for fixed optional equipment/content slots so their provenance and animation
-targets remain stable.
-
-Do not treat P45 runtime-child provenance as available. Runtime structural
-children remain deferred; author known slots and toggle `Enabled`.
-
-## Structured leaves
-
-Address fields of these leaf values:
-
-- `SpriteInfo`: `FileId`, `SliceIndex`
-- Vector values: lowercase components such as `x`, `y`, `z`, `w` where
-  supported by the concrete vector type
-- Color: lowercase `r`, `g`, `b`, `a`
-
-Keep the casing exact. `FileId` and `SliceIndex` are PascalCase; vector and
-color components are lowercase.
-
-Use complete values in normal member initialization:
-
-```neo
-Sprite = Images.Hero.Slice(0);
-Placeholder = SpriteInfo.Empty;
-Position = new(0, 0, 0);
-Tint = Color(1, 1, 1, 1);
-```
-
-A bare `Images.Hero` yields a file ID only in a file-valued field context.
-Use `.Slice(index)` for a complete `SpriteInfo`.
-Use `SpriteInfo.Empty` for an authored non-null empty sprite. Use `null` only
-when the declared type is nullable `SpriteInfo?`.
-
-NeoScript may read or write structured fields when the receiver's effective
-storage permits it:
-
-```neo
-root.Session.Debug.Slice = Leg.Sprite.SliceIndex;
-Leg.Sprite.SliceIndex = 2;
-Leg.Position.y = 0.25;
-Leg.Tint.a = 0.5;
-```
-
-Treat writes as read-modify-write against the current whole leaf. Reject
-unknown fields, vector components unsupported by the concrete type, non-integer
-integer-vector values, and color channels outside `[0, 1]`.
-
-## Animation overrides
-
-Use partial structured literals only inside animation override graphs:
-
-```neo
-Overrides = new {
-  Sprite = new { SliceIndex = 1 },
-  Position = new { y = 0.25 },
-  Tint = new { a = 0.5 },
-};
-```
-
-An empty partial `new { }` means no change. A partial override changes only
-the named fields and preserves the leaf's other current fields. A whole-leaf
-override replaces the whole leaf.
-
-Frame overrides may change `Enabled`, `FlipX`, and `SortingOrder`; they may
-not add, remove, or reorder `Children`.
-
-Address direct children through selector delegates. Prefer the project's own
-stable identity contract, such as an immutable `Name`, slug, or semantic
-position. When a selector means one specific authored child slot whose
-placement clones carry `sourceValueId`, return
-`Reference<T>(id: "<authored-child-id>", withProvenance: true)`. The flag is
-opt-in and defaults to `false`; without it the ID is matched exactly. Missing
-optional child slots are skipped with diagnostics when the authored slot is
-absent, while stale pre-provenance placements may still fail closed.
-
-Authored object placements can carry variant and source metadata beside their
-schema keys. Preserve that metadata when editing the row; do not declare it as
-project schema fields. Raw tile placements use their row class and `Cell`, with
-no `assetClassId` or `assetValueId` sidecars.
-
-## Segments and tracks
-
-Use `NeoAnimationSegment<T>` for a frame-indexed value lane. The shipped
-sprite specialization is `NeoSpriteAnimationSegment`, whose
-`NeoAnimationSegmentFrame<SpriteInfo>` rows each provide `Index` and
-`Value`. Sparse frame values hold until the next row or `Duration`.
-Pass `Value` through the frame constructor (for example,
-`new NeoAnimationSegmentFrame<int>(value: 60)`). The constructor argument is
-the frame's authored value; it must not collapse to the concrete generic
-binding's fallback while the segment is materialized.
-
-Use one polymorphic `NeoAnimationClip.Tracks` list:
-
-- `NeoAnimationChildTrack` schedules `ClipKey` on the child returned by its
-  `Selector` delegate.
-- A project subclass of
-  `NeoAnimationSegmentTrack<TChild, TValue>` schedules a segment onto one
-  target member. Implement its abstract `Segment` member as a stored value,
-  lookup, or computed getter.
-- The shipped
-  `NeoSpriteAnimationSegmentTrack<TChild extends NeoSpriteObject>` pairing
-  targets `NeoSpriteObject.Sprite`.
-
-Declare a concrete project track by implementing `Segment`, expose a compatible
-selector function on the owning object, then pass that function to each row:
-
-```neo
-class StoredPantsTrack : NeoSpriteAnimationSegmentTrack<PantsSprite> {
-  public override NeoSpriteAnimationSegment Segment = new();
-}
-
-class LegPart : NeoObject {
-  public PantsSprite SelectPants() {
-    var child = this.Children.FirstOrDefault((candidate) => {
-      return candidate.Name == "Pants";
-    });
-    if (child is PantsSprite pants) {
-      return pants;
-    }
-    throw "Pants child is missing or has the wrong type";
-  }
-
-  public NeoAnimationClip<LegPart> Walk = new NeoAnimationClip<LegPart> {
-    Tracks = [
-      new StoredPantsTrack(selector: this.SelectPants) {
-        StartFrame = 0,
-        Direction = .Reverse,
-        OffsetEndIndex = 3,
-      },
-    ]
-  };
-}
-```
-
-Selectors may also be compatible inline closures. Prefer a named function when
-the identity rule is reused or deserves an explicit failure message. An exact
-`Reference<T>(id: "...")` recreates the row-ID coupling selectors were
-introduced to remove; use `withProvenance: true` only for a deliberately
-authored slot identity. For new track rows, omit `@id` and let the successful
-push assign it. Preserve IDs already present on pulled rows.
-
-A selector argument such as `this.SelectPants` is evaluated in the lexical
-scope of the class that declares the clip. Here `this` is the `LegPart`, not
-the nested track row or an outer object instance that later receives a copy of
-the declaration default. A named method group lowers to the P60 member-target
-form. Its declaration default carries `valueId: null` because no instance row
-exists yet; materializing the declaration binds it to the concrete `LegPart`
-row. An inline closure remains compiled closure source and reconstructs its
-lexical owner from the materialized graph. Do not interchange these two forms.
-
-Each track has `StartFrame`, `Direction` (`.Forward` or `.Reverse`), and a
-crop window `OffsetStartIndex`/`OffsetEndIndex`. Crop before reversing, then
-schedule on the owning clip. Content beyond the owning clip truncates. Reject
-empty/inverted crop windows and tracks that can never enter the clip.
-
-Treat track target selection as project-authored identity logic, not row data.
-The selector return type must be compatible with `TChild`; the segment value
-must be compatible with `TValue`. `Refresh` controls selector reevaluation,
-while track reads and segment getters are re-resolved for the next applied
-frame after a watched dependency changes.
-
-When multiple tracks write the same member in one frame, apply list order and
-let the last write win.
-
-A track can target a Class member. Each frame writes its whole value, and a
-`null` frame clears the member. Every `NeoObjectBase`, sprites included,
-declares `Collider`, so a per-frame trigger such as an attack hit box is a
-Session `Collider` override on the child plus a track of `NeoCollider?`
-frames:
-
-```neo
-class ColliderAnimationSegment : NeoAnimationSegment<NeoCollider?> {
-}
-
-@settings(target: NeoObjectBase.Collider)
-class SwingColliderTrack(NeoDelegate<SwordSprite> selector)
-  : NeoAnimationSegmentTrack<SwordSprite, NeoCollider?>(selector: selector) {
-  public override ColliderAnimationSegment Segment = new ColliderAnimationSegment() {
-    Duration = 3,
-    Frames = [
-      new NeoAnimationSegmentFrame<NeoCollider?>(value: new NeoCollider() {
-        Size = new(1, 1),
-        Offset = new(1, 1),
-        IsTrigger = true
-      }) { Index = 1 },
-      new NeoAnimationSegmentFrame<NeoCollider?>(value: null) { Index = 2 }
-    ]
-  };
-}
-```
-
-The segment's class must fit the target member's class. Like any track target,
-the member must be a writable Save, Session, or Writable leaf on the child, for
-example `@storage(allowed: .Session) public override NeoCollider? Collider;`.
-
-## NeoFlow dialogues
-
-Lookup dialogue groups use the same collection paths as lookup members:
-
-```neo
-NeoDialogueGroup FishingVictory = new(
-  kind: .Lookup,
-  collection: Assets.FishEncounters,
-  collectionValue: Reference(root.Assets.FishEncounters),
-);
-```
-
-The collection member and its value may be created in the same push without
-explicit IDs. Pull emits readable paths when the collection has a stable root
-path. Raw `Reference<Member>(id: "...")` and `Reference(id: "...")` forms remain
-readable, and values without a root path retain the ID form.
-
-Node and option prose lowers to localized-text records with canonical node or
-choice backlinks. Existing translations and unrelated localization links are
-preserved when the source is pushed.
-
-Put exactly one top-level `sealed class Name : NeoDialogue` in each `.neoflow`
-file. Make it non-generic, derive directly from compiler-owned `NeoDialogue`, and
-override `Trigger Trigger` exactly once. Do not add any other type declaration.
-
-```neoflow
-@id("capitol-dialogue-id")
-@settings(name: "Capitol: cold boot", saveOptionChoices: true)
-sealed class CapitolColdBoot : NeoDialogue {
-  @primary Outpost capitol = Assets.Capitol;
-  Player player = Player.Current;
-
-  @id("trigger-id")
-  override Trigger Trigger = new(group: CapitolDialogues.High) => Welcome;
-
-  @id("welcome-node-id")
-  Text Welcome = new(name: "Welcome!") {
-    """
-    Hello, {player.Name}.
-    """
-
-    @id("continue-option-id")
-    Option Continue = new() {
-      """
-      Continue.
-      """
-      return Finish;
-    }
-  }
-
-  @id("finish-node-id")
-  Text Finish = new() {
-    """
-    Until next time.
-    """
-  }
-}
-```
-
-Use `@primary` explicitly; never infer it. In a `.Lookup` group, the
-dialogue's `@primary` is the lookup value that triggers it; a lookup dialogue
-without one never triggers. Keep dialogue bindings flow-wide and
-node bindings scoped to their node/children. Give each persisted condition use,
-action invocation, mutation, pause, option, and node its own owner-scoped ID.
-
-Use `=> Next` or a trailing block with `return Next;`; do not author a `to:`
-argument. A destination arrow always follows an `=` initializer, as in
-`= new(...) => Welcome;`; an arrow that instead follows a member name or a
-parameter list's `)` is a NeoScript expression body, so the two never collide.
-Require destinations for triggers, options, and outcomes. Permit terminal
-text/actions to fall through. Keep all statements for
-`Actions Empty = new();` inside its body.
-
-After editing, run `neo dialogue dryrun <dialogue-ref>`. It prepares the local
-project candidate, including new dialogues and pending schema or value changes,
-without fetching or committing server content. Exit 1 means the graph
-would fail on device. Keep every dialogue edit in the tracked `.neoflow` source
-and commit it with `neo push`.
-
-### Dialogue group names and local symbols
-
-Use `NeoDialogueGroup QuestUnlocks = new(kind: .Standard, parent: Quests, name: "Unlocks")`
-when the local identifier should differ from the record's display name. Omitting
-`name` uses the identifier. Unity generates its dialogue API from the stored
-name (`Quests.Unlocks`), independently of the local identifier. Pull, force-pull,
-and reset retain the local identifier and authored file path by `@id`; a remote
-rename updates the `name:` argument.
-
-Trigger groups accept both `group: QuestUnlocks.Medium` and
-`group: Quests.Unlocks.Medium`. Qualified paths use the group's display name
-converted to an identifier; priority options use their declared names.
-Completion, hover, navigation, and diagnostics resolve both forms. Sibling
-groups that produce the same path segment require their distinct local aliases.
-
-### NeoFlow display names
-
-For `Text`, `Actions`, `Conditions`, `Option`, and `Outcome`, omitting `name:`
-infers the label from a custom authored symbol. `Option Accept = new()` gets
-label `Accept`, regardless of its prose. Dialogue classes use the same rule
-when `@settings(name: ...)` is omitted.
-
-Generated symbols such as `Text1`, `Actions2`, `Option1_2`, `Outcome1`, and the
-identity-based `Node_...` forms stay unlabeled for their corresponding kinds.
-A symbol from another kind is custom: `Option Text1` gets label `Text1`.
-Explicit names win, including
-`name: ""` for clearing a label, or `name: null` on optional graph labels. Dialogues and outcomes store
-an empty string for an unset label; optional graph labels store null. Pull
-writes explicit empty overrides where omission would otherwise infer a name,
-and omits a redundant label equal to the inferred symbol.
-
-The fixed `Trigger` member does not infer a label. Reusable condition and action
-functions keep their function identifiers as `sourceFunctionName`; they have
-no separate display-name field or `name:` constructor. Rename the function
-and its uses to change that source name. Linked-value aliases likewise retain
-their `sourceName`. These names never come from prose, and the naming rule does
-not change IDs, destinations, or condition/action use identities.