@neocompose/cli 0.32.3 → 0.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.32.3",
+  "version": "0.33.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.32.3 -->
+<!-- reviewed-through-cli: 0.33.0 -->
 
 # Neo Compose CLI
 

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

@@ -83,7 +83,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.32.3 -->
+<!-- reviewed-through-cli: 0.33.0 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -21,10 +21,14 @@ migration, or `.neoflow` file. NeoFlow has its own single-dialogue exception.
 Persist the declared identifier as the schema name; there is no separate
 technical/display name. Keep existing IDs stable.
 
-NeoScript keywords are case-sensitive. Lexer-classified type names remain
-legal in contextual identifier slots, so a member, parameter, or enum option
-may be named `Set` or `Dictionary`; lowercase keywords such as `class` and
-`return`, plus the builtin `Math` namespace, remain reserved.
+NeoScript keywords are case-sensitive. Qualified member labels, schema keys,
+registry entries, and enum options occupy their owner's namespace, so they may
+reuse unrelated builtin names such as `Set`, `Dictionary`, `List`, or `Math`.
+Type-token spellings such as `Set` and `Dictionary` are also legal parameters.
+Actual lowercase grammar keywords such as `class` and `return` remain
+reserved. Top-level declarations and bindings retain their own reservations:
+for example, neither may shadow the unqualified builtin `Math` namespace, and
+implicit bindings such as `this`, `root`, and `context` cannot be parameters.
 
 ```neo
 @id("interface-named-id")

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

@@ -8,7 +8,7 @@ runtime ownership, evaluation, and migrations.
 - Inline bodies and snippets
 - Nullability and ownership
 - Numeric builtins
-- Logical operators
+- Conditional and logical operators
 - Loops and transfer
 - Switch
 - Try/catch
@@ -44,6 +44,20 @@ Prefer `--json` for automation.
 
 Inside an inline Class body, unqualified names resolve against that Class;
 invoke delegate and action members directly with `Selector()` or `OnChanged()`.
+Clear every subscribed listener from a stored action with
+`this.OnChanged.Clear()`. `Clear()` is a mutating statement and follows the
+action member's effective storage and writability.
+
+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.
+
+Calling `Equals(other)` on a non-null generic value dynamically uses the
+runtime Class's one-argument `Equals` Function or NSFunction when it returns
+`bool`, including the effective override. Values without that member fall back
+to ordinary NeoScript equality.
 
 ## Nullability and ownership
 
@@ -108,10 +122,22 @@ language's `float`-to-`int` conversions: they return `int` for `int` and
 at runtime. `Round` rounds midpoints to even, matching `decimal.Round(0)`.
 `Sign` always returns `int`; `Sqrt` takes `int` or `float` only.
 
-`Math` is a qualifier, never a type or a value, and the name is reserved: no
-Class, enum, member, parameter, or local may be named `Math`.
+`Math` is an unqualified builtin qualifier, never a type or value, so no Class,
+enum, parameter, or local may shadow it. Qualified members use their owner's
+namespace and may be named `Math`; access one as `this.Math` or
+`SomeValue.Math` without colliding with the builtin qualifier.
+
+## Conditional and logical operators
+
+Use `condition ? whenTrue : whenFalse` for a value chosen by a condition:
+
+```neo
+T modified = this.Modifier != null ? this.Modifier(value) : value;
+```
 
-## Logical operators
+The operator has lower precedence than `??`, `||`, and `&&`, associates from
+the right, and evaluates only the selected result arm. Both arms must share a
+common assignable type or fit the surrounding expected type.
 
 Use `&&` and `||` with C# precedence: `&&` binds tighter than `||`, and
 parentheses preserve explicit grouping. Both operators short-circuit, so the