@neocompose/cli 0.89.7 → 0.89.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.89.7",
+  "version": "0.89.9",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.89.7 -->
+<!-- reviewed-through-cli: 0.89.9 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/cli-development.md

@@ -118,6 +118,11 @@ codec reads when changing either projection. Class-generic results whose binding
 is known only at runtime use the SDK generic reader, including recursive tuple,
 collection, enum, and reference projections; scalar conversion alone is insufficient.
 
+Direct class-constrained `Reference<T>` and `Set<Reference<T>>` fields emit concrete
+accessors using the SDK generic reader, even while the declaring class leaves `T`
+open. Only authored abstract declarations emit abstract members. Compile the
+open class and exercise direct, inherited, closed, and read-only instances.
+
 A stored `Reference<T>` implementing an inherited get-only `T` property emits a
 value getter that reads the reference target. Keep its interface and field tokens
 on the inherited type, and compile both open and closed generic overrides.
@@ -138,7 +143,7 @@ The marker near the top of `SKILL.md` must exactly match the package version,
 and this quoted copy is checked too:
 
 ```html
-<!-- reviewed-through-cli: 0.89.7 -->
+<!-- reviewed-through-cli: 0.89.9 -->
 ```
 
 Keep this skill on current behavior. Upgrade steps, rollout prerequisites,

package/skills/neocompose-cli/references/declarations/constructors.md

@@ -31,6 +31,26 @@ Foo value = new(bar: "BAR", isFun: true) { IsFun = false };
 - A header constructor disables implicit parameterless `new` and forbids
   other constructor overloads. Its derived identity takes no `@id`.
 
+## Variant parameters
+
+Constructors accept `NeoVariant<T>` and `NeoLookupVariant<T, TValue>` selections,
+including nullable selections and generic targets such as `NeoVariant<Kid<int>>`.
+A member initializer can retain the selection for each instance:
+
+```neo
+class Box : NeoObject {}
+class Made(NeoVariant<Box> selection) {
+  public NeoVariant<Box> Selection = selection;
+}
+Made value = new(Box.Variants.Base);
+```
+
+Push and export retain the selected variant and any bound lookup row for replay.
+`null` is an empty nullable selection; `Box.Variants.Base` selects the base class.
+To pass a bound lookup selection directly, use a declared variant path and a
+stored row ID, such as `new Made(Box.Variants.Seeds.BySeed.Bind(Reference(id: "row-id")))`.
+This compiles to a fixed selection; `Bind` does not evaluate a dynamic row expression.
+
 ## Declared constructors
 
 Declare overloadable constructors as members when each body owns its own
@@ -142,6 +162,10 @@ class Child(string name) : Base {
   explicitly when needed.
 - Base-constructor arguments use the constructed class's concrete generic
   bindings, including an `Item<T>` parameter forwarded through its base chain.
+- Recording a constructor argument does not claim ownership. An initializer
+  may pass it to a nested constructor or attach it to a collection while
+  retaining its identity. Giving the same aggregate two owned fields or
+  collection positions still requires an explicit `Clone()`.
 - Constraints may construct another generic from a sibling parameter:
 
 ```neo

package/skills/neocompose-cli/references/declarations/declarations.md

@@ -39,6 +39,9 @@ abstract class Item<TContext extends SomeClass> : INamed {
 The `@id`s above are pulled IDs. New declarations omit them; push assigns them.
 Never put `@id` on inferred list/dictionary entry types or derived structural
 descriptors.
+Generic bindings and their nested collection descriptors follow the owning
+declaration's identity. Deleting and recreating an idless declaration creates
+fresh bindings; retaining its pulled IDs preserves them.
 
 ## Modifiers
 

package/skills/neocompose-cli/references/declarations/initializers.md

@@ -3,6 +3,11 @@
 Member defaults: what they may read, when they compute, generic and
 Immutable construction, and edits to stored constructions.
 
+Object initializer fields indent one level below the construction's header,
+including inside call arguments. The opening brace may be on the header line
+or the following line. Multiline argument lists retain their continuation
+indentation, using the project's configured spaces or tabs.
+
 ## Initializer scope
 
 - Field initializers may read their class's static members unqualified,
@@ -28,6 +33,10 @@ Immutable construction, and edits to stored constructions.
 
 ## Computed initializers
 
+The editor checks computed defaults with the same expression resolver as push.
+Unknown names, missing members, invalid type arguments, and expression type
+errors appear at the offending initializer expression, including nested defaults.
+
 A default that isn't a closed literal stores as a computed initializer and
 replays for omitted members in push, web, and SDK. A stored override stays
 pinned until reset.

package/skills/neocompose-cli/references/neoscript/collections.md

@@ -4,6 +4,10 @@ Queries and mutations on `List`, `Set`, and `Dictionary` values. Collection
 declarations and storage live in
 [member kinds](../declarations/member-kinds.md).
 
+Collections have no constructors. Initialize List and Set members with `[]`
+and Dictionary members with `{}`, including static members. Writing `new()`
+reports an editor diagnostic with the appropriate empty literal before push.
+
 ## Counting and matching
 
 - `items.Count` and `items.Count()` give the size; `items.Count(pred)` counts
@@ -43,7 +47,11 @@ return this.Beds
   snapshot through a writable alias makes `ThenBy` throw until a new `OrderBy`.
 - Negative skip/take counts behave as zero.
 - Read-only results keep entry identity and grant no extra write access to
-  entries.
+  entries. Declared index lookups (`items.Index.Name[key]`) preserve the source
+  entries' write permissions: writable fields can be updated through unique
+  results or a bucket's entries, while bucket membership stays read-only.
+  Subsequent index lookups reflect writes to indexed fields, including writes
+  through `Where` results.
 
 ## Reductions
 
@@ -69,6 +77,8 @@ return this.Beds
 
 These apply to writable collections and are statements:
 
+- String-keyed dictionaries accept any string, including `__proto__` and
+  `constructor`, in both indexed assignment and `Add(key, value)`.
 - `items.Add(value)` appends an entry. An aggregate already owned by another
   entry or field can't be added again. Add a new value, or `Clone()` a class
   instance.

package/skills/neocompose-cli/references/neoscript/delegates-and-listeners.md

@@ -18,6 +18,8 @@ List<Item> ready = this.Items.Where((item) => item.Count > 0);
 - Call any non-null delegate expression directly: `callbacks[0](value)`,
   `(cond ? a : b)()`, `Factory.Make()()`. Force-unwrap a nullable one first:
   `callbacks["key"]!()`. Void delegates are statements only.
+- A typed lambda can be called immediately when its result has an expected
+  type: `int n = ((int x) => x + 1)(2);`. Declare each parameter's type.
 - Inside a class body, invoke delegate and action members directly:
   `Selector()`, `OnUpdated()`.
 

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

@@ -44,6 +44,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 +114,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