@neocompose/cli 0.76.0 → 0.76.2

package/package.json

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

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

@@ -184,6 +184,12 @@ Readonly is shallow. A readonly collection's membership is fixed, while its
 entries' members follow their own storage and mutability. User class members
 still declare no storage.
 
+A readonly member declared as a literal (no initializer or constructor call)
+that reads neither `this` nor a constructor argument and holds nothing
+writable is a constant. Instances share its declared value and store nothing
+until a constructor or initializer block writes it. A readonly collection or
+initializer is still built per instance.
+
 `@index(member: Field, kind: .Unique)` and
 `@column(member: Field, width: ..., visibility: ..., pin: ..., overflow: ...)`
 are repeatable List annotations. `member:` is a bare field name on the entry
@@ -269,10 +275,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
@@ -459,12 +470,13 @@ construction remain subject to storage and `readonly` restrictions.
 Runtime construction never supplies an Immutable member: an initializer block,
 constructor body, base-clause argument, or generated C# factory cannot set one.
 The value is never stored with the instance. When the declaration, including
-every row it owns, reads neither `this` nor a constructor argument, the member
-is a constant and every instance shares one value. Otherwise each instance
-evaluates the declared initializer with its own `this` and constructor
-arguments, again after a reload. A method group such as `selector: SelectTorso`
-binds `this`. `Clone()` shares an authored or constant Immutable value and
-re-evaluates a per-instance one. A class with a required Immutable member and
+every row it owns, reads neither `this` nor a constructor argument, and no
+value of its type holds a writable member, the member is a constant and every
+instance shares one value. Otherwise each instance evaluates the declared
+initializer with its own `this` and constructor arguments, again after a
+reload. A method group such as `selector: SelectTorso` binds `this`.
+`Clone()` shares an authored Immutable value or a constant and re-evaluates a
+per-instance one. A class with a required Immutable member and
 no initializer cannot be constructed at runtime; only authored values construct
 it.
 

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,14 @@ 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.
+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 +550,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.
 
 ## Member change listeners