@neocompose/cli 0.88.0 → 0.89.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.88.0",
+  "version": "0.89.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.88.0 -->
+<!-- reviewed-through-cli: 0.89.0 -->
 
 # Neo Compose CLI
 

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

@@ -109,7 +109,7 @@ The marker near the top of `SKILL.md` must exactly match the package version,
 and this quoted copy is checked too:
 
 ```html
-<!-- reviewed-through-cli: 0.88.0 -->
+<!-- reviewed-through-cli: 0.89.0 -->
 ```
 
 Keep this skill on current behavior. Upgrade steps, rollout prerequisites,

package/skills/neocompose-cli/references/declarations/extensions.md

@@ -0,0 +1,46 @@
+# Extensions
+
+Declare functions and computed properties in top-level extension blocks. Each
+member has its own `@id`; the block has no identity. Blocks can share any
+`.neo` definition file. Pull retains member file placement and otherwise uses
+`Extensions/<Receiver>Extensions.neo`.
+
+```neo
+extension Person {
+  @id("person-full-name")
+  public string FullName => $"{this.FirstName} {this.LastName}";
+}
+
+extension List<Item> {
+  @id("item-best")
+  Item? Best() => this.OrderByDescending((i) => i.Quality).FirstOrDefault();
+}
+
+extension<T> List<T> {
+  @id("list-first-value")
+  T? FirstValue => this.FirstOrDefault();
+}
+```
+
+Always use `this` to access the extended instance. Interface receivers are
+supported and use the ordinary writable-member rules. Extensions add no
+stored fields, constructors, inheritance, or operators. They are visible
+project-wide. Applicable declared members take priority over extensions;
+applicable extensions take priority over built-ins. Ambiguous candidates are
+errors. Receiver type parameters must appear in the receiver and cannot have
+defaults. Functions may also declare their own type parameters.
+
+Computed properties support getters and explicit `set(Type value)` bodies.
+Static extensions have no `this` and are called through the receiver type.
+Extensions cannot be listener or spy/mock targets or use builder bodies.
+
+Use `neo script check --all` to check local declarations. For direct checks,
+select an extension with `--member <stable-member-id>`. Do not pass `--this`.
+Direct evaluation accepts `--this-value <valueId>` only for a closed class or
+interface receiver. Static extensions reject `--this-value`. Evaluate scalar,
+collection, receiver-generic, and explicitly generic calls in an ordinary
+`neo script eval --source '...'` expression. Evaluate setters through ordinary
+assignments in source.
+
+Both evaluators support extension members independently of the generated C#
+version. See [Unity export](../sync/unity-export.md) for wrapper availability.

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

@@ -96,3 +96,43 @@ Put type arguments on the call, never the qualifier: `List<int>.Repeat` is an
 error and bare `List` is not a value. `count` must be an `int`; a negative
 count throws at runtime. The value and then the count evaluate exactly once,
 so a reference-typed value repeats the same reference.
+
+## Sequences and generators
+
+Built-in collections implement `IEnumerable<T>` for their exact value type.
+A dictionary enumerates its values. `GetEnumerator()` creates an independent
+`IEnumerator<T>` with `MoveNext()`, `Current`, and `Dispose()`. Built-in cursors
+snapshot membership when acquired. `Current` requires a successful `MoveNext`.
+
+```neo
+public IEnumerable<int> Neighbors(int cell) {
+    yield return cell - 1;
+    yield return cell + 1;
+}
+
+public List<int> Collect(IEnumerable<int> values) => values;
+public IEnumerator<int> Cursor(List<int> values) => values;
+```
+
+Typed assignments, parameters, and returns acquire a cursor or collect a list
+implicitly. Collecting a cursor consumes its remaining values, excluding its
+current value, and disposes it. Element types must match exactly. A collection
+itself does not own an iteration position.
+
+A generator returns non-nullable `IEnumerable<T>` or `IEnumerator<T>`. Arguments
+are evaluated when called; its body starts on the first `MoveNext`. Use
+`yield return value` and `yield break`. `foreach` disposes its cursor on normal
+completion, `break`, `return`, and catchable errors. A suspended generator runs
+entered `finally` blocks when disposed. Yields cannot appear in catch/finally
+blocks or a try block with catches; generators cannot invoke async functions.
+
+`start..end` is an ascending, upper-exclusive int sequence. Reversed bounds are
+empty. `foreach (var i in 0..count)` uses a counted loop without allocating a
+cursor. Ranges require safe integer bounds.
+
+`IEnumerator<T>` and derived cursor interfaces cannot occur in stored member
+shapes, including Session storage, nested collection entries, or tuples. Use
+computed properties and callable signatures for cursors; store `List<T>` data
+explicitly. Stored enumerable interface members accept authored class rows.
+Runtime sequences are shown as unenumerated and are not expanded for previews.
+`ToSet()` rejects enumerable/cursor interface elements.

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

@@ -102,6 +102,7 @@ Read only the leaf the task needs:
 Related branches:
 
 - [References](../values/references.md): `Reference<T>` handles and slots.
+- [Extensions](../declarations/extensions.md): typed receiver functions and computed properties.
 - [Overloads](../declarations/overloads.md): declaring and calling overloads.
 - [Constructors](../declarations/constructors.md) and
   [initializers](../declarations/initializers.md): construction order and

package/skills/neocompose-cli/references/sync/unity-export.md

@@ -45,3 +45,19 @@ an export go into the next batch. It never pulls or pushes.
 
 Pull, push, branch, merge, resolve, init, and export take turns through
 `.neo/workspace.lock`; a lock whose process died is taken over.
+
+## C# target and extension wrappers
+
+Set `codegen.csharpVersion` in `neo.json` to a numeric language version such as
+`"14"`. `latest` and `preview` are rejected. Without an override, export uses
+the supported Unity compiler mapping or the SDK's C# 9 baseline. It reads
+`codegen.unityVersion` first, then the linked Unity project's
+`ProjectSettings/ProjectVersion.txt`. `neo doctor` reports the effective target
+and its source. An unrecognized Unity version produces a baseline warning.
+
+Closed instance extension functions can generate classic C# extension methods.
+Interface receivers, open receiver types, static extensions, and computed
+extension properties require C# 14. Export omits an unavailable wrapper and
+reports its member ID, receiver, and missing capability. It keeps the member
+available to the NeoScript evaluators and SDK direct invocation API. Changing
+the target regenerates wrappers and removes obsolete owned wrapper files.