@neocompose/cli 0.35.0 → 0.36.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # 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
+
+- Treat `Partial<T>` values as sparse deltas throughout lowering and emission,
+  without invoking or reconstructing `T`'s required constructor.
+- Materialize complete Unity defaults for template-less image and audio
+  registry entries instead of writing an invalid template override shape.
+- Keep declarations inside variant delegate closures out of the global-child
+  registry, so separate `initialize` and `apply` closures may reuse local names.
+
 ## [0.35.0] - 2026-08-19
 
 ### Added

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),
@@ -18907,6 +19027,14 @@ function collectGlobalChildEntries(sourceText, declaration) {
   let pendingAnnotations = [];
   for (let index = 0; index < tokens.length; index++) {
     const token = tokens[index];
+    if (token.text === "(" || token.text === "[") {
+      groupDepth++;
+      continue;
+    }
+    if (token.text === ")" || token.text === "]") {
+      groupDepth--;
+      continue;
+    }
     if (token.text === "{") {
       braceDepth++;
       continue;
@@ -18916,14 +19044,6 @@ function collectGlobalChildEntries(sourceText, declaration) {
       continue;
     }
     if (braceDepth !== 1) continue;
-    if (token.text === "(" || token.text === "[") {
-      groupDepth++;
-      continue;
-    }
-    if (token.text === ")" || token.text === "]") {
-      groupDepth--;
-      continue;
-    }
     if (groupDepth !== 0) continue;
     if (token.text === ";") {
       pendingAnnotations = [];
@@ -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]
     ]);
   }
 });
@@ -48137,6 +48272,20 @@ function buildDefaultUnityTexture2DImportSettings() {
     }
   };
 }
+function buildDefaultUnityAudioClipImportSettings() {
+  return {
+    forceToMono: false,
+    normalize: true,
+    loadInBackground: false,
+    ambisonic: false,
+    loadType: "decompress-on-load" /* DecompressOnLoad */,
+    compressionFormat: "vorbis" /* Vorbis */,
+    quality: 1,
+    sampleRateSetting: "preserve-sample-rate" /* PreserveSampleRate */,
+    overrideSampleRate: null,
+    preloadAudioData: true
+  };
+}
 function isUnityVector2(value) {
   const v = value;
   if (!isObject(value)) return false;
@@ -53024,6 +53173,20 @@ var init_project_file_registry = __esm({
 });
 
 // src/project-source/project-file-source.ts
+function projectFileUnityImportSettingsV4(kind, templateId) {
+  if (templateId === null) {
+    return {
+      ...kind === "image" ? buildDefaultUnityTexture2DImportSettings() : buildDefaultUnityAudioClipImportSettings(),
+      templateId: null
+    };
+  }
+  return {
+    ...kind === "image" ? { type: "texture-2d" } : {},
+    templateId,
+    overridePaths: [],
+    values: {}
+  };
+}
 function emitProjectFileRegistrySourcesV4(records2) {
   const liveFiles = [...records2.values()].filter((record3) => record3.recordKind === "project-file" && !record3.deleted).map((record3) => ({ record: record3, data: requireFileData(record3) }));
   assertUniqueProjectBinaryPaths(liveFiles);
@@ -53142,12 +53305,10 @@ function lowerTrustedProjectFileRegistrySourcesV4(state, analysis, trustedPendin
       });
     }
     if (importSettingsChanged) {
-      next[settingsField] = {
-        ...declaration.kind === "image" ? { type: "texture-2d" } : {},
-        templateId: declaration.templateId,
-        overridePaths: [],
-        values: {}
-      };
+      next[settingsField] = projectFileUnityImportSettingsV4(
+        declaration.kind,
+        declaration.templateId
+      );
     }
     return {
       recordKind: "project-file",
@@ -53445,6 +53606,7 @@ var init_project_file_source = __esm({
     init_source_format();
     init_project_file_registry();
     init_members();
+    init_unity_import_settings();
     REGISTRY_ENTRY = /(?:@id\(\s*("(?:[^"\\]|\\.)*")\s*\)\s*)?(?:@settings\(([\s\S]*?)\)\s*)?(NeoImage|NeoAudioClip)\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*new\(\s*("(?:[^"\\]|\\.)*")\s*\)\s*;/gy;
     assignDeterministicFileSymbols = assignDeterministicProjectFileSymbols;
   }
@@ -70393,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);
@@ -70417,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);
@@ -98181,11 +98376,11 @@ function lowerMemberDefaultSourcesV4(state, analysis, manifest, options = {}) {
         context.parsedInitializers,
         declaration.initializer
       );
-      const requiresEvaluation = initializerRequiresEvaluation(
-        context.declaredConstructors,
+      const requiresEvaluation = memberInitializerRequiresEvaluation(
+        context,
+        member,
         annotatedValue(expression).expression,
-        memberClassName(context, member),
-        bindingRuntimeIdentifiers(context, binding)
+        binding
       );
       const baseData3 = stateData(context, "member", memberId);
       const annotatedExpression = annotatedValue(expression).expression;
@@ -98676,12 +98871,7 @@ function declaredCollectionMemberIds(context, collectionMemberId) {
 }
 function defaultRequiresOwnedRows(context, member, sourceExpression, source) {
   const expression = annotatedValue(sourceExpression).expression;
-  if (initializerRequiresEvaluation(
-    context.declaredConstructors,
-    expression,
-    memberClassName(context, member),
-    bindingRuntimeIdentifiers(context, source)
-  )) {
+  if (memberInitializerRequiresEvaluation(context, member, expression, source)) {
     return false;
   }
   if (member.kind === "class") return expression.kind === "new";
@@ -98693,6 +98883,15 @@ function defaultRequiresOwnedRows(context, member, sourceExpression, source) {
   }
   return false;
 }
+function memberInitializerRequiresEvaluation(context, member, expression, source) {
+  if (member.kind === "class" && member.partial === true) return false;
+  return initializerRequiresEvaluation(
+    context.declaredConstructors,
+    expression,
+    memberClassName(context, member),
+    bindingRuntimeIdentifiers(context, source)
+  );
+}
 function indexInitAuthoredRowIds(context, initSource, owner) {
   indexAuthoredRowIds(context.initAuthoredRowIds, initSource, owner);
 }
@@ -99240,7 +99439,7 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
     member,
     inheritedEnvironment
   );
-  if (context.structuralConstruction && resolvedMember.kind === "class" && expression.kind === "new" && structurallyConstructedClassId(context, resolvedMember, expression) !== null) {
+  if (context.structuralConstruction && resolvedMember.kind === "class" && resolvedMember.partial !== true && expression.kind === "new" && structurallyConstructedClassId(context, resolvedMember, expression) !== null) {
     return lowerStructuralConstructionRow(
       context,
       resolvedMember,
@@ -99255,11 +99454,11 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
       authoredSlice
     );
   }
-  if (!isStoredCallableLiteral(resolvedMember.kind, expression) && initializerRequiresEvaluation(
-    context.declaredConstructors,
+  if (!isStoredCallableLiteral(resolvedMember.kind, expression) && memberInitializerRequiresEvaluation(
+    context,
+    resolvedMember,
     expression,
-    memberClassName(context, resolvedMember),
-    bindingRuntimeIdentifiers(context, source)
+    source
   )) {
     const unattachedId = annotated.id === null ? unattachedAuthoredRowId(authoredSlice) : null;
     if (unattachedId !== null) {
@@ -99321,7 +99520,8 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
     if (effectiveClass === void 0) {
       throw new Error(`Unknown value class ${resolvedMember.classId}.`);
     }
-    if (effectiveClass.declarationModifier === "abstract") {
+    const partial = resolvedMember.partial === true;
+    if (!partial && effectiveClass.declarationModifier === "abstract") {
       throw new Error(
         `Cannot instantiate abstract class ${effectiveClass.name} for ${path}. Use a concrete descendant instead.`
       );
@@ -99339,13 +99539,15 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
       expression,
       declaredEnvironment
     );
-    validateConstructedGenericArguments(
-      context,
-      effectiveClass,
-      expression,
-      environment,
-      path
-    );
+    if (!partial) {
+      validateConstructedGenericArguments(
+        context,
+        effectiveClass,
+        expression,
+        environment,
+        path
+      );
+    }
     genericBindings = animationChildOverrideSeedBindings(
       context,
       effectiveClass,
@@ -99355,19 +99557,20 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
     );
     const body = {};
     const argumentSlices = constructorArgumentValueSlices(authoredSlice);
-    for (const {
-      projectedMember,
-      schemaKey,
-      argument: argument2,
-      argumentIndex
-    } of resolveConstructorProjectionArguments(
+    const projectedArguments = partial ? [] : resolveConstructorProjectionArguments(
       context,
       effectiveClass,
       expression,
       valueId,
       environment,
       source
-    )) {
+    );
+    for (const {
+      projectedMember,
+      schemaKey,
+      argument: argument2,
+      argumentIndex
+    } of projectedArguments) {
       const childPath = `${path}.${schemaKey}`;
       const childValueId = pendingNestedValueId(source, childPath);
       if (rows.has(childValueId)) {
@@ -99413,7 +99616,7 @@ function lowerSeedRow(context, member, sourceExpression, source, valueId, path,
         effectiveClass.id,
         assignment.name
       );
-      if (inheritedLegacyConstructorProjections(
+      if (!partial && inheritedLegacyConstructorProjections(
         context.classes,
         effectiveClass.id
       ).some((projection) => projection.memberId === childMember.id)) {
@@ -99853,11 +100056,11 @@ function lowerValueRow(context, member, sourceExpression, expectedValueId, sourc
     member,
     environment
   );
-  if (!isStoredCallableLiteral(resolvedMember.kind, expression) && initializerRequiresEvaluation(
-    context.declaredConstructors,
+  if (!isStoredCallableLiteral(resolvedMember.kind, expression) && memberInitializerRequiresEvaluation(
+    context,
+    resolvedMember,
     expression,
-    memberClassName(context, resolvedMember),
-    bindingRuntimeIdentifiers(context, source)
+    source
   )) {
     const code = initializerExpressionSlice(authoredSlice);
     if (code === void 0) {
@@ -100075,7 +100278,8 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
   const schemaClass2 = context.classes.get(classId);
   if (schemaClass2 === void 0)
     throw new Error(`Unknown value class ${classId}.`);
-  if (schemaClass2.declarationModifier === "abstract") {
+  const partial = member.partial === true;
+  if (!partial && schemaClass2.declarationModifier === "abstract") {
     throw new Error(
       `Cannot instantiate abstract class ${schemaClass2.name} for value ${String(base.id)}. Use a concrete descendant instead.`
     );
@@ -100090,13 +100294,15 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
     expression,
     declaredEnvironment
   );
-  validateConstructedGenericArguments(
-    context,
-    schemaClass2,
-    expression,
-    environment,
-    String(base.id ?? member.name)
-  );
+  if (!partial) {
+    validateConstructedGenericArguments(
+      context,
+      schemaClass2,
+      expression,
+      environment,
+      String(base.id ?? member.name)
+    );
+  }
   const baseBody = isObjectRecord2(base.value) ? base.value : {};
   const body = retainedStoredClassBody(
     context,
@@ -100104,7 +100310,7 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
     baseBody
   );
   const assignmentSlices = objectInitializerSlices(authoredSlice);
-  if (materializedConstruction !== "preserve") {
+  if (!partial && materializedConstruction !== "preserve") {
     lowerConstructorProjections(
       context,
       schemaClass2,
@@ -100119,7 +100325,7 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
   }
   for (const assignment of expression.initializer ?? []) {
     const childMember = classMemberByName(context, classId, assignment.name);
-    if (inheritedLegacyConstructorProjections(
+    if (!partial && inheritedLegacyConstructorProjections(
       context.classes,
       schemaClass2.id
     ).some((projection) => projection.memberId === childMember.id)) {
@@ -102173,7 +102379,7 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
   const hasStoredConstruction = isObjectRecord2(value.constructorArgs);
   let projection;
   try {
-    projection = hasStoredConstruction ? {
+    projection = partial ? { arguments: [], memberIds: /* @__PURE__ */ new Set(), targetValueIds: [] } : hasStoredConstruction ? {
       arguments: [],
       memberIds: new Set(
         effectiveConstructorProjections(
@@ -102210,7 +102416,7 @@ function classValue(context, member, value, visited, targetTyped, outerEnvironme
   const name = classValueTypeName(context, classId, member, environment);
   let storedConstruction;
   try {
-    storedConstruction = storedConstructorCallSource(
+    storedConstruction = partial ? null : storedConstructorCallSource(
       context,
       schemaClass2,
       value,
@@ -104166,12 +104372,10 @@ function lowerProjectFileRegistrySourcesV4(root, state, analysis, options = {})
       });
     }
     if (importSettingsChanged) {
-      next[settingsField] = {
-        ...declaration.kind === "image" ? { type: "texture-2d" } : {},
-        templateId: declaration.templateId,
-        overridePaths: [],
-        values: {}
-      };
+      next[settingsField] = projectFileUnityImportSettingsV4(
+        declaration.kind,
+        declaration.templateId
+      );
     }
     return {
       recordKind: "project-file",
@@ -104203,12 +104407,7 @@ function lowerDiscoveredProjectBinariesV4(root, state, analysis) {
     const templateId = binary.kind === "image" ? optionalString3(projectData.defaultTextureTemplateId) : optionalString3(projectData.defaultAudioClipTemplateId);
     const settingsField = binary.kind === "image" ? "unityTextureSettings" : "unityAudioClipSettings";
     const otherSettingsField = binary.kind === "image" ? "unityAudioClipSettings" : "unityTextureSettings";
-    const settings = {
-      ...binary.kind === "image" ? { type: "texture-2d" } : {},
-      templateId,
-      overridePaths: [],
-      values: {}
-    };
+    const settings = projectFileUnityImportSettingsV4(binary.kind, templateId);
     const now = Date.now();
     return {
       recordKind: "project-file",
@@ -104581,6 +104780,7 @@ var init_project_files = __esm({
     init_source_format();
     init_members();
     init_project_file_registry();
+    init_project_file_source();
     SUPPORTED_BINARY_TYPES = /* @__PURE__ */ new Map([
       [".png", { kind: "image", mimeType: "image/png" }],
       [".jpg", { kind: "image", mimeType: "image/jpeg" }],
@@ -113595,7 +113795,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.14",
-      cliVersion: "0.35.0",
+      cliVersion: "0.36.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -120197,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.0");
+    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.0",
+  "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.0 -->
+<!-- reviewed-through-cli: 0.36.0 -->
 
 # Neo Compose CLI
 
@@ -197,6 +197,8 @@ AudioClipRegistry AudioClips = new() {
 Use `Images.Sword.Slice(0)` for a sprite and `AudioClips.SwordHit` for audio.
 Renaming the registry symbol, moving the local presentation, or replacing bytes
 retains the file ID.
+Omitting `@settings(template: ...)` uses the complete built-in Unity import
+defaults for that file kind.
 
 ## Resolve conflicts by identity
 

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

@@ -50,7 +50,12 @@ NeoVariant<ExampleObject> Down = new(
   `() => new ExampleObject(.Down)` works; `apply` is void, so its expression
   body must be a call or an assignment, as in
   `(source) => source.FacingDir = .Down`. The server compiles them, so authored
-  source carries only the code.
+  source carries only the code. Each closure has its own lexical scope, so
+  local names may be reused between `initialize` and `apply`.
+- `overrides` and each child override's `overrides` value are `Partial<T>`
+  deltas over existing instances. They may use inferred `new { ... }` or
+  explicit `new Partial<T> { ... }`, and never pass arguments to or invoke
+  `T`'s constructor—even when `T` has a required constructor.
 
 Folders are records too, declared as their own globals and assigned per
 variant. Nesting is spelled in the path with `/`; intermediate segments are

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.0 -->
+<!-- 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`:

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

@@ -170,7 +170,8 @@ diff, and dry-run do not rewrite its registry. A successful push creates the
 record, uploads verified bytes, and materializes its declaration and ID.
 
 Edit the typed registry declaration directly when an explicit symbol or
-non-default template is needed before push.
+non-default template is needed before push. With no template annotation, the
+CLI persists the complete built-in Unity defaults for the file kind.
 
 Pull/push compare server-verified SHA-256, not storage ETags. A divergent
 binary keeps local bytes and writes the verified remote side under