@neocompose/cli 0.35.1 → 0.36.1

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## [0.36.1] - 2026-08-19
+
+### Fixed
+
+- Preserve authored function parameter defaults in live project-source symbols,
+  so calls may omit a defaulted trailing argument and hover/signature help show
+  the declared `= value`.
+- Store direct field and property reads, including static getters such as
+  `FeatureFlags.StartInventorySize`, as executable member initializers instead
+  of rejecting them as unresolved persisted literals.
+
+## [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),
@@ -25170,13 +25290,14 @@ function compileProjectSourceBodies(documents) {
             implicitMemberAccess: true,
             staticMember: false,
             kind: "constructor",
-            parameters: constructor2.parameters.map((parameter4, index) => ({
-              id: `${declaredConstructorId(owner, declaration, constructor2)}:argument:${index}`,
-              name: parameter4.name,
-              type: sourceTypeRef(parameter4.type, owner, graph.typeIdsByName),
-              location: location(uri, parameter4.range),
-              selectionLocation: location(uri, parameter4.nameRange)
-            })),
+            parameters: constructor2.parameters.map(
+              (parameter4, index) => sourceParameter(
+                parameter4,
+                owner,
+                graph.typeIdsByName,
+                `${declaredConstructorId(owner, declaration, constructor2)}:argument:${index}`
+              )
+            ),
             functionName: constructor2.name
           },
           projectIndex,
@@ -25205,13 +25326,12 @@ function compileProjectSourceBodies(documents) {
             staticMember: false,
             kind: "constructor",
             parameters: (declaration.headerParameters ?? []).map(
-              (parameter4, index) => ({
-                id: `${initId}:argument:${index}`,
-                name: parameter4.name,
-                type: sourceTypeRef(parameter4.type, owner, graph.typeIdsByName),
-                location: location(uri, parameter4.range),
-                selectionLocation: location(uri, parameter4.nameRange)
-              })
+              (parameter4, index) => sourceParameter(
+                parameter4,
+                owner,
+                graph.typeIdsByName,
+                `${initId}:argument:${index}`
+              )
             ),
             functionName: "init"
           },
@@ -25248,13 +25368,14 @@ function compileProjectSourceBodies(documents) {
             context: {
               ...baseContext2,
               kind: "function",
-              parameters: member.parameters.map((parameter4, index) => ({
-                id: `${info.symbol.id}:argument:${index}`,
-                name: parameter4.name,
-                type: sourceTypeRef(parameter4.type, owner, graph.typeIdsByName),
-                location: location(uri, parameter4.range),
-                selectionLocation: location(uri, parameter4.nameRange)
-              })),
+              parameters: member.parameters.map(
+                (parameter4, index) => sourceParameter(
+                  parameter4,
+                  owner,
+                  graph.typeIdsByName,
+                  `${info.symbol.id}:argument:${index}`
+                )
+              ),
               deferred: member.modifiers.includes("async"),
               functionName: member.name
             },
@@ -25621,13 +25742,9 @@ function sourceMemberSymbol(member, owner, typeIds, source) {
       ...common,
       kind: "function",
       returnType: type,
-      parameters: member.parameters.map((parameter4, index) => ({
-        id: `${id2}:argument:${index}`,
-        name: parameter4.name,
-        type: sourceTypeRef(parameter4.type, owner, typeIds),
-        location: location(owner.uri, parameter4.range),
-        selectionLocation: location(owner.uri, parameter4.nameRange)
-      })),
+      parameters: member.parameters.map(
+        (parameter4, index) => sourceParameter(parameter4, owner, typeIds, `${id2}:argument:${index}`)
+      ),
       deferred: member.modifiers.includes("async"),
       ...member.modifiers.includes("native") ? { native: true } : {}
     };
@@ -25699,8 +25816,7 @@ function requiredConstructorSymbol(owner, declaration, typeIds) {
   return {
     id: requiredConstructorBodyId(owner),
     parameters: headerParameters.map((parameter4) => ({
-      name: parameter4.name,
-      type: sourceTypeRef(parameter4.type, owner, typeIds),
+      ...sourceParameter(parameter4, owner, typeIds),
       required: !parameter4.type.nullable
     })),
     required: true,
@@ -25711,14 +25827,23 @@ function declaredConstructorSymbol(owner, declaration, constructor2, typeIds) {
   return {
     id: declaredConstructorId(owner, declaration, constructor2),
     parameters: constructor2.parameters.map((parameter4) => ({
-      name: parameter4.name,
-      type: sourceTypeRef(parameter4.type, owner, typeIds),
+      ...sourceParameter(parameter4, owner, typeIds),
       required: !parameter4.type.nullable
     })),
     ...constructor2.docsText ? { documentation: constructor2.docsText } : {},
     location: location(owner.uri, constructor2.range)
   };
 }
+function sourceParameter(parameter4, owner, typeIds, id2) {
+  return {
+    ...id2 === void 0 ? {} : { id: id2 },
+    name: parameter4.name,
+    type: sourceTypeRef(parameter4.type, owner, typeIds),
+    ...parameter4.defaultValue === void 0 ? {} : { defaultValue: { displayText: parameter4.defaultValue.text } },
+    location: location(owner.uri, parameter4.range),
+    selectionLocation: location(owner.uri, parameter4.nameRange)
+  };
+}
 function substituteInheritedSourceMember(member, baseInfo, resolvedBaseType) {
   if (baseInfo.declaration.kind !== "class" || resolvedBaseType.kind !== "named") {
     return {
@@ -26556,6 +26681,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 +29221,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 +43089,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 +43149,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 +43186,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 +43411,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 +43518,8 @@ var init_neoscript_guards = __esm({
       ["removeActionListener" /* removeActionListener */, 8],
       ["callAction" /* callAction */, 8],
       ["conditional" /* conditional */, 12],
-      ["delegateClosure" /* delegateClosure */, 12]
+      ["delegateClosure" /* delegateClosure */, 12],
+      ["indexOf" /* indexOf */, 13]
     ]);
   }
 });
@@ -59595,6 +59735,7 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
 function positionRequiresEvaluation(context, expression, expected, ownerClass) {
   if (isStoredDelegateLiteral(expected, expression)) return false;
   if (isStoredActionLiteral(expected, expression)) return false;
+  if (isSourceMemberValueRead(context, expression, ownerClass)) return true;
   return initializerRequiresEvaluation(
     context.declaredConstructors,
     expression,
@@ -59605,6 +59746,36 @@ function positionRequiresEvaluation(context, expression, expected, ownerClass) {
     )
   );
 }
+function isSourceMemberValueRead(context, expression, ownerClass) {
+  let current = expression;
+  while (current.kind === "annotated") current = current.expression;
+  const path = expressionMemberPath(current);
+  if (path === null) return false;
+  const parts = path.split(".");
+  let classId;
+  let memberName;
+  let requiresStatic = false;
+  if (parts.length === 1 || parts.length === 2 && parts[0] === "this") {
+    classId = materializedId(ownerClass, "class", ownerClass.name);
+    memberName = parts.at(-1);
+  } else if (parts.length === 2) {
+    classId = context.classIdsByName.get(parts[0]);
+    memberName = parts[1];
+    requiresStatic = true;
+  } else {
+    const receiverPath = parts.slice(0, -1).join(".");
+    classId = context.rootValueTargetsByPath.get(receiverPath)?.classId;
+    memberName = parts.at(-1);
+  }
+  if (classId === void 0 || memberName === void 0) return false;
+  const memberId = effectiveMemberIdByName(context, classId, memberName);
+  if (memberId === null) return false;
+  const source = context.sourceMembersById.get(memberId)?.member;
+  if (source?.kind === "function") return false;
+  const schema = context.loweredMembers.get(memberId) ?? context.baseMembers.get(memberId);
+  const isStatic = source?.modifiers.includes("static") ?? schema?.isStatic ?? false;
+  return !requiresStatic || isStatic;
+}
 function isStoredDelegateLiteral(type, expression) {
   if (type.name !== "NeoDelegate") return false;
   let current = expression;
@@ -70420,7 +70591,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 +70631,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 +113831,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.14",
-      cliVersion: "0.35.1",
+      cliVersion: "0.36.1",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -120229,7 +120433,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.1");
     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.1",
   "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.1 -->
 
 # 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.1 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -154,6 +154,12 @@ components must be numeric literals. When a computed list or dictionary entry
 carries an authored `@id`, parenthesize the expression — `@id("row")
 (A.B / A.C)` — so the annotation names the row rather than its left operand.
 
+A direct field or property read is computed too, whether it is local,
+qualified static, or reached through a stable root path. For example,
+`protected int Slots = FeatureFlags.StartInventorySize;` evaluates the current
+static field or getter whenever a new instance is constructed; it is not baked
+into a persisted literal during push.
+
 Declare overloadable constructors as members when each constructor body owns
 its parameter scope:
 

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`: