@neocompose/cli 0.76.1 → 0.76.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.76.1",
+  "version": "0.76.3",
   "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.1 -->
+<!-- reviewed-through-cli: 0.76.3 -->
 
 # Neo Compose CLI
 
@@ -68,7 +68,8 @@ opaque JSON or guessed syntax.
   its old parent no longer declares it. See the identity reference for limits.
 - Omit `@id` on new ordinary declarations and nested rows unless a same-push
   structural reference genuinely requires an explicit UUID. A successful push
-  assigns the durable IDs and rewrites source.
+  assigns the durable IDs and inserts them into the authored source. Files that
+  get no new IDs keep their bytes.
 - Do not add a second `@id` to a root or static member initializer. The member
   ID owns that stored binding. Existing nested class/list rows retain their
   inline IDs; new rows normally omit them until push.
@@ -309,7 +310,9 @@ or server verification is involved.
 The CLI and VS Code extension share NeoScript formatting and read `.editorconfig`
 for `.neo` and `.neoflow` files. Set `indent_style`, `indent_size`, `end_of_line`,
 and `insert_final_newline` there to keep regenerated source consistent with your
-editor. Defaults are two spaces, LF, and a final newline. Push preserves authored
+editor. Defaults are two spaces, LF, and a final newline. A NeoFlow prose
+block's content and closing `"""` lines follow its opening `"""`, so re-indenting
+never changes the text. Push preserves authored
 text when regeneration has the same tokens; pull preserves semantically unchanged
 files. Formatting-only body or source-location changes do not create a subsequent
 push, including stored initializer recipes, computed member defaults, and inline

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.1 -->
+<!-- reviewed-through-cli: 0.76.3 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -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
@@ -275,10 +290,15 @@ Operator expressions are valid member defaults and store as computed
 initializers, the same way calls do — `public float Derived =
 Flags.Start / Flags.Scale;` is fine. Positions that store no rows still
 require literals: dictionary keys must be string literals or enum option
-literals for enum-keyed dictionaries, and Vector/Color components must be numeric
-literals. When a computed list or dictionary entry
-carries an authored `@id`, parenthesize the expression — `@id("row")
-(A.B / A.C)` — so the annotation names the row rather than its left operand.
+literals for enum-keyed dictionaries, and Color components must be numeric
+literals. In a static member or its collection entries, a vector with a
+computed component, such as `new Vector2(Probe.X, 1)`, stores as a computed
+initializer. Instance member defaults, including their collection entries,
+still require numeric literal vector components. When a computed list or
+dictionary entry carries an authored `@id`, parenthesize the expression —
+`@id("row") (A.B / A.C)` — so the annotation names the row rather than its left
+operand.
+A push that assigns such a row's ID adds those parentheses itself.
 
 Numeric literals do not use C# suffixes: write `0` or `0.5`, not `0f` or
 `0.5f`. The declared/contextual type determines whether a literal is stored as

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

@@ -55,12 +55,10 @@ such as `set(int value) => this.Raw = value;`. An expression whose value would
 simply be discarded is rejected with a diagnostic that names the block body as
 the fix.
 
-`neo push` and `neo pull` canonicalize a stored body to the shorthand when its
-authored spelling is exactly one `return` statement that fits on one line;
-anything else re-emits as a block. Setters always re-emit as blocks. A push
-preserves the form you authored for members it did not otherwise rewrite, so
-choosing longhand for a one-line getter is stable; a fresh `neo pull` writes
-the canonical shorthand.
+`neo pull` and canonical emission write a body as the shorthand when it is
+exactly one `return` statement that fits on one line, and anything else as a
+block. Setters are always blocks. `neo push` keeps the body form you authored,
+so choosing longhand for a one-line getter is stable.
 
 Properties require a getter implementation. A bodyless `{ get; }` contract
 requires `abstract` on the member, even inside an abstract class, for example
@@ -122,11 +120,33 @@ class and derived classes may invoke it or call `Clear()`; public external
 callers may subscribe and unsubscribe with `+=` and `-=` but cannot raise or
 reset the action.
 
-Inline `NeoDelegate` lambdas may be returned or stored 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. Explicit lambda
-parameter annotations accept the same type grammar as declarations, including
-`decimal`, generic parameters, collections, arrays, and nullable types.
+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
+nullable types.
 
 A lambda may use an expression body too: `(x) => x * 2` is the block body
 `(x) => { return x * 2; }`. In a void delegate the expression is a statement,
@@ -549,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`, 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. 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.
 
 ## Member change listeners