@neocompose/cli 0.77.0 → 0.78.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.77.0",
+  "version": "0.78.0",
   "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.77.0 -->
+<!-- reviewed-through-cli: 0.78.0 -->
 
 # 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.77.0 -->
+<!-- reviewed-through-cli: 0.78.0 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -91,7 +91,7 @@ Use context-aware typed annotations:
 - `@visibility(.Hidden)` only on a class; absence means visible.
 - Stateful settings use contextual enum cases, such as
   `@settings(format: .Plain)` and `@settings(kind: .Unordered)`.
-- `@settings(...)` before a `List` element or `Dictionary` value type
+- `@settings(...)` before a `List` or `Set` element or `Dictionary` value type
   configures the collection's entries: `List<@settings(format: .Plain) string>`,
   `Dictionary<string, @settings(min: 0) int>`. Only the member that declares
   the collection spells them; overrides share its entries.
@@ -213,6 +213,19 @@ An explicit construction must be assignable to its receiving type. For example,
 `List<Base>` accepts `new Derived()` when `Derived` inherits `Base`, but rejects
 an unrelated class at `new`. Generic arguments must also be compatible.
 
+A generic class without a declared constructor is constructed with its type
+arguments, such as `new Box<int> { Item = 4 }` or a target-typed
+`new() { Item = 4 }`. A `T` field is required unless the type argument is
+nullable, so `new Box<int?>()` may omit it. `new Box()` is rejected as an open
+generic Class. Inside the class, methods and field initializers construct with
+the class's own parameter, such as `public Bag<T> B = new Bag<T>();`. Such an
+initializer with fields or entries, like `new Bag<T> { N = 3 }`, runs per
+instance, since each instance closes `T` differently. A type
+argument that wraps the parameter, such as `new Bag<List<T>>()`, is rejected.
+Type arguments must satisfy `extends` constraints in bodies too.
+A type argument may be a delegate, such as `Box<NeoDelegate<int, int>>`, but
+not a `NeoAction`, which is never a value.
+
 Primary-constructor parameters can initialize generic collection fields directly:
 
 ```neo
@@ -221,7 +234,8 @@ class Box<T>(List<T> value) {
 }
 ```
 
-The same rule applies to `Dictionary<string, T>` and nested collections.
+The same rule applies to `Dictionary<string, T>`, nested collections, and
+stored instances such as `public static Box<int> Value = new([1, 2]);`.
 
 ## Member and relation rules
 
@@ -257,6 +271,36 @@ A `Reference<T>` member satisfies an interface `T Foo { get; }` or
 
 Constructor and function parameters use `Set<T>` for several selections.
 
+### Set members
+
+`Set<T>` is an insertion-ordered collection that can't hold duplicates. The
+element picks the storage:
+
+- An enum `Set<Trait>` is a multi-select Enum.
+- `Set<Reference<T>>` is a multi-select lookup.
+- `Set<NeoDialogueReference>` is a multi-select dialogue lookup.
+- Any other element makes an owned Set whose entries are rows, like a List.
+
+An owned Set holds `bool`, `int`, `float`, `decimal`,
+`@settings(format: .Plain) string`, vectors, `Color`, sprites, audio clips,
+or a class. Elements can't be nullable, collections, variants, delegates,
+actions, or interfaces. A class entry is unique by row, a value entry by its
+value. `@index` and `@column` work as on a List; `kind:` is an error, since a
+Set is always insertion-ordered.
+
+```neo
+@index(member: Slug, kind: .Unique)
+public Set<Quest> ActiveQuests = [];
+public Set<int> LuckyNumbers = [3, 7];
+public Set<Trait> Traits = [.Brave];
+```
+
+`selection:` is an error everywhere: `Set<T>` selects many and `T` selects
+one. The language server's quick fix rewrites `@settings(selection: .Multi)`
+to a `Set<…>` type. A default literal that repeats a value fails `push`, and a
+`List<Trait>` stays an ordered List of enum values. Queries over a Set, such
+as `Where` and `OrderBy`, return a Set; `ToSet()` turns a List into one.
+
 Declare a multicast event as `NeoAction<…>`. Its value is an ordered listener
 set, so give it a bracketed list of method groups — never a lambda, and never
 a bare method group — and never mark it `required`: the rest state is the
@@ -410,7 +454,12 @@ class Foo(string bar, bool isFun) {
 Foo value = new(bar: "BAR", isFun: true) { IsFun = false };
 ```
 
-Header parameters are in scope throughout the class. Permit at most one `init`
+Header parameters are in scope throughout the instance members of the class.
+Field initializers, collection entries, object initializers, and lambdas read
+them per construction, so `public NeoDelegate<int> Value = () => n;` returns
+each instance's own `n`. A lambda can also read `this`, as in
+`() => n + this.M`; the rest of an initializer can't. Static members have no
+construction and can't read header parameters. Permit at most one `init`
 block. A header constructor disables implicit parameterless `new` and forbids
 additional constructor overloads. Its derived constructor identity is not
 authored with `@id`.

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

@@ -137,6 +137,15 @@ 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.
+`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, or Dictionary static shares
+the same object. A static delegate cannot copy another Class's delegate field,
+because its closure compiles in its own Class; wrap it as `() => Other.Call()`.
 Collection type arguments in constructions, such as `new Box<List<int>>([1, 2])`,
 work even when no field declares that collection type. Preparation includes the
 needed type descriptors; spec-only types remain in the test candidate.

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

@@ -312,6 +312,11 @@ different. The name must end with the binary's extension, because pull
 rebuilds the file's path from it. With no template annotation, the CLI persists the complete built-in
 Unity defaults for the file kind.
 
+Template-backed Unity settings may contain sparse nested override values and leaf
+paths such as `platformSettings.standalone.maxTextureSize` or
+`spriteSettings.pivot.x`. Preserve these paths during synchronization so untouched
+settings continue inheriting from the template.
+
 A top-level `NeoImage` or `NeoAudioClip` declaration in any definition file
 can stand in for an inline entry. The registry lists it by name
 (`NeoAudioClip SwordHit = SWORD_HIT;`), and the declaration carries the `@id`,