@neocompose/cli 0.85.0 → 0.86.0

package/package.json

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

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

@@ -61,6 +61,13 @@ it may extend another class but cannot be extended, cannot also be abstract,
 and can only be sealed while it has no subclasses. Interfaces can declare type
 parameters and pass arguments to the interfaces they extend; see Interface
 members.
+A `closed` class is implicitly abstract and defines an exhaustive subtype
+family within the project version. Do not combine `closed` with `abstract` or
+`sealed`. Descendants remain open unless explicitly sealed or closed. Every
+generic parameter of a direct subclass must appear in its base construction.
+Changing the family requires recompilation of its switch-expression consumers.
+Generated Unity C# uses an abstract class; C# 15 is not required.
+
 A read-only override may narrow a class or interface contract to an assignable
 class or derived interface, including a non-null value for a nullable contract.
 Generated Unity C# keeps the inherited property type for Mono compatibility;

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

@@ -148,16 +148,17 @@ Functions, natives and interface functions can declare their own type
 parameters after the name, each with an optional constraint and default:
 
 ```neo
-public static T? FirstOf<T extends Item = Item>(List<Item> items) {
-    foreach (Item item in items) {
-        if (item is T match) return match;
-    }
-    return null;
-}
+public static T? FirstOf<T extends Item = Item>(List<T> items) => items.FirstOrDefault();
 ```
 
 A call writes every type argument or omits the defaulted tail
-(`FirstOf<Seed>(items)`, `FirstOf(items)`); nothing is inferred. Function type
+(`FirstOf<Seed>(items)`, `FirstOf(items)`). When `<...>` is omitted, supplied
+arguments infer the function's type arguments. Lambda inputs bind first so their
+returns can infer output parameters, as in `Map(seed, (value) => value.Price)`.
+Defaults fill parameters with no inference evidence. The destination/expected
+return type does not provide evidence. Explicit `<...>` keeps explicit/default
+binding and does not infer omitted trailing arguments. Conflicting types require
+explicit arguments; inference does not invent a shared ancestor for siblings. Function type
 parameters take no `@id`, and an override declares the same count, constraints
 and defaults, though it may rename them.
 
@@ -384,12 +385,38 @@ Inside a generic body, `Reference<T>` takes the category of `T`'s binding.
 
 ## Numeric types
 
-`int` is a 32-bit integer and `float` is a 32-bit float, matching C#. Float
-literals, stored values, and every arithmetic step round to 32 bits, so
-`0.1f + 0.2f` behaves like Unity. `int` division truncates toward zero.
+`int` stores whole numbers and division truncates toward zero. Ordinary integer
+arithmetic retains the precision of the stored number. `float` literals, stored
+values, and every float arithmetic step round to 32 bits, matching Unity.
 `decimal` is exact base-10 and is the only type to use for currency or other
 values that must not drift.
 
+## Bitwise integer operators
+
+Use `~`, `&`, `^`, `|`, `<<`, `>>`, and `>>>` with non-nullable `int` operands.
+The compound forms are `&=`, `^=`, `|=`, `<<=`, `>>=`, and `>>>=`.
+Enums, bools, float literals such as `1.0`, and decimals are not accepted.
+Use `Set<Enum>` for enum membership.
+
+```neo
+int mask = (region << 8) | (tile & 255);
+bool hasEast = (mask & 2) != 0;
+mask &= ~2;
+```
+
+Each operand wraps modulo 2^32 into signed int32 at the bitwise boundary.
+Every result is signed int32. Ordinary integer arithmetic is unchanged.
+Shift counts use their low five bits: 32 means 0, 33 means 1, and -1 means 31.
+`>>` extends the sign bit; `>>>` fills with zero but still returns a signed
+result. Thus `-1 >>> 1` is 2147483647 and `-1 >>> 0` is -1.
+Operands evaluate once, left to right. A compound assignment captures its
+target and reads its old value before evaluating the right operand.
+
+Precedence from tightest to loosest: unary, switch expressions, multiplication/division/remainder,
+addition/subtraction, shifts, comparisons, equality and `is`, `&`, `^`, `|`,
+`&&`, `||`, `??`, then `?:`. Binary bitwise operators associate left to right.
+Keep shift characters contiguous: `x >> 1` is valid; `x > > 1` is not.
+
 ## Numeric builtins
 
 Use the `Math` namespace for numeric utilities with C# names and C# semantics:
@@ -692,8 +719,39 @@ switch (direction) {
 Permit `int`, `string`, `bool`, enum, and nullable forms. Stack labels when
 they share one body. End every reachable non-empty section with `break`,
 `return`, `throw`, or `continue` when a surrounding loop makes it valid.
-Do not use implicit fallthrough, switch expressions, pattern cases, guards, or
-`goto`.
+Do not use implicit fallthrough, pattern cases, guards, or `goto` in statement switches.
+
+### Switch expressions
+
+Use `value switch { pattern => result, ... }` to produce one value. Arms may
+use scalar/enum constants, `null`, type patterns (`Damage`), declaration
+patterns (`Damage damage`), or `_`. A declaration binding is scoped to its
+arm's optional `when` guard and result. Patterns and guards run in order; the
+selector runs once and only the chosen result runs.
+
+```neo
+closed class HitResult {}
+sealed class Miss : HitResult {}
+sealed class Damage : HitResult { public int Amount = 0; }
+class Combat {
+  public string Describe(HitResult result) => result switch {
+    Miss => "miss",
+    Damage damage when damage.Amount > 10 => "strong hit",
+    Damage damage => $"{damage.Amount}",
+  };
+}
+```
+
+Every switch expression must be exhaustive. Handle every bool/enum option or
+closed-class branch, plus null for nullable input. Other types require a
+covering type or `_` fallback. A guard contributes no exhaustive coverage
+unless it is literally `true`. Missing and unreachable cases are compile
+errors. Adding a new subtype recompiles affected consumers.
+
+Result arms must fit the expected type or have a common assignable type.
+Property, relational, list, and positional patterns are unsupported. Pattern
+cases in statement switches remain unsupported. Install the matching Unity
+SDK before exporting the new switch-expression IR; older SDKs reject it.
 
 ## Try/catch