@neocompose/cli 0.89.8 → 0.89.10

package/skills/neocompose-cli/references/values/identities.md

@@ -70,7 +70,6 @@ stored instance rather than building a copy. Its owning placement keeps it,
 so a constructor that stores it needs a `Reference` field:
 
 ```neo
-@id("86ac7c7d-8d3b-4642-9def-cdf32643bdc5")
 DeliveryQuest HARD_AS_STONE = new();
 // The core quest list owns HARD_AS_STONE.
 WorkflowStep UNLOCK = new QuestUnlockStep(HARD_AS_STONE);
@@ -82,13 +81,15 @@ class QuestUnlockStep(DeliveryQuest quest) : WorkflowStep {
 
 - The local needs exactly one owning placement. Unowned locals, ambiguous
   placements, and cycles are source errors.
-- A nested target needs its existing `@id`. A structurally owned list entry
-  may use an unused UUID-v4 in the same push.
-- A local nested inside an evaluated constructor stays idless on first push;
-  push assigns its identity before it can be referenced. Don't give it a fresh
-  UUID.
-- A direct static owner supplies a pending identity for an idless local, and
-  aliases of that static local work too.
+- New nested locals can be referenced before their first push or export, including
+  inside lists, dictionaries, and constructor-backed owners. Preparation resolves
+  each reference to the row its unique owner creates. Aliases share that identity.
+  Sibling constructor arguments and explicit `Reference(LOCAL)` calls reuse the
+  child within the same owning tree. A parent constructor may borrow a child
+  that one of its field overrides owns; pull preserves both uses.
+  Direct `Reference(LOCAL)` fields resolve after the owning constructor runs.
+- Push writes assigned IDs back to source. Dry-run and export prepare the same
+  references without requiring hand-written IDs or an earlier push.
 - A member default is a construction template, so its local is not a single
   stored instance.
 - Owned locals inside evaluated initializers need directly addressable fields,

package/skills/neocompose-cli/references/world/variants.md

@@ -25,6 +25,29 @@ NeoVariant<ExampleObject> Down = new(
   written `new { ... }` or `new Partial<T> { ... }`. They never pass
   constructor arguments, even when `T` has a required constructor.
 
+A child override's explicit `NeoAnimationChildOverride<TChild>` argument
+selects the child type and its `Partial<TChild>` payload. The child type may
+extend `NeoObjectBase`; it does not have to equal the list's base type.
+Returning a local variable from the selector preserves that explicit type.
+The selector takes no parameters. Its `this` is the variant target instance,
+so `() => this.SelectFirstSprite()` and `this.SelectFirstSprite` both work
+when that method takes no arguments and returns `TChild`. A search through
+`Children` returns an optional `NeoObjectBase`; narrow it to `TChild` and
+handle the missing-child case before returning it.
+
+```neo
+new NeoAnimationChildOverride<AnimationSpriteObject>(() => {
+  if (this.Children.FirstOrDefault((child) => child.Name == "Sprite")
+      is not AnimationSpriteObject sprite) {
+    throw new NeoError("Expected a sprite child");
+  }
+  return sprite;
+}, new Partial<AnimationSpriteObject> { Sprite = Images.OreVeins.Slice(1) })
+```
+
+VSCode and `neo status` validate selector bodies and constructor delegate
+arguments, including names, parameter counts, return paths, and return types.
+
 A nested class partial changes only named members. A list override replaces
 the whole list; it does not patch entries by index. In particular, overriding
 a clip's `Frames` requires the complete desired list, not just the changed
@@ -44,6 +67,8 @@ frame. For editing an existing clip, see [frame overrides](animation.md).
 - Selections compare equal when class, variant, and bound lookup row match.
   An unset optional selection differs from `Base`.
 
+Variant selections can also be [constructor parameters](../declarations/constructors.md#variant-parameters). A constructor can retain a named, base, or bound lookup selection in a member initializer.
+
 ## Folders
 
 ```neo
@@ -112,8 +137,9 @@ NeoLookupVariant<ExampleObject, NeoSortingLayer> Layered = new(
 ## Type restrictions
 
 `NeoVariantFolder` and `NeoLookupVariantFolder` are top-level records, never
-member or parameter types. Variant handles are valid as Variant members only,
-not as collection entries, lookup targets, parameters, or generic bindings.
+member or parameter types. Variant handles are valid as Variant members and
+constructor parameters, not as collection entries, lookup targets, ordinary
+function parameters, or generic bindings.
 
 ## Stored overrides