@neocompose/cli 0.84.3 → 0.84.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.84.3",
+  "version": "0.84.5",
   "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.84.3 -->
+<!-- reviewed-through-cli: 0.84.5 -->
 
 # Neo Compose CLI
 

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

@@ -129,7 +129,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.84.3 -->
+<!-- reviewed-through-cli: 0.84.5 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

package/skills/neocompose-cli/references/commands-and-sync.md

@@ -335,6 +335,9 @@ Generated animation clip targets and reference lookup factories retain construct
 generic arguments, including supported forwarded bindings. Clip getters use the
 declared target type when the owner is a derived class. Export reports an error
 when a clip target does not match the owner or one of its constructed base types.
+Inherited collection interface getters preserve supported detached temporaries.
+Constructed entries such as `Frame<T>` use the interface's generic argument
+family for both their collection type and value converters.
 New instances that reuse existing member-localized text retain its shared ID
 and translations in the export.
 

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

@@ -425,6 +425,10 @@ value-level target metadata.
 
 ## Computed initializers and declared constructors
 
+Inherited member initializers read parameters from the constructor that declared
+them, including when export materialization clones their bodies. A storage-only
+override keeps that original constructor scope.
+
 Use an expression initializer when a member default must be evaluated during
 construction rather than stored as a closed literal. It is replayed for omitted
 members in push, web, and SDK contexts. A stored override remains pinned until

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

@@ -124,6 +124,26 @@ class members and `IReceiver` members. The same applies to guards that return,
 throw, or break. Reassignment clears the proof, and paths that did not pass the
 guard cannot use it.
 
+A class can construct each interface only once. A class value known to implement
+`IBox<int>` cannot pass an `is IBox<string>` check, including through inherited
+interfaces. Open classes can still acquire an unrelated interface. Checks between
+interface-only receivers retain their runtime behavior.
+
+Guards preserve a generic receiver's `T` identity and its declared bound. A
+declaration pattern also keeps the original receiver's members: after
+`if (item is not IReceiver receiver) return;`, `item` still has its class or
+generic type, while `receiver` exposes `IReceiver`.
+
+A later class guard retains these capabilities. For example, after checking
+`item is IReceiver` and then `item is Furnace`, the original `item` exposes both
+`Furnace` and `IReceiver` members. A sealed class that cannot implement the
+proven interface remains an impossible test.
+
+Guards also narrow named global values and static member paths. Qualified and
+unqualified static access share the same proof, including inherited statics.
+Assignments clear affected proofs. A closure must establish its own guard
+because the stored value can change before the closure runs.
+
 Functions, natives and interface functions can declare their own type
 parameters after the name, each with an optional constraint and default:
 
@@ -172,18 +192,19 @@ Each instance binds defaults that read `this` to itself; invalid lambda bodies
 are reported at the declaration by status, editor validation, and preparation.
 Static delegate fields use static class scope: they can read static members
 without an instance owner, and cannot access `this` or instance members.
-Other static fields can call them in their initializers, as in
-`public static int First = Helper.Run();`. Outside a lambda body, a field
-initializer qualifies the members it reads; a bare `Run()` or `Number` there is
-an unknown name.
-A delegate field default is the exception: it may name a method group bare.
+Field initializers can read their declaring class's static members without a
+qualifier, including inherited statics and reads inside nested object defaults:
+`public int First = Run();` and `public static int Copy = Number;`.
+Eager initializers cannot read instance members or `this`; static defaults also
+cannot capture class-header parameters. Defer instance reads inside a delegate
+lambda. A delegate field default may also name a method group bare.
 `Value = Read` or `this.Read` binds each new instance to its own `Read`, and a
 static function may be named as `Read` or qualified as `Holder.Read`/`Other.Read`.
 A qualified method group must name a static function. Method groups use the same
 signature rule as in a body, and a mismatch is reported at the declaration.
 A static field that names another static copies a value, as in
 `public static int B = Holder.A;`. A class, List, Set, or Dictionary static
-already owns its value, so call `Clone()` or use `Reference`. A static delegate cannot copy another Class's delegate field,
+already owns its value, so call `Clone()` or use `Reference`. A static delegate cannot copy another Class's delegate field, including an inherited one,
 because its closure compiles in its own Class; wrap it as `() => Other.Call()`.
 Omitted constructor fields use their authored defaults, including optional fields.
 Writable collection defaults belong to each instance; mutations persist on later
@@ -195,7 +216,13 @@ needed type descriptors; spec-only types remain in the test candidate.
 Generic primary constructors also accept stored collection arguments, such as
 `public static Box<List<int>> Value = new([1, 2]);`. Stored replay uses the closed
 parameter type to preserve collection references.
+Stored constructors validate every authored type argument, including names nested
+inside collections and generic types. An expected field type cannot hide an unknown
+type in `new Box<List<MissingType>>()`.
 Typed locals also accept generic class types such as `Box<int> box = new(1);`.
+Generic class arguments remain invariant through inheritance: `IntBox : Box<int>`
+can be assigned to `Box<int>`, but not `Box<string>`. Arguments are substituted
+through every intermediate base class, including nested generic arguments.
 Explicit lambda parameter annotations accept the same type grammar as
 declarations, including `decimal`, generic parameters, collections, arrays, and
 nullable types.
@@ -224,7 +251,8 @@ unconstrained generic `T` compares by value.
 Calling `Equals(other)` on a non-null generic value dynamically uses the
 runtime Class's one-argument `Equals` Function or NSFunction when it returns
 `bool`, including the effective override. Values without that member fall back
-to value equality.
+to value equality. For local sets, that fallback compares their current entries
+in insertion order, regardless of prior reads or mutations.
 
 Object initializers are available in method bodies and `.spec.neo` tests:
 
@@ -265,6 +293,9 @@ conditions being false also narrow receivers in later `else if` conditions.
 A nullable value coalesced with a non-null fallback produces a non-null result,
 including in constructor arguments: `new Sprite(item.Sprite ?? SpriteInfo.Empty)`.
 A nullable fallback keeps the result nullable when the left operand can be null.
+When a reference result is expected, `first ?? fallback` selects the reference
+itself. A present reference to a null target does not select the fallback.
+In a scalar context, references still read their targets before coalescing.
 
 Treat lookup-return values with the same nullable narrowing rules.
 
@@ -331,6 +362,12 @@ this.A = Reference(this.Count);   // A now names Count
 this.A += 1;                      // reads A's target, writes it back
 ```
 
+Conditional assignments such as `this.A = choose ? first : second` rebind `A`
+when both branches supply references. Scalar branches write through `A`; a mixed
+reference and scalar choice reads the selected reference's target. Constructors
+may initialize their own reference fields this way, but cannot write through
+external targets.
+
 A plain value never becomes a reference: passing `3` to a `Reference<int>`
 parameter is an error. A handle reference never owns, so it can't hold a new
 list or a query result.
@@ -387,6 +424,11 @@ may be null. The receiver stays unchanged.
 return "banana".Replace("a", "o"); // "bonono"
 ```
 
+Integer inputs assigned to `float` round to float32. This also applies to
+function arguments and returns, collection entries, and `List.Repeat` with a
+float entry type. `Contains` and `IndexOf` on float collections also convert
+integer search arguments. Nullable assignments preserve `null`.
+
 ## Collection builtins
 
 Lists expose their size as either `items.Count` or `items.Count()`. Use
@@ -399,8 +441,9 @@ Use `Any()` or `Any((item) => predicate)` to check for a match, and
 `All((item) => predicate)` to check every entry. Both short-circuit; an empty
 collection has `Any() == false` and `All(...) == true`.
 
-`Last`, `LastOrDefault`, `Single`, and `SingleOrDefault` accept zero arguments
-or one predicate. `Last` throws when no entry matches. `Single` throws unless
+`First`, `FirstOrDefault`, `Last`, `LastOrDefault`, `Single`, and `SingleOrDefault` accept zero arguments
+or one predicate. `First` and `Last` throw when no entry matches. Enum sets
+return enum values, including when a predicate selects the entry. `Single` throws unless
 exactly one matches; `SingleOrDefault` still throws for multiple matches.
 The `OrDefault` forms return nullable entries and use `null` for no match.
 
@@ -711,3 +754,7 @@ and may appear in any order. Use the existing nested positional override for a
 virtual owner; changing its listeners alone must not add a value override.
 Omitting a field inherits its listeners. An empty array suppresses inherited
 listeners and disappears when there is no inherited wiring to suppress.
+
+Decimal collection membership compares numeric values: `1.0` and `1.00` are
+equal for `ToSet`, `Contains`, `IndexOf`, `Add`, and `Remove`. Decimal scale
+is retained for display; string entries such as `"1.0"` and `"1.00"` stay distinct.

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

@@ -190,6 +190,13 @@ EligibleIngredients = root.Assets.Crafting.FurnaceRecipes
   .ToSet()
 ```
 
+`Box<Reference<Item>>` keeps its reference storage type through push and pull,
+including explicit `new Box<Reference<Item>>()` calls. Its `Item` targets stay
+shared; reading a class reference still produces the class value. A derived
+construction in a base-typed slot retains reference bindings forwarded through
+the inheritance chain, such as `Base<Reference<Item>>` holding
+`new Derived<Reference<Item>>()`.
+
 Writing `Reference(recipe.Ingredient)` inside the callback is also valid.
 `Reference(value)` preserves an evaluated class value and its identity; it does
 not clone it or turn it into a separate wrapper object. An optional generic
@@ -232,6 +239,10 @@ Reference<NeoDialogue>(id: "capitol-dialogue-id")
 - Both forms are legal in a member's declaration default, not only inside a
   value graph. A key written there resolves after every pass has run, so it may
   name a row the same push creates.
+- List and dictionary declaration defaults can contain slot references, including
+  nested collections: `List<Reference<int>> Counts = [Reference(root.Save.Bits)]`.
+  Each instance owns its collection; entries continue to target the original
+  root or static slot, including slots supplied by declaration defaults.
 - Keep genuine structural references ID-based when their collection has no
   stable symbol, path, or key surface. Animation track and frame-override
   targets are selectors, not structural references: encode a stable
@@ -276,6 +287,10 @@ that instance. Leaving the emitted construction unchanged creates no redundant
 value rows. A nullable member with no default remains bare; an explicit null
 default emits `= null`.
 
+Changing a construction to another overload or shared argument rebuilds the
+instance even when the argument values compare equal. Owned inline arguments
+still compare by contents; unchanged shared arguments keep their identities.
+
 Spelling an unchanged child default, such as `FPS = 8`, stays a no-op after
 push even when sibling fields own stored rows. Adding a different child default
 preserves those siblings' row identities; it does not transfer their ownership.
@@ -399,3 +414,8 @@ is an error; remove the declaration to request deletion.
 New schema getters referenced by NeoFlow interpolation need no `@id`. Export and
 `neo dev` assign the same identity to the declaration and its references, including
 inherited getters. Repeated exports and the next push reuse the export identity ledger.
+
+Dictionary string keys are data. An entry named `"Id"` reads its value through
+`dictionary["Id"]`; class `.Id` continues to return the class instance identity.
+
+You can remove a constructor and replace every call to it in the same edit. Push prepares the new calls together with the schema change and removes argument rows owned by the old constructions.