@neocompose/cli 0.81.0 → 0.81.2

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.81.2
+
+### Patch Changes
+
+- 75ebf1e: A type written in a function body with the wrong number of type arguments no longer compiles, as declarations already did. `item is ToolItem<AttackItemAsset>` against a two-parameter `ToolItem` now fails with `Type 'ToolItem' expects 2 type arguments, but 1 was provided.` Type arguments on a generic parameter, a built-in or registry type, or more than 17 on `NeoDelegate` fail the same way. Already-compiled bodies keep running until their source is edited.
+- 4415c34: A string in a collection that happens to equal a live value id now reads back as that string, not as the row it names. Before, `touching.Add(placed.Id)` followed by `touching.Remove(placed.Id)` removed nothing, and index reads, `foreach`, `Contains`, `IndexOf`, `Set<string>`, and dictionary values returned the named row instead. Assigning a list slot whose string named another row also overwrote that row's value, and `Contains` on a `List<string>` matched an entry's own row id. A collection now records which of its entries are row ids the first time a written value makes it mixed, and a local collection holds its values. Neo Compose .NET SDK 0.71.5 fixes the same for local collections in Unity.
+- fffe524: A constructor argument that constructs a generic class inline, such as `new Holder(box: new Box<List<int>>(value: [1]))` or `new Holder(bags: [new Bag<int>(items: [1])])`, now writes back to source. Before, the next push after a pull failed with "Expected Box but received Box<int>" or "has no concrete class".
+
+  Value comparison now treats two generic bindings to the same type as equal, so replaying such a construction no longer reads as an edit that rebuilds it.
+
+- c2b1188: `EffectiveValueReader` takes `overrideRows: "constructed"` for override rows that are complete construction output. It reads rows minted outside the document as they are instead of replaying their construction. Edited copies of stored rows still expand, and forked readers do not inherit the option. The world animation panel uses it for its constructor, variant, and class Default previews, which had replayed every character part on the main thread when the panel opened.
+
+  A complete row of a class that declares a function or getter no longer replays on read. Those members never store a slot, but the reader counted them as missing.
+
+## 0.81.1
+
+### Patch Changes
+
+- dd6fe7e: A constructor argument that is itself an inline construction now keeps its own argument rows. This covers constructions passed directly, inside a list or dictionary argument, through a generic parameter, or in a settle block inside an argument. Before, the next push after a pull deleted those rows, and the value could no longer be written back to source.
+
+  Contextual enum keys such as `{ .B: value }` now resolve against the dictionary's key enum. The CLI writes enum keys in that form, so a pulled enum-keyed dictionary argument failed the next push.
+
+- ba53774: Preserve reserved-looking dictionary keys, including `__proto__`, when packing, cloning, hashing, and materializing values.
+- d901d09: Editing the constructor arguments of a pushed value, including a static such as a `NeoCellPattern`, now rebuilds the instance in place instead of failing with `construction-arguments-conflict`. The value keeps its ID, rows at unchanged positions keep theirs, and the stored arguments update. Changing the constructed class is still refused. Fields set in a constructor argument's own `{ ... }` block are now stored instead of dropped.
+- 69baa8c: `ToVariant` no longer reruns the target variant's `initialize`. It runs the variant's `Apply`, `Overrides`, and `ChildOverrides` on the instance as it stands. A stored instance now records two variants: `instanceVariantId`, the variant whose `Initialize()` built it, and `instanceAppliedVariantId`, the variant `ToVariant` last applied. The applied variant's `Overrides` and `ChildOverrides` layer over the construction; its `Apply` writes stay as overrides. `ToVariant(Base)` removes the applied layer. A `ToVariant` on an object nested inside another instance's construction applies the variant's layers in place and records nothing, so the values set where it was constructed stay. Repainting a placement with a different variant in the world editor replaces the built-by variant and removes the applied layer. Pushes reject a placement whose applied variant does not exist or belongs to a class the placement does not inherit. Existing data is unchanged. Requires Neo Compose SDK 0.71.4 or later.
+
 ## 0.81.0
 
 ### Minor Changes