@neocompose/cli 0.76.2 → 0.77.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.76.2",
+  "version": "0.77.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.76.2 -->
+<!-- reviewed-through-cli: 0.77.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.76.2 -->
+<!-- reviewed-through-cli: 0.77.0 -->
 ```
 
 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
@@ -202,12 +202,27 @@ List getter.
 Use `.EnumCase` only when context fixes one enum type; otherwise write
 `EnumType.Case`. Constructor parameters supply this context for positional
 and named arguments, including substituted generic parameter types. Defaults
-and settings must be statically analyzable.
+and settings must be statically analyzable. An integer is not an enum option.
+Instance fields, static fields, and local value definitions report incompatible
+enum initializers at the authored expression before value lowering. Extracting
+a list or dictionary into a local preserves element validation. Errors point
+to the entry in the local definition, including missing `.Option` or
+`EnumType.Option` dictionary keys.
 
 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.
 
+Primary-constructor parameters can initialize generic collection fields directly:
+
+```neo
+class Box<T>(List<T> value) {
+  public List<T> Value = value;
+}
+```
+
+The same rule applies to `Dictionary<string, T>` and nested collections.
+
 ## Member and relation rules
 
 Infer member kind and optionality from its type and nullability. Treat the
@@ -216,14 +231,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

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

@@ -124,6 +124,25 @@ Inline `NeoDelegate` lambdas may be returned, stored, or assigned to a typed
 local such as `NeoDelegate<int, int> twice = (x) => x * 2;`, and may read
 surrounding locals and parameters. Those values are captured when the lambda is
 created, so later changes to the outer binding do not alter the closure.
+Any non-null delegate expression can be called directly, including
+`callbacks[0](value)`, `(condition ? first : second)()`, and `Factory.Make()()`.
+Force-unwrap a nullable delegate before calling it, as in `callbacks["key"]!()`.
+Void delegates can only be called as statements.
+Instance delegate field defaults are compiled against their declared signature.
+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.
+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.
+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.
 Typed locals also accept generic class types such as `Box<int> box = new(1);`.
 Explicit lambda parameter annotations accept the same type grammar as
 declarations, including `decimal`, generic parameters, collections, arrays, and
@@ -550,7 +569,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.
+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