@neocompose/cli 0.82.4 → 0.83.0

package/package.json

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

package/skills/neocompose-cli/references/commands-and-sync.md

@@ -331,6 +331,10 @@ to earlier content reuses that result after verifying output bytes; changed or
 missing outputs are regenerated. Edited content is validated
 even when C# generation is skipped. After a CLI code-generation fix, run
 `neo export` again; generator revision changes invalidate cached C# output.
+Generated animation clip targets and reference lookup factories retain constructed
+generic arguments, including supported forwarded bindings. Clip getters use the
+declared target type when the owner is a derived class. Export reports an error
+when a clip target does not match the owner or one of its constructed base types.
 New instances that reuse existing member-localized text retain its shared ID
 and translations in the export.
 

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

@@ -58,7 +58,9 @@ abstract class Item<TContext extends SomeClass> : INamed {
 Use ordinary `public`, `protected`, `private`, `static`, `virtual`, `abstract`,
 `sealed`, and `override` semantics. A sealed class is an instantiable leaf:
 it may extend another class but cannot be extended, cannot also be abstract,
-and can only be sealed while it has no subclasses. Interfaces are non-generic.
+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 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;
@@ -298,6 +300,56 @@ A `Reference<T>` member satisfies an interface `T Foo { get; }` or
 
 Constructor and function parameters use `Set<T>` for several selections.
 
+### Interface members
+
+An interface types a member anywhere a class does: a field, a nullable,
+`readonly`, or `static` field, a `List`, `Set`, or `Dictionary` entry, a
+generic argument, a parameter, and `Reference<I>`. Each row holds its own
+class, which must implement the interface.
+
+```neo
+interface IContainer<T extends Item> {
+  List<T> Contents { get; }
+}
+
+class Crate<T extends Item> : IContainer<T> {
+  public List<T> Contents = [];
+}
+
+class Player {
+  public IContainer<Seed>? Pouch = new Crate<Seed>();
+  public List<IContainer<Seed>> Racks = [];
+}
+```
+
+- Construct a class, never the interface: `new IContainer<Seed>()` is an error.
+  Defaults and constructor arguments name the concrete class.
+- An open class can sit in an interface slot only when the interface fills
+  every class parameter, as `Crate<T> : IContainer<T>` does. Otherwise store a
+  closed subclass.
+- A class implements a given interface once, counting its `extends` chain.
+  `IContainer<Seed>` and `IContainer<Tool>` on one class is an error.
+- An interface argument is a type parameter in scope or a type with none
+  inside it. `IContainer<List<T>>` is an error.
+- `x is IContainer<Seed>` compares the arguments the row implements the
+  interface with. A generic interface needs its arguments in `is`.
+- `NeoVariant<I>` is an error, since variants belong to a class. `@index` on a
+  collection of interface entries is an error; `@column` can name an interface
+  property.
+- Interfaces carry no storage. A row fits a slot only when its class allows
+  the storage the row lives in. The compiler refuses an assignment that can't
+  fit, and push and commit refuse an authored row that doesn't fit.
+- A variant or animation override that puts a different class in an
+  interface slot replaces the slot's row.
+- A generic parameter can be constrained by an interface,
+  `T extends IContainer<Seed>`, and an interface can be a generic argument
+  where the parameter's constraint admits it.
+
+Generated C# types the slot by the generated interface, so a class that
+doesn't implement it doesn't compile. Writing a C# class that implements the
+interface but isn't a Neo class throws, naming the slot. So does writing a row
+the interface doesn't determine.
+
 ### Set members
 
 `Set<T>` is an insertion-ordered collection that can't hold duplicates. The
@@ -314,9 +366,9 @@ identities; added entries receive stable identities under the instance.
 
 An owned Set holds `bool`, `int`, `float`, `decimal`,
 `@settings(format: .Plain) string`, vectors, `Color`, sprites, audio clips,
-or a class. Elements can't be nullable, collections, variants, delegates,
-actions, or interfaces. A class entry is unique by row, a value entry by its
-value. `@index` and `@column` work as on a List; `kind:` is an error, since a
+a class, or an interface. Elements can't be nullable, collections, variants,
+delegates, or actions. A class or interface entry is unique by row, a value
+entry by its value. `@index` and `@column` work as on a List; `kind:` is an error, since a
 Set is always insertion-ordered.
 
 ```neo