@neocompose/cli 0.77.1 → 0.79.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.77.1",
+  "version": "0.79.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.77.1 -->
+<!-- reviewed-through-cli: 0.79.0 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/animation-and-world-authoring.md

@@ -38,10 +38,28 @@ NeoCellPattern neighbors = NeoCellPattern.Box(1, excluding: .Center);
 NeoCellPattern custom = new(offsets: [new(-1, 0), new(2, 1)]);
 ```
 
+`NeoCellPattern` is an ordinary stored class, and the presets are stored
+static values. A field that owns its pattern can't default to a preset or any
+other stored static, because the static already owns that row. `neo status`
+and push refuse `= NeoCellPattern.EightNeighbors` there. Call `.Clone()` to
+give each instance its own copy, or declare `Reference<NeoCellPattern>` to
+share the preset or any stored pattern:
+
+```neo
+class Sprinkler : NeoObject {
+  public NeoCellPattern Reach = NeoCellPattern.EightNeighbors.Clone();
+  public Reference<NeoCellPattern> Splash = NeoCellPattern.Center;
+}
+```
+
 On a placed `NeoObject`, `this.Cell` returns its grid cell.
 `this.GetObjects<Plant>(neighbors)` returns matching placed objects in the
 same grid, filtered to `Plant` and subclasses. `this.GetTile(neighbors)`
-returns the first tile found in pattern order, or null. These queries track
+returns the first tile found in pattern order, or null.
+`this.GetTiles(neighbors)` returns the tile at each occupied cell in pattern
+order and skips empty cells. Each query takes an optional `offset` that shifts
+the whole pattern, so `this.GetTiles(neighbors, new(0, 2))` queries around the
+cell two rows up without building a translated pattern. These queries track
 empty cells as well as hits, so a getter updates when a new neighbor appears.
 Calling them on an unplaced object is an error.
 
@@ -51,10 +69,11 @@ Box, Cross, and Line include the origin by default. Use `excluding: .Center`
 to omit it. Line's `length` is the number of steps beyond the origin, so
 `Line(new(1, 0), 3)` contains four cells.
 
-The SDK uses the existing `NeoCellPattern` type and `GetCells(origin)` API.
-Replace old boolean factory arguments with `NeoCellPatternExcluding.None`
-or `.Center`. To retain Line's old default, pass
-`excluding: NeoCellPatternExcluding.Center` explicitly.
+In C#, the generated `NeoCellPattern` implements `INeoCellPattern`, an
+`IReadOnlyList<Vector2Int>` of offsets, and SDK grid helpers accept any
+`INeoCellPattern`. Replace old boolean factory arguments with
+`NeoCellPatternExcluding.None` or `.Center`. To retain Line's old default,
+pass `excluding: NeoCellPatternExcluding.Center` explicitly.
 
 ## Tile placements
 

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.77.1 -->
+<!-- reviewed-through-cli: 0.79.0 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -35,7 +35,8 @@ names with readable ones. It keeps chosen names and rewrites references. Use
 declaration file grouping already recorded by the workspace, while
 declarations with no prior placement use the canonical per-declaration layout. Use `--force` only to discard local edits for the server
 version. Normal pulls persist a transaction cursor and fetch only changed
-records. If the remote head is unchanged, pull preserves the local source
+records. Dictionary string keys, including Unicode, round-trip through full and
+incremental reads. If the remote head is unchanged, pull preserves the local source
 without compiling it; use `neo status` to inspect local edits and diagnostics.
 Pull ignores records whose hashes already match the saved server baseline,
 including echoes of this checkout's last push, and advances its cursor without
@@ -86,7 +87,9 @@ does not prompt, upload, commit, or rewrite source.
 Removing a class or collection declaration also deletes its hidden collection
 entry members, including nested lists and dictionaries. Replacing a collection
 with a scalar deletes its abandoned entries too. Entries used by surviving
-declarations are retained. Review these derived deletions in `neo status` or
+declarations are retained. If a member is deleted locally before pulling remote
+instance values, pull retains those values in the deletion plan; the next push
+removes them with the member. Review these derived deletions in `neo status` or
 `neo diff` before pushing.
 
 Dry-run also compares the CLI's derived-edge extractor with the server version

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

@@ -91,7 +91,7 @@ Use context-aware typed annotations:
 - `@visibility(.Hidden)` only on a class; absence means visible.
 - Stateful settings use contextual enum cases, such as
   `@settings(format: .Plain)` and `@settings(kind: .Unordered)`.
-- `@settings(...)` before a `List` element or `Dictionary` value type
+- `@settings(...)` before a `List` or `Set` element or `Dictionary` value type
   configures the collection's entries: `List<@settings(format: .Plain) string>`,
   `Dictionary<string, @settings(min: 0) int>`. Only the member that declares
   the collection spells them; overrides share its entries.
@@ -271,6 +271,36 @@ A `Reference<T>` member satisfies an interface `T Foo { get; }` or
 
 Constructor and function parameters use `Set<T>` for several selections.
 
+### Set members
+
+`Set<T>` is an insertion-ordered collection that can't hold duplicates. The
+element picks the storage:
+
+- An enum `Set<Trait>` is a multi-select Enum.
+- `Set<Reference<T>>` is a multi-select lookup.
+- `Set<NeoDialogueReference>` is a multi-select dialogue lookup.
+- Any other element makes an owned Set whose entries are rows, like a List.
+
+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
+Set is always insertion-ordered.
+
+```neo
+@index(member: Slug, kind: .Unique)
+public Set<Quest> ActiveQuests = [];
+public Set<int> LuckyNumbers = [3, 7];
+public Set<Trait> Traits = [.Brave];
+```
+
+`selection:` is an error everywhere: `Set<T>` selects many and `T` selects
+one. The language server's quick fix rewrites `@settings(selection: .Multi)`
+to a `Set<…>` type. A default literal that repeats a value fails `push`, and a
+`List<Trait>` stays an ordered List of enum values. Queries over a Set, such
+as `Where` and `OrderBy`, return a Set; `ToSet()` turns a List into one.
+
 Declare a multicast event as `NeoAction<…>`. Its value is an ordered listener
 set, so give it a bracketed list of method groups — never a lambda, and never
 a bare method group — and never mark it `required`: the rest state is the
@@ -535,6 +565,9 @@ Populated unordered member defaults, such as `@settings(kind: .Unordered)` with
 `List<Entry> Entries = [new Entry()]`, are constructed by an initializer for
 each instance. A declaration has no container value row to own unordered entries.
 Nested unordered lists already have container rows and retain their stored values.
+A field, collection entry, or dictionary value can't place a value that
+something else already owns, such as `Bag = [Shared.Pattern]` or a constructor
+parameter stored in an ordinary field. Call `Clone()` or use `Reference`.
 
 A lookup's declared class must be assignable to the entry class of its
 `@settings(collection: Owner.Member)` collection. A subclass may narrow the

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

@@ -143,8 +143,8 @@ static function may be named as `Read` or qualified as `Holder.Read`/`Other.Read
 A qualified method group must name a static function. Method groups use the same
 signature rule as in a body, and a mismatch is reported at the declaration.
 A static field that names another static copies a value, as in
-`public static int B = Holder.A;`; a class, List, or Dictionary static shares
-the same object. A static delegate cannot copy another Class's delegate field,
+`public static int B = Holder.A;`. A class, List, Set, or Dictionary static
+already owns its value, so call `Clone()` or use `Reference`. A static delegate cannot copy another Class's delegate field,
 because its closure compiles in its own Class; wrap it as `() => Other.Call()`.
 Collection type arguments in constructions, such as `new Box<List<int>>([1, 2])`,
 work even when no field declares that collection type. Preparation includes the
@@ -356,9 +356,6 @@ count fails at runtime with `List.Repeat count must be non-negative; got
 still known. The value is evaluated exactly once, then the count exactly once,
 so side effects happen once regardless of `count`, and every entry is that one
 value: for a reference-typed entry the same reference repeats `count` times.
-Materializing the list charges `count` to the shared collection-entries
-execution budget, so a runaway count fails with the existing budget error
-before allocating.
 
 ## Conditional and logical operators
 
@@ -422,7 +419,6 @@ and `Select((key, value) => key)`. String-keyed dictionaries yield strings.
 Use `break` for the nearest loop or switch and `continue` for the nearest
 loop. A `continue` inside a switch nested in a loop continues the loop.
 
-All nested loops and called NeoScript bodies share a 10,000-iteration budget.
 A `while` loop checks its boolean condition before each iteration. A
 `do / while` loop runs its body once before checking the condition. Both
 require braces; the `do / while` condition ends with a semicolon.
@@ -437,8 +433,7 @@ do {
 } while (this.HasWork());
 ```
 
-`continue` checks the condition again in both loops. Each executed body counts
-against the shared iteration budget.
+`continue` checks the condition again in both loops.
 
 ## Switch
 

package/skills/neocompose-cli/references/values-identities-and-references.md

@@ -21,7 +21,7 @@ Root root = new() {
   @id("root-assets-member-id")
   @storage(allowed: .Immutable)
   Assets Assets = new() {
-    Outposts = [Assets.Capitol],
+    Outposts = [Assets.Capitol.Clone()],
   };
 }
 ```
@@ -44,6 +44,22 @@ class Assets {
 
 A computed static getter is an alias; it creates neither a binding nor a row.
 
+A static used in another initializer copies value kinds, including scalars and
+delegates. Class, list, set, and dictionary values have exactly one owner.
+Placing a value that something else already owns is refused: a static, a
+static's field, a collection entry, a local placed elsewhere, or a constructor
+parameter stored in an ordinary field. Status, push, and `neo test` report the
+placement at its authored position. Call `Clone()` to own a copy, or use
+`Reference`:
+
+```neo
+static Outpost Annex = Assets.Capitol.Clone();
+static Reference<Outpost> Seat = Reference(Assets.Capitol);
+```
+
+Statics created together may refer to each other regardless of declaration
+order; no preliminary push is needed.
+
 Enum-keyed dictionaries accept contextual or qualified option keys in defaults
 and stored values:
 
@@ -102,13 +118,18 @@ AudioSettings AUDIO_SETTINGS = new() { Main = SFX_FOLDER };
 ```
 
 In constructor arguments and executable operands, a class local names its one
-stored instance instead of constructing a copy:
+stored instance instead of constructing a copy. Its owning placement keeps it,
+so a constructor that stores it needs a `Reference` field:
 
 ```neo
 @id("86ac7c7d-8d3b-4642-9def-cdf32643bdc5")
 DeliveryQuest HARD_AS_STONE = new();
 // The core quest list owns HARD_AS_STONE.
 WorkflowStep UNLOCK = new QuestUnlockStep(HARD_AS_STONE);
+
+class QuestUnlockStep(DeliveryQuest quest) : WorkflowStep {
+  public Reference<DeliveryQuest> Quest = quest;
+}
 ```
 
 The referenced local must have exactly one owning placement. A nested target
@@ -312,6 +333,11 @@ different. The name must end with the binary's extension, because pull
 rebuilds the file's path from it. With no template annotation, the CLI persists the complete built-in
 Unity defaults for the file kind.
 
+Template-backed Unity settings may contain sparse nested override values and leaf
+paths such as `platformSettings.standalone.maxTextureSize` or
+`spriteSettings.pivot.x`. Preserve these paths during synchronization so untouched
+settings continue inheriting from the template.
+
 A top-level `NeoImage` or `NeoAudioClip` declaration in any definition file
 can stand in for an inline entry. The registry lists it by name
 (`NeoAudioClip SwordHit = SWORD_HIT;`), and the declaration carries the `@id`,