@neocompose/cli 0.77.0 → 0.77.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.77.0",
+  "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.77.0 -->
+<!-- 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.77.0 -->
+<!-- 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

@@ -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
 
@@ -410,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.