@neocompose/cli 0.35.1 → 0.36.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [0.36.0] - 2026-08-19
+
+### Added
+
+- Add collection `Count` property access, optional-predicate `Count(...)`, and
+  list `IndexOf(value)` across NeoScript compilation, IntelliSense, web/CLI
+  evaluation, Unity export validation, and the matching Unity runtime.
+
+### Changed
+
+- **Breaking:** Unity export schema version is now 26 and the NeoScript
+  compiler revision is now 13. Exports containing `indexOf` or predicate
+  `count` IR require the matching Unity SDK.
+
+### Fixed
+
+- Prevent VS Code completion from replacing an existing identifier when an
+  author inserts `this.` before it.
+- Restrict action invocation and `NeoAction.Clear()` to the declaring class
+  and its derived classes. Public external callers may still subscribe and
+  unsubscribe with `+=` and `-=`.
+- Keep declaration-pattern bindings for indexed expressions such as
+  `items[index] is Item item`, so the bound local remains available inside the
+  successful branch without incorrectly treating the indexed expression as a
+  stable dotted narrowing path.
+- Diagnose `NeoAction<void>` with the canonical zero-argument spelling,
+  `NeoAction`, instead of later reporting the misleading invocation arity.
+
 ## [0.35.1] - 2026-08-19
 
 ### Fixed

package/dist/neo.mjs

@@ -2313,7 +2313,7 @@ function formatType(type, project) {
         )
       ].join(", ")}>${suffix}`;
     case "action":
-      return `NeoAction<${type.parameterTypes.map((parameter4) => formatType(parameter4, project)).join(", ")}>${suffix}`;
+      return `${type.parameterTypes.length === 0 ? "NeoAction" : `NeoAction<${type.parameterTypes.map((parameter4) => formatType(parameter4, project)).join(", ")}>`}${suffix}`;
   }
 }
 var UNKNOWN_TYPE;
@@ -2416,7 +2416,8 @@ function complete(snapshot, position) {
   if (insidePlainString(snapshot.lexed.tokens, offset)) {
     return { isIncomplete: false, items: [] };
   }
-  const word = wordRangeAt(snapshot.source.text, offset);
+  const wordAtCursor = wordRangeAt(snapshot.source.text, offset);
+  const word = { start: wordAtCursor.start, end: offset };
   const prefix = snapshot.source.text.slice(word.start, offset);
   const tokens = significantTokensBefore(snapshot.lexed.tokens, word.start);
   const tail = tokens[tokens.length - 1];
@@ -4129,10 +4130,20 @@ function collectionSymbols(kind, type) {
     method(
       "Count",
       { kind: "primitive", name: "int" },
-      [],
-      "Return the entry count."
+      [optionalCollectionPredicate(kind, entryType, keyType)],
+      "Return the entry count, optionally restricted by a predicate. It may also be read as a property."
     )
   ];
+  if (kind === "list") {
+    symbols.push(
+      method(
+        "IndexOf",
+        { kind: "primitive", name: "int" },
+        [parameter2("value", entryType)],
+        "Return the first matching index, or -1."
+      )
+    );
+  }
   if (!canMutate) return symbols;
   if (kind === "dictionary") {
     symbols.push(
@@ -4192,6 +4203,20 @@ function collectionSymbols(kind, type) {
 function lambdaParameters(kind, entry, key) {
   return kind === "dictionary" ? [parameter2("key", key), parameter2("value", entry)] : [parameter2("item", entry)];
 }
+function optionalCollectionPredicate(kind, entry, key) {
+  return {
+    name: "predicate",
+    type: {
+      kind: "delegate",
+      returnType: { kind: "primitive", name: "bool" },
+      parameterTypes: lambdaParameters(kind, entry, key).map(
+        (candidate) => candidate.type
+      ),
+      nullable: true
+    },
+    defaultValue: { displayText: "null", value: null }
+  };
+}
 function method(name, returnType, parameters, documentation) {
   return {
     id: `builtin:collection:${name}`,
@@ -4311,7 +4336,13 @@ function inferLambdaParameterType(local, snapshot) {
     (token) => token.start === snapshot.source.offsetAt(local.nameRange.start)
   );
   if (declarationIndex < 0) return UNKNOWN_TYPE;
-  const lambdaMethods = /* @__PURE__ */ new Set(["Where", "First", "FirstOrDefault", "Select"]);
+  const lambdaMethods = /* @__PURE__ */ new Set([
+    "Where",
+    "First",
+    "FirstOrDefault",
+    "Select",
+    "Count"
+  ]);
   for (let cursor = declarationIndex - 1; cursor >= 1; cursor--) {
     const open = tokens[cursor];
     const method2 = tokens[cursor - 1];
@@ -4354,7 +4385,10 @@ function symbolCompletion(symbol, word, snapshot) {
       range: snapshot.source.range(word.start, word.end),
       newText: insertText
     },
-    commitCharacters: callable2 ? ["("] : ["."],
+    // `.` is a completion trigger, not a commit character. Treating it as
+    // both lets VS Code accept a stale selection while an author prefixes an
+    // existing identifier (for example, typing `this.` before a member).
+    ...callable2 ? { commitCharacters: ["("] } : {},
     symbolId: symbol.id
   };
 }
@@ -4370,7 +4404,7 @@ function typeCompletion(type, word, snapshot) {
       range: snapshot.source.range(word.start, word.end),
       newText: type.name
     },
-    commitCharacters: [".", "<"],
+    commitCharacters: ["<"],
     symbolId: type.id
   };
 }
@@ -4386,7 +4420,7 @@ function indexCompletion(index, word, snapshot) {
       range: snapshot.source.range(word.start, word.end),
       newText: index.name
     },
-    commitCharacters: [".", "["],
+    commitCharacters: ["["],
     symbolId: index.id
   };
 }
@@ -8510,7 +8544,7 @@ var NEOSCRIPT_COMPILER_REVISION;
 var init_strict_ir = __esm({
   "../packages/neoscript-language/src/strict-ir.ts"() {
     "use strict";
-    NEOSCRIPT_COMPILER_REVISION = 12;
+    NEOSCRIPT_COMPILER_REVISION = 13;
   }
 });
 
@@ -8535,8 +8569,10 @@ function pathRoot(path) {
 }
 function factsFromIsCheck(expression, whenTrue) {
   const path = canonicalPath(expression.operand);
-  if (!path) return [];
   const nullCheck = expression.type.kind === "primitive" && expression.type.name === "null";
+  if (path === null && (!whenTrue || nullCheck || !expression.bindingName)) {
+    return [];
+  }
   if (whenTrue) {
     return nullCheck ? [{ expression: expression.operand, path, nullValue: true }] : [
       {
@@ -12156,10 +12192,10 @@ var init_strict_resolver = __esm({
       applyFactsToScope(outerScope, targetScope, facts, mode = "all") {
         for (const fact of facts) {
           if (mode === "bindings-only" && !fact.bindingName) continue;
-          const rootEntry = outerScope.lookup(pathRoot(fact.path));
-          if (!rootEntry) continue;
           const natural = this.resolveExpression(fact.expression, outerScope);
+          const rootEntry = fact.path === null ? null : outerScope.lookup(pathRoot(fact.path));
           if (fact.nullValue) {
+            if (fact.path === null || rootEntry === null) continue;
             if (fact.loose === true && natural.type.kind === "primitive" && (natural.type.name === "string" || natural.type.name === "int" || natural.type.name === "float" || natural.type.name === "bool")) {
               continue;
             }
@@ -12176,7 +12212,7 @@ var init_strict_resolver = __esm({
             const naturalDefinition = natural.type.kind === "named" ? this.project.typeById.get(natural.type.typeId) : void 0;
             const retainConcreteClass = !fact.bindingName && naturalDefinition?.kind === "class" && targetDefinition?.kind === "interface";
             const narrowed = retainConcreteClass ? { ...natural.type, nullable: false } : { ...target, nullable: false };
-            if (mode === "all") {
+            if (mode === "all" && fact.path !== null && rootEntry !== null) {
               targetScope.narrow(fact.path, rootEntry, narrowed);
             }
             if (fact.bindingName) {
@@ -12193,6 +12229,7 @@ var init_strict_resolver = __esm({
             }
             continue;
           }
+          if (fact.path === null || rootEntry === null) continue;
           if (!isNullable(natural.type)) continue;
           targetScope.narrow(fact.path, rootEntry, {
             ...natural.type,
@@ -12650,6 +12687,19 @@ var init_strict_resolver = __esm({
             indexSurface: receiver.type
           };
         }
+        if (name === "Count" && collectionPartsFor(receiver) !== null) {
+          if (nullPropagating) {
+            throw new CompileError(
+              "Null-propagating collection Count access is not supported; coalesce or narrow the collection first.",
+              pos
+            );
+          }
+          return intrinsic(
+            "count" /* Count */,
+            { collectionPointer: receiver.pointer },
+            { kind: "primitive", name: "int" }
+          );
+        }
         const primitiveMember = resolvePrimitiveMember(receiver.type, name);
         if (primitiveMember) {
           if (isPrimitive(receiver.type, "DialogueRef")) {
@@ -14395,10 +14445,50 @@ var init_strict_resolver = __esm({
         const collection = collectionPartsFor(receiver);
         if (!collection) return null;
         if (name === "Count") {
-          requireArgCount(name, args, 0, pos);
+          if (args.length > 1) {
+            throw new CompileError(
+              `Count expects zero or one predicate, got ${args.length}.`,
+              pos
+            );
+          }
+          const fn = args[0] ? this.resolveCollectionLambda(
+            args[0],
+            collection,
+            { kind: "primitive", name: "bool" },
+            scope,
+            pos
+          ) : void 0;
           return intrinsic(
             "count" /* Count */,
-            { collectionPointer: receiver.pointer },
+            {
+              collectionPointer: receiver.pointer,
+              ...fn ? { function: fn } : {}
+            },
+            { kind: "primitive", name: "int" }
+          );
+        }
+        if (name === "IndexOf" && collection.kind === "list") {
+          requireArgCount(name, args, 1, pos);
+          const expectedValueType = collectionOperationValueType(
+            receiver,
+            collection
+          );
+          const value = this.resolveExpression(
+            requiredAt(args, 0),
+            scope,
+            expectedValueType
+          );
+          this.requireCollectionOperationAssignable(
+            value.type,
+            expectedValueType,
+            receiver,
+            collection,
+            pos,
+            "IndexOf argument"
+          );
+          return intrinsic(
+            "indexOf" /* IndexOf */,
+            { collectionPointer: receiver.pointer, valuePointer: value.pointer },
             { kind: "primitive", name: "int" }
           );
         }
@@ -14790,6 +14880,7 @@ var init_strict_resolver = __esm({
        * return and no optional form to carry.
        */
       resolveActionCall(action, actionType, expression, scope) {
+        this.assertActionControlAccessible(action, "invoke", expression.pos);
         if (expression.callee.kind === "member" && expression.callee.optional) {
           throw new CompileError(
             `${this.describe(actionType)} is never null, so optional-chained invocation is not supported.`,
@@ -15047,6 +15138,7 @@ var init_strict_resolver = __esm({
         }
         const receiver = this.resolveExpression(expression.callee.receiver, scope);
         if (receiver.type.kind !== "action") return null;
+        this.assertActionControlAccessible(receiver, "clear", pos);
         if (expression.callee.optional) {
           throw new CompileError(
             `${this.describe(receiver.type)} is never null, so optional-chained Clear is not supported.`,
@@ -15109,6 +15201,34 @@ var init_strict_resolver = __esm({
           }
         };
       }
+      /**
+       * An action's declared accessibility controls who may subscribe. Invoking
+       * or clearing its listener set is a separate, protected-like capability:
+       * the declaring class and its subclasses may raise/reset the action, while
+       * public callers remain limited to `+=` and `-=`.
+       */
+      assertActionControlAccessible(action, operation, pos) {
+        const symbol = action.symbol;
+        const owner = symbol === void 0 ? void 0 : symbol.inheritedFrom ? this.project.typeById.get(symbol.inheritedFrom.typeId) : [...this.project.typeById.values()].find(
+          (type) => type.members.some(
+            (candidate) => candidate.id === symbol.id && candidate.inheritedFrom === void 0
+          )
+        );
+        if (symbol !== void 0 && owner !== void 0 && memberAccessFailure({
+          project: this.project,
+          context: this.context,
+          owner,
+          symbol: { ...symbol, accessModifier: "protected" }
+        }) === null) {
+          return;
+        }
+        const verb = operation === "invoke" ? "invoked" : "cleared";
+        const actionName = symbol === void 0 ? this.describe(action.type) : `'${owner?.name ?? symbol.inheritedFrom?.typeName ?? "Unknown"}.${symbol.name}'`;
+        throw new CompileError(
+          `Action ${actionName} can only be ${verb} from its declaring class or a derived class; external callers may only subscribe with '+=' or '-='.`,
+          pos
+        );
+      }
       resolveConditionalExpression(expression, scope, expected) {
         const condition = this.toBool(
           this.resolveExpression(expression.condition, scope),
@@ -26556,6 +26676,15 @@ function validateTypeApplication(uri, type, genericParameters, environment, diag
     return;
   }
   if (type.name === "NeoAction") {
+    if (type.typeArguments.some((argument2) => argument2.name === "void")) {
+      diagnose(
+        diagnostics,
+        uri,
+        type.range,
+        "invalid-member-type",
+        "Type 'NeoAction' cannot use 'void' as a parameter type; spell a zero-argument action as bare 'NeoAction'."
+      );
+    }
     if (type.typeArguments.length > 16) {
       diagnose(
         diagnostics,
@@ -29087,10 +29216,8 @@ function maskOutsideProjectBody(text, start, end) {
 }
 function projectWordRange(text, offset) {
   let start = offset;
-  let end = offset;
   while (start > 0 && /[A-Za-z0-9_]/.test(text[start - 1] ?? "")) start--;
-  while (end < text.length && /[A-Za-z0-9_]/.test(text[end] ?? "")) end++;
-  return { start, end };
+  return { start, end: offset };
 }
 function isContextualDot(text, wordStart) {
   if (text[wordStart - 1] !== ".") return false;
@@ -42957,6 +43084,13 @@ function isNSFunctionContains(value) {
   if (typeof info !== "object" || info === null) return false;
   return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer);
 }
+function isNSFunctionIndexOf(value) {
+  const v = value;
+  if (v?.type !== "indexOf" /* indexOf */) return false;
+  const info = v.info;
+  if (typeof info !== "object" || info === null) return false;
+  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer);
+}
 function isNSFunctionStringOp(value) {
   const v = value;
   if (v?.type !== "stringOp" /* stringOp */) return false;
@@ -43010,12 +43144,7 @@ function isNSFunctionListRepeat(value) {
 }
 function isNSFunctionCount(value) {
   const v = value;
-  if (v?.type !== "count" /* count */) return false;
-  const info = v.info;
-  if (typeof info !== "object" || info === null) return false;
-  return isNSPointer(
-    info.collectionPointer
-  );
+  return v?.type === "count" /* count */ && isNSCollectionOptionalBoolFunction(v.info);
 }
 function isNSDialogueMemoryFunctionInfo(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -43052,7 +43181,7 @@ function isNSFunctionImageSlice(value) {
   return isNSPointer(info.sliceIndexPointer);
 }
 function isNSFunction(value) {
-  return isNSFunctionClassConstructor(value) || isNSFunctionClassClone(value) || isNSFunctionListIndex(value) || isNSFunctionSelect(value) || isNSFunctionFirst(value) || isNSFunctionFirstOrDefault(value) || isNSFunctionWhere(value) || isNSFunctionContains(value) || // stringOp was missing from this chain since its introduction — a
+  return isNSFunctionClassConstructor(value) || isNSFunctionClassClone(value) || isNSFunctionListIndex(value) || isNSFunctionSelect(value) || isNSFunctionFirst(value) || isNSFunctionFirstOrDefault(value) || isNSFunctionWhere(value) || isNSFunctionContains(value) || isNSFunctionIndexOf(value) || // stringOp was missing from this chain since its introduction — a
   // compiled getter using ToLower()/StartsWith() would fail pointer
   // validation anywhere isNSFunction gates. Fixed alongside decimalOp.
   isNSFunctionStringOp(value) || isNSFunctionDecimalOp(value) || isNSFunctionMathOp(value) || isNSFunctionListRepeat(value) || isNSFunctionCount(value) || isNSFunctionVisitCount(value) || isNSFunctionHasVisited(value) || isNSFunctionVectorConstructor(value) || isNSFunctionImageSlice(value) || isNSFunctionVariantInitialize(value) || isNSFunctionVariantApply(value) || isNSFunctionDeclaredConstructor(value);
@@ -43277,7 +43406,12 @@ function minimumNeoScriptCompilerRevisionForIR(node, visited = /* @__PURE__ */ n
   visited.add(node);
   const discriminatorRevision = "type" in node && typeof node.type === "string" ? MINIMUM_REVISION_BY_IR_DISCRIMINATOR.get(node.type) ?? 1 : 1;
   const fallbackRevision = "missingMemberFallback" in node && node.missingMemberFallback === "valueEquality" ? 12 : 1;
-  let minimum = Math.max(discriminatorRevision, fallbackRevision);
+  const countPredicateRevision = "type" in node && node.type === "count" /* count */ && "info" in node && typeof node.info === "object" && node.info !== null && "function" in node.info && node.info.function !== void 0 && node.info.function !== null ? 13 : 1;
+  let minimum = Math.max(
+    discriminatorRevision,
+    fallbackRevision,
+    countPredicateRevision
+  );
   const isLiteralValue = "typeInfo" in node && "value" in node && !("type" in node);
   for (const [key, child] of Object.entries(node)) {
     if (isLiteralValue && key === "value") continue;
@@ -43379,7 +43513,8 @@ var init_neoscript_guards = __esm({
       ["removeActionListener" /* removeActionListener */, 8],
       ["callAction" /* callAction */, 8],
       ["conditional" /* conditional */, 12],
-      ["delegateClosure" /* delegateClosure */, 12]
+      ["delegateClosure" /* delegateClosure */, 12],
+      ["indexOf" /* indexOf */, 13]
     ]);
   }
 });
@@ -70420,7 +70555,23 @@ function evalFunction(fn, scope, ctx) {
     }
     case "count" /* count */: {
       const c = evalPointer(fn.info.collectionPointer, scope, ctx);
-      return collectionLength(c);
+      const innerFn = fn.info.function ?? null;
+      if (innerFn === null) return collectionLength(c);
+      const isList = isListCollection(c);
+      let count = 0;
+      const callback = prepareCollectionCallback(
+        innerFn,
+        scope,
+        ctx,
+        isList,
+        "predicate",
+        () => {
+          count += 1;
+          return 0 /* Continue */;
+        }
+      );
+      iterateCollection(c, ctx, callback);
+      return count;
     }
     case "contains" /* contains */: {
       const c = evalPointer(fn.info.collectionPointer, scope, ctx);
@@ -70444,6 +70595,23 @@ function evalFunction(fn, scope, ctx) {
       });
       return containsResolvedEntry;
     }
+    case "indexOf" /* indexOf */: {
+      const collection = listArg(
+        evalPointer(fn.info.collectionPointer, scope, ctx),
+        "IndexOf receiver"
+      );
+      const target = evalPointer(fn.info.valuePointer, scope, ctx);
+      const targetReferenceId = typeof target === "string" ? target : findKnownRowIdByValueReference(target, ctx);
+      let found = -1;
+      iterateCollection(collection, ctx, (entry, key, valueId) => {
+        if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
+          found = numberArg(key, "IndexOf index");
+          return 1 /* Break */;
+        }
+        return 0 /* Continue */;
+      });
+      return found;
+    }
     case "decimalOp" /* decimalOp */: {
       const info = fn.info;
       const receiverRaw = evalPointer(info.receiverPointer, scope, ctx);
@@ -113627,7 +113795,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.14",
-      cliVersion: "0.35.1",
+      cliVersion: "0.36.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -120229,7 +120397,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.35.1");
+    console.log("0.36.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

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

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

@@ -80,9 +80,14 @@ 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()`.
+Spell a zero-argument action as bare `NeoAction`; type arguments name action
+parameters, so `NeoAction<void>` is invalid rather than a zero-argument alias.
 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.
+action member's effective storage and writability. Only the action's declaring
+class and derived classes may invoke it or call `Clear()`; public external
+callers may subscribe and unsubscribe with `+=` and `-=` but cannot raise or
+reset the action.
 
 Inline `NeoDelegate` lambdas may be returned or stored and may read surrounding
 locals and parameters. Those values are captured when the lambda is created,
@@ -172,7 +177,17 @@ 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.
 
-## List builtins
+## Collection builtins
+
+Lists expose their size as either `items.Count` or `items.Count()`. Use
+`items.Count((item) => predicate)` to count only matching entries without
+materializing a filtered list. The same Count forms work on Dictionary and Set
+collections; dictionary predicates may accept `(key, value)` just like the
+other collection callbacks.
+
+Use `items.IndexOf(value)` to return the zero-based index of the first equal
+list entry, or `-1` when the value is absent. `IndexOf` is list-only and uses
+the same value/reference equality as `Contains`.
 
 Use `List.Repeat(value, count)` to build a list of `count` copies of a value
 instead of hand-counting a literal or looping around `Add`: