@neocompose/cli 0.89.4 → 0.89.5

package/package.json

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

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

@@ -58,6 +58,12 @@ Specs to read in full when relevant:
   those. App context projection, database adapters, and reactive hosts stay
   in the app. `npm run lint:architecture` checks boundaries and cycles;
   `npm run test:runtime-package` checks a standalone database host.
+- Default-value document adapters must carry constructor descriptors along
+  with members and values. Nested declaration defaults can contain constructor
+  recipes that construction checks must resolve before copying their rows.
+  Default copies pass the closed member placement to `defaultValueSource` and
+  read expanded children from that copy's rows. Declaration row IDs alone do
+  not identify a generic instantiation.
 - Compiled test caches include the relative spec path because source
   coordinates are part of the compiled body. Debug output stays on stderr,
   including in JSON test runs.
@@ -100,6 +106,29 @@ commits use the shared client preparation protocol.
   either changes. Undo/reset metadata changes invalidate the incremental
   cursor and fall back to a full snapshot.
 
+For Unity export changes to collection entry readers, compile the generated C#.
+Nested `Set<Reference<T>>` entries in lists and dictionaries must construct set
+views for class, slot, and collection targets, preserving read-only membership
+and each selected value's own storage permissions.
+Tuple fields, readers, and factory parameters retain enum-set, reference-handle,
+and nullable-entry metadata. Closed class and interface generic arguments use the same storage representation
+in fields, tuples, factories, and function signatures. Ordinary function
+collections retain read-only interfaces. Check generated C# compilation and SDK
+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.
+
+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.
+Reference-valued contracts retain their handles and their constructed base's
+class family. Interface adapters project invariant reference wrappers explicitly.
+When reading a selected collection, resolve its own descriptor, not its entry codec.
+Generic constructor initializers must close Reference target types before encoding
+a selection, so a reference to a list retains the list row rather than its entries.
+Preserve absent optional references through nullable value contracts; required
+references still reject a missing selection.
+
 ## Package and release maintenance
 
 Publish native JavaScript only: no `.csproj`, `.cs`, `.dll`, Roslyn host
@@ -109,7 +138,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.4 -->
+<!-- reviewed-through-cli: 0.89.5 -->
 ```
 
 Keep this skill on current behavior. Upgrade steps, rollout prerequisites,
@@ -147,3 +176,5 @@ or candidate-materialization changes also need a real `neo test` against the
 affected full-project candidate; Vitest doesn't replace it. Run
 `npm run doctor` last, and don't rerun passing suites just because doctor
 formatted files.
+
+Class collection assignment must validate all incoming owned entries before replacing a stored row or changing its aliases. Keep caught-rejection, late-entry failure, duplicate-row, and successful retry controls in `class-collection-assignment.test.ts`.

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

@@ -49,6 +49,8 @@ class Foo {
 ```
 
 Their parameters are visible only in that body, never in member initializers.
+A sole declared constructor accepts positional or named arguments and runs its
+body in either form. Overloads require named arguments to select the constructor.
 Each declared constructor must settle every required member itself; a
 call-site block can't repair an invalid constructor.
 

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

@@ -41,8 +41,10 @@ pinned until reset.
   inside `new() { Year = root.Save.World.Time.Year }`.
 - Literal-only positions: dictionary keys (string literals, or option literals
   for enum keys) and Color components. Instance member defaults need numeric
-  literal vector components; statics may compute them
-  (`new Vector2(Probe.X, 1)`).
+  literal vector components, including vectors nested in stored object/list
+  defaults. A rejected stored component is reported at its authored location
+  with the containing member name. Statics may compute supported component
+  expressions (`new Vector2(Probe.X, 1)`).
 - Parenthesize a computed list or dictionary entry that has an `@id`:
   `@id("row") (A.B / A.C)`. Push adds these parentheses when it assigns IDs.
 

package/skills/neocompose-cli/references/neoscript/types-and-narrowing.md

@@ -80,6 +80,12 @@ public static T? FirstOf<T extends Item = Item>(List<T> items) => items.FirstOrD
   evidence. The expected return type is not evidence. Explicit `<...>`
   never infers the omitted tail. Conflicting types need explicit arguments;
   inference does not invent a common ancestor.
+- Tuple arguments infer element by element, including nested tuples; labels do
+  not affect inference. `(T,T)` with `(1,2.5)` infers `float`. An enclosing
+  invariant position, such as `List<(T,T)>`, still requires exact element
+  types. Nullable elements matched against `T?` contribute their non-null
+  type. Null literals, target-typed `new()`, and empty collections supply no
+  evidence, but do not discard evidence from sibling tuple elements.
 - Function type parameters take no `@id`. Overrides declare the same count,
   constraints, and defaults but may rename them.
 

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

@@ -22,7 +22,11 @@ AudioClipRegistry AudioClips = new() {
 
 - `Images.Sword.Slice(0)` is a sprite; `AudioClips.SwordHit` is a clip. A bare
   `Images.Sword` is only a file ID, valid in file-valued contexts such as
-  `SpriteInfo.FileId`.
+  `SpriteInfo.FileId`. Assigning it directly to `SpriteInfo` is an error;
+  use `.Slice(0)` to select a sprite. Status, editor validation, and export
+  preparation report this at the assignment, including declaration defaults
+  and unused top-level object initializers. Uploading the image does not make
+  an unsliced assignment valid.
 - Registries and binaries may sit in any non-ignored folder. Update the path
   when moving a binary.
 - Renaming the symbol or replacing bytes keeps the file ID when `@id` stays.

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

@@ -42,6 +42,10 @@ public Reference<int> TrackedStat;          // another member's int
 - A single reference's initializer body returns one row, never a set.
 - `Reference<T>` satisfies interface `T Foo { get; }` or `{ get; set; }` and
   abstract `T Foo { get; }`.
+- Reads through a base getter use its declared return type. A stored
+  `Reference<T>` implementing a `T` getter reads the target value, including
+  closed generic targets. A getter declared to return `Reference<T>` keeps
+  that reference, so callers can retain its identity or write through it.
 - Generated C# exposes a read-only interface; call `TryWritable` to write.
 
 ## Defaults

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

@@ -70,6 +70,9 @@ Rules push and the language service enforce:
 - `Base` is reserved case-insensitively; `<Class>.Variants.Base` is the class
   with no variant.
 - Names must survive C# identifier normalization.
+- A selection such as `ExampleObject.Variants.Down` must name a declared
+  class. An unknown class is reported on that identifier in the editor; CLI
+  validation and export retain its authored file, line, and column.
 
 Push accepts variants in any `.neo` file. Pull writes
 `Variants/<Class>.neo` and `Variants/<Class>/<Folder path>.neo`, one file per
@@ -111,3 +114,27 @@ NeoLookupVariant<ExampleObject, NeoSortingLayer> Layered = new(
 `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.
+
+## Stored overrides
+
+A stored `NeoVariant<T>` field override may keep its target or narrow it to a
+descendant class. It may also remove `?`. A required override does not inherit
+an optional base member's null default: supply a compatible selection on every
+construction path, or declare a non-null default on the override. An inherited
+non-null default must satisfy the narrowed target; replace an incompatible
+default on the override. Explicit null
+defaults and selections remain invalid for required members.
+
+```neo
+class InventoryItem {
+  public virtual NeoVariant<PlacedItem>? Placed = null;
+}
+class MailboxItem : InventoryItem {
+  public override NeoVariant<PlacedMailboxItem> Placed;
+}
+```
+
+`PlacedMailboxItem` must derive from `PlacedItem`. A selection must satisfy the
+override's target, including when it uses `Class.Variants.Base`. This rule does
+not make unrelated generic wrappers covariant. Generated C# overrides retain
+the inherited `NeoVariant<PlacedItem>` wrapper because that wrapper is invariant.