@neocompose/cli 0.76.3 → 0.77.1

package/package.json

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

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

@@ -86,11 +86,11 @@ that does not authorize copying the annotation onto authored records.
 
 Use context-aware typed annotations:
 
-- `@settings(...)` for format/search/selection/editor constraints.
+- `@settings(...)` for format/search/collection/editor constraints.
 - `@storage(allowed: ...)` on classes and storage keys on members.
 - `@visibility(.Hidden)` only on a class; absence means visible.
 - Stateful settings use contextual enum cases, such as
-  `@settings(format: .Plain)` and `@settings(selection: .Multi)`.
+  `@settings(format: .Plain)` and `@settings(kind: .Unordered)`.
 - `@settings(...)` before a `List` 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
@@ -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
 
@@ -231,14 +245,31 @@ the instance's recorded constructor or variant. They track later source-default
 edits until that field is explicitly overridden; resetting an override makes it
 virtual again.
 
-A lookup member's arity is its declared type. `public Config Config` selects one
-entry and its declared type is the entry type; `public Set<Config> Configs`
-selects several. An initializer body for a single-select lookup returns one
-entry, never a set.
+Declare a lookup member as `Reference<T>`. `public Reference<Config> Config`
+selects one row and reads as `Config`. `public Set<Reference<Config>> Configs`
+selects several and reads as `Set<Config>`. An initializer body for a single
+reference returns one row, never a set. `T` with `@settings(collection:)` is an
+error; the language server's quick fix respells it.
+
+`@settings(collection: Owner.Member)` binds the reference to one collection.
+Without it the reference is unbound: it selects any stored row of `T` or a
+subclass, anywhere in the project. The selected row's store decides writes. A
+write through it to a Save row lands, and to an asset row it errors. Its
+generated C# property is the read-only interface; call `TryWritable` to write.
+
+An unbound default can name its row by a unique index:
+
+```neo
+public Reference<Item> StarterSeed = root.Assets.Items.Index.Slug["seed.carrot"]!;
+```
+
+The receiver is a `root` path to a List, `.Index.<Name>` is a unique index on
+it, and the key is a string literal. Any other shape stays initializer code.
+
+A `Reference<T>` member satisfies an interface `T Foo { get; }` or
+`{ get; set; }` and an abstract `T Foo { get; }`.
 
-The CLI also accepts `List<T>` with `selection: .Multi` on a member. Emitted
-source uses `Set<T>`; constructor and function parameters must use `Set<T>`
-to carry selection semantics.
+Constructor and function parameters use `Set<T>` for several selections.
 
 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
@@ -393,7 +424,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.
@@ -569,7 +578,7 @@ locally, like push. If another commit lands while it runs, the run is refused:
 run it again. `neo loc` writes work the same way: a write refused because
 another commit landed is run again.
 
-VS Code rename follows override families and class constructors, resolves contextual enum options such as `.Success`, renames a constructor parameter's named arguments (`new Item(count: 1)`) in bodies, initializers, specs, and base clauses, and keeps local-variable renames scoped to their declaration. Assigned IDs are not required for these refactorings. Inferred locals initialized with conditional expressions retain their common branch type for member completion, navigation, and rename. Typed delegate calls retain their return type too. Lambda returns use the delegate signature for target-typed constructors and enum argument suggestions. Member completion also follows optional access and null-forgiving receivers, including dictionary lookups.
+VS Code rename follows override families and class constructors, resolves contextual enum options such as `.Success`, renames a constructor parameter's named arguments (`new Item(count: 1)`) in bodies, initializers, specs, and base clauses, and keeps local-variable renames scoped to their declaration. Assigned IDs are not required for these refactorings. Inferred locals initialized with conditional expressions retain their common branch type for member completion, navigation, and rename. Direct parenthesized expressions and chained delegate factory calls retain their result type too. `List.Repeat` results infer their element type from the value, explicit call-site type arguments, and expected list type, including for inferred locals and direct indexed access. Lambda returns use the delegate signature for target-typed constructors and enum argument suggestions. Member completion also follows optional access and null-forgiving receivers, including dictionary lookups.
 
 ## Member change listeners