@neocompose/cli 0.72.1 → 0.72.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.72.2] - 2026-10-08
+
+- Resolve void statement calls through generic class and interface constraints, preserving generic arguments and receiver nullability checks.
+- Infer contextual enum literals in positional and named constructor arguments, including generic parameters and overloads with defaults.
+- Reject unrelated explicit class constructions in typed initializers, with source diagnostics that agree between the editor and CLI. Preserve concrete and generic types when a local target-typed construction is stored through a base-class member.
+
 ## [0.72.1] - 2026-10-07
 
 - Speed up `neo export` and `neo dev`: reuse verified unchanged exports, cache unchanged parsing and preparation work, share dialogue compiler symbols, and index Unity generation. Regenerate C# only when its schema inputs change; continue validating edited content and repairing changed output files.

package/dist/neo.mjs

@@ -20567,11 +20567,12 @@ var init_local_values = __esm({
     init_formatter();
     init_workspace_source_path();
     init_executable_parser();
+    init_source_text();
     init_language_spec();
     init_lower_support();
     LocalValueBindingsV4 = class {
       definitions = /* @__PURE__ */ new Map();
-      expressions = /* @__PURE__ */ new Map();
+      initializers = /* @__PURE__ */ new Map();
       owners = /* @__PURE__ */ new Map();
       /** Static members whose initializer is a bare local name, by that name. */
       ownerMembers = /* @__PURE__ */ new Map();
@@ -20608,7 +20609,7 @@ var init_local_values = __esm({
             owners.set(valueId, source.label);
             this.owners.set(global.name, owners);
           }
-          text = global.initializer;
+          text = step.text;
           expression = step.expression;
           source = {
             ...source,
@@ -20627,7 +20628,28 @@ var init_local_values = __esm({
         let last = null;
         for (const step of this.chain(name)) last = step;
         if (last === null) return null;
-        return { expression: last.expression, text: last.global.initializer };
+        return { expression: last.expression, text: last.text };
+      }
+      initializer(global) {
+        const cached = this.initializers.get(global.name);
+        if (cached) return cached;
+        let text = global.initializer;
+        let expression = parseExpression(text);
+        let construction = expression;
+        while (construction.kind === "annotated")
+          construction = construction.expression;
+        if (construction.kind === "new" && construction.className === null) {
+          const offset = new SourceText(text).offsetAt({
+            line: construction.pos.line - 1,
+            character: construction.pos.column - 1
+          }) + 3;
+          const type = typeText({ ...global.type, nullable: false });
+          text = `${text.slice(0, offset)} ${type}${text.slice(offset)}`;
+          expression = parseExpression(text);
+        }
+        const prepared = { global, expression, text };
+        this.initializers.set(global.name, prepared);
+        return prepared;
       }
       /** Each local an alias chain starting at `name` passes through, in order. */
       *chain(name) {
@@ -20637,9 +20659,9 @@ var init_local_values = __esm({
           if (visited.has(global.name))
             throw new Error(`Local initializer cycle reaches ${global.name}.`);
           visited.add(global.name);
-          const expression = this.expressions.get(global.name) ?? parseExpression(global.initializer);
-          this.expressions.set(global.name, expression);
-          yield { global, expression };
+          const prepared = this.initializer(global);
+          const { expression } = prepared;
+          yield prepared;
           global = expression.kind === "ident" ? this.definitions.get(expression.name) : void 0;
         }
       }
@@ -20685,7 +20707,7 @@ var init_local_values = __esm({
         const placements = [];
         for (const [name, definition2] of this.definitions) {
           const valueIds = this.owners.get(name)?.keys().toArray() ?? [];
-          const expression = this.expressions.get(name) ?? parseExpression(definition2.initializer);
+          const expression = this.initializers.get(name)?.expression ?? parseExpression(definition2.initializer);
           placements.push({
             name,
             type: typeText(definition2.type),
@@ -28282,6 +28304,20 @@ var init_collection_query = __esm({
 function neoScriptArgumentNameSetKey(names) {
   return [...names].map((name) => name.toLowerCase()).sort().join(",");
 }
+function neoScriptParameterByName(parameters, name) {
+  let indexes3 = parameterNameIndexes.get(parameters);
+  if (!indexes3) {
+    const built = /* @__PURE__ */ new Map();
+    for (let index2 = 0; index2 < parameters.length; index2++) {
+      const key = parameters[index2].name.toLowerCase();
+      if (!built.has(key)) built.set(key, index2);
+    }
+    indexes3 = built;
+    parameterNameIndexes.set(parameters, indexes3);
+  }
+  const index = indexes3.get(name.toLowerCase());
+  return index === void 0 ? void 0 : parameters[index];
+}
 function neoScriptCallMatchesParameters(suppliedNames, parameters) {
   const supplied = new Set(suppliedNames.map((name) => name.toLowerCase()));
   const declared = new Set(
@@ -28542,10 +28578,12 @@ function describeParameter(parameter4) {
   const defaulted = parameter4.defaultValue === void 0 ? "" : ` = ${parameter4.defaultValue.displayText}`;
   return `${parameter4.name}${nullability}${defaulted}`;
 }
+var parameterNameIndexes;
 var init_declared_constructors = __esm({
   "../packages/neoscript-language/src/declared-constructors.ts"() {
     "use strict";
     init_project2();
+    parameterNameIndexes = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -35304,6 +35342,7 @@ var init_strict_resolver = __esm({
             (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === callee.name
           );
           if (member) {
+            this.validateFunctionReceiver(receiver, callee.name, optional2, pos);
             if (type !== void 0) this.assertMemberAccessible(type, member, pos);
             if (member.static === true) {
               throw new CompileError(
@@ -36452,12 +36491,10 @@ var init_strict_resolver = __esm({
       callableSignatureForReceiver(symbol, receiver) {
         let parameters = symbol.parameters ?? [];
         let returnType = symbol.returnType ?? symbol.type;
-        if (this.context.projectSourceKind !== "spec" && !(receiver?.kind === "instance" && receiver.dispatch === "base")) {
-          return { parameters, returnType };
-        }
         if (receiver?.kind !== "instance") return { parameters, returnType };
         const receiverType = receiver.expression.type;
         if (receiverType.kind !== "named") return { parameters, returnType };
+        if (!receiverType.typeArguments?.length) return { parameters, returnType };
         const declaring = this.project.typeById.get(receiverType.typeId);
         if (declaring === void 0) return { parameters, returnType };
         parameters = parameters.map((parameter4) => ({
@@ -37361,6 +37398,21 @@ var init_strict_resolver = __esm({
           callSiteId: this.nextCallSite(expression.pos)
         };
       }
+      validateFunctionReceiver(receiver, name, optional2, pos) {
+        if (optional2 && !isNullable(receiver.type)) {
+          throw new CompileError(
+            `\`?.\` requires an optional receiver; got ${this.describe(receiver.type)}`,
+            pos
+          );
+        }
+        const receiverType = receiver.optionalChainType ?? receiver.type;
+        if (!optional2 && isNullable(receiverType)) {
+          throw new CompileError(
+            `Function '${name}' is called on ${this.describe(receiverType)}, which may be null. Use optional chaining, force-unwrapping, or a null check before calling it.`,
+            pos
+          );
+        }
+      }
       resolveFunctionStatement(expression, scope) {
         if (expression.kind !== "call") return null;
         const receiverValue = this.callReceiver(expression.callee, scope);
@@ -37524,12 +37576,19 @@ var init_strict_resolver = __esm({
           }
         }
         const receiver = receiverValue();
-        if (receiver.type.kind !== "named") return null;
-        const type = this.project.typeById.get(receiver.type.typeId);
+        const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+        if (memberReceiverType.kind !== "named") return null;
+        const type = this.project.typeById.get(memberReceiverType.typeId);
         const symbol = type?.members.find(
           (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === memberName
         );
         if (!symbol) return null;
+        this.validateFunctionReceiver(
+          receiver,
+          memberName,
+          expression.callee.optional === true,
+          expression.pos
+        );
         if (type !== void 0) {
           this.assertMemberAccessible(type, symbol, expression.pos);
         }
@@ -37542,7 +37601,10 @@ var init_strict_resolver = __esm({
         this.validateCallableInContext(symbol, expression.pos);
         const resolved = this.resolveCallableArguments(
           symbol,
-          { kind: "instance", expression: receiver },
+          {
+            kind: "instance",
+            expression: memberReceiverType === receiver.type ? receiver : { ...receiver, type: memberReceiverType }
+          },
           expression.args,
           scope,
           expression.pos
@@ -42576,6 +42638,7 @@ function createEnvironment(documents, project) {
     project,
     projectIndex: createProjectIndex(project),
     listenerResolvers: /* @__PURE__ */ new Map(),
+    assignability: /* @__PURE__ */ new Map(),
     enums,
     types,
     globals,
@@ -43854,13 +43917,19 @@ function validateExpression(expression, expected, scope, environment, uri, range
     );
     return;
   }
-  if (expected && expression.kind !== "contextualEnum" && !isReferenceCall(expression)) {
+  if (expected && expression.kind !== "contextualEnum" && expression.kind !== "annotated" && !isReferenceCall(expression)) {
     const actual = inferExpressionType(expression, scope, environment);
-    if (actual && !semanticTypesAssignable(actual, expected)) {
+    const explicitConstruction = expression.kind === "new" && expression.className !== null && expected.name !== "Partial";
+    const assignable = actual === void 0 || (explicitConstruction ? constructionTypesAssignable(actual, expected, scope, environment) : semanticTypesAssignable(actual, expected));
+    if (actual && !assignable) {
       pushDiagnostic(
         diagnostics,
         uri,
-        anchor ? anchorSpan(anchor, expression.pos, 1) : range2,
+        anchor ? anchorSpan(
+          anchor,
+          expression.pos,
+          expression.kind === "new" ? 3 : 1
+        ) : range2,
         "project-expression-type-mismatch",
         `Expected ${describeType(expected)} but received ${describeType(actual)}.`
       );
@@ -44134,23 +44203,26 @@ function validateExpression(expression, expected, scope, environment, uri, range
         }))
       );
     }
-    const fields = declaration?.members.filter(
-      (member) => member.kind === "field" && !member.modifiers.includes("static")
-    ) ?? [];
-    const overload = declaration && declaration.constructors.length > 0 ? matchingDeclaredConstructor(declaration, expression.argumentNames) : null;
+    const parameters = declaration.headerParameters ?? matchingDeclaredConstructor(declaration, siteArgumentNames)?.parameters;
+    const fields = [];
+    const fieldsByName = /* @__PURE__ */ new Map();
+    if (declaration.headerParameters === void 0 && declaration.constructors.length === 0) {
+      for (const member of declaration.members) {
+        if (member.kind !== "field" || member.modifiers.includes("static"))
+          continue;
+        fields.push(member);
+        fieldsByName.set(member.name, member);
+      }
+    }
     expression.args.forEach((argument2, index) => {
       const authoredName = expression.argumentNames?.[index];
       const named = declaration.name === NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME ? authoredName ?? NEO_LOOKUP_VARIANT_FOLDER_CONSTRUCTOR_ARGUMENTS[index]?.name : authoredName;
       if (declaration.name === NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME && named === "collection") {
         return;
       }
-      const parameter4 = named ? (declaration.headerParameters ?? []).find(
-        (candidate) => candidate.name === named
-      ) ?? overload?.parameters.find((candidate) => candidate.name === named) : void 0;
+      const parameter4 = named && parameters ? neoScriptParameterByName(parameters, named) : parameters?.[index];
       const variantMember = named === void 0 || named === null ? void 0 : variantSite === null ? void 0 : NEO_VARIANT_MEMBER_ARGUMENTS.get(named);
-      const field = named ? fields.find(
-        (candidate) => candidate.name === (variantMember ?? named)
-      ) : fields[index];
+      const field = named ? fieldsByName.get(variantMember ?? named) : fields[index];
       const expectedType = parameter4?.type ?? field?.type;
       const expectedSemanticType = declaration.name === NEO_LOOKUP_VARIANT_FOLDER_TYPE_NAME && named === "collectionValue" ? { name: "string" } : expectedType ? substituteSemanticType(semanticType(expectedType), siteBindings) : void 0;
       validateExpression(
@@ -44450,6 +44522,41 @@ function commonSemanticAssignableType(left, right) {
   if (semanticTypesAssignable(right, left)) return left;
   return void 0;
 }
+function constructionTypesAssignable(actual, expected, scope, environment) {
+  if (actual.name === expected.name && !actual.arguments?.length && !expected.arguments?.length)
+    return true;
+  const owner = scope.get("this")?.name ?? "";
+  const key = `${owner}:${describeType(actual)}>${describeType(expected)}`;
+  const cached = environment.assignability.get(key);
+  if (cached !== void 0) return cached;
+  const declaration = environment.projectIndex.typeByName.get(owner);
+  const context = {
+    project: environment.project,
+    kind: "initializerExpression",
+    ...declaration ? { declaringType: { kind: "named", typeId: declaration.id } } : {}
+  };
+  const pos = { line: 1, column: 1 };
+  let assignable = true;
+  try {
+    assignable = isNeoScriptTypeAssignable(
+      resolveNeoScriptType(
+        semanticAst(actual, pos),
+        context,
+        environment.projectIndex
+      ),
+      resolveNeoScriptType(
+        semanticAst(expected, pos),
+        context,
+        environment.projectIndex
+      ),
+      environment.projectIndex
+    );
+  } catch (error) {
+    if (!(error instanceof CompileError)) throw error;
+  }
+  environment.assignability.set(key, assignable);
+  return assignable;
+}
 function semanticNumericRank(name) {
   if (name === "int") return 0;
   if (name === "float") return 1;
@@ -44599,7 +44706,10 @@ function inferExpressionType(expression, scope, environment) {
   if (expression.kind === "litString" || expression.kind === "litInterp" || expression.kind === "litTripleString")
     return primitiveType("string");
   if (expression.kind === "new")
-    return expression.className ? { name: expression.className } : void 0;
+    return expression.className ? {
+      name: expression.className,
+      ...expression.typeArguments ? { arguments: expression.typeArguments.map(semanticAstType) } : {}
+    } : void 0;
   if (expression.kind === "force") {
     const operand = inferExpressionType(expression.operand, scope, environment);
     return operand ? { ...operand, nullable: false } : void 0;
@@ -44874,14 +44984,19 @@ function classExtends(actual, expected, environment, visited) {
   );
 }
 function matchingDeclaredConstructor(declaration, argumentNames) {
-  const names = (argumentNames ?? []).filter(
-    (name) => name !== null
-  );
-  const key = [...names].map((name) => name.toLowerCase()).sort().join(",");
-  const matches = declaration.constructors.filter(
-    (constructor2) => constructor2.parameters.map((parameter4) => parameter4.name.toLowerCase()).sort().join(",") === key
+  if (declaration.constructors.length === 1)
+    return declaration.constructors[0] ?? null;
+  if (argumentNames.some((name) => name === null)) return null;
+  const names = argumentNames.filter((name) => name !== null);
+  const resolution = resolveNeoScriptNamedOverload(
+    declaration.constructors,
+    names,
+    (constructor2) => constructor2.parameters.map((parameter4) => ({
+      name: parameter4.name,
+      defaulted: parameter4.defaultValue !== void 0
+    }))
   );
-  return matches.length === 1 ? matches[0] ?? null : null;
+  return resolution.kind === "resolved" ? resolution.overload : null;
 }
 function semanticType(type) {
   return {
@@ -45230,6 +45345,7 @@ var init_project_source_semantics = __esm({
     init_strict_compile_error();
     init_executable_parser();
     init_project_source_construction_diagnostics();
+    init_declared_constructors();
     init_project_source_variants();
     init_language_spec();
     init_project_source_settlement();
@@ -50866,7 +50982,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.72.1",
+      cliVersion: "0.72.2",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -110681,7 +110797,8 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
       continue;
     const key = `${change.recordKind}:${change.recordId}`;
     const base = baseScriptRecords.get(key);
-    if (base && canonicallyEqual2(
+    if (base && // Rollout-tolerated bodies still need recompilation before reuse.
+    firstRejectedNeoScriptCompiledBody(base, null) === null && !hasPendingNeoScriptDerivation(change.recordKind, base) && canonicallyEqual2(
       authoredScriptRecord(change.recordKind, base),
       authoredScriptRecord(change.recordKind, change.nextData)
     ))
@@ -110733,12 +110850,14 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
         if (kind === "member")
           remappedMembers.set(record7.id, {
             ...moved,
-            ...stripClientDerivedBodies("member", record7)
+            createdAt: record7.createdAt,
+            updatedAt: record7.updatedAt
           });
         else
           remappedConstructors.set(record7.id, {
             ...moved,
-            ...stripConstructorDerivedBodies(record7)
+            createdAt: record7.createdAt,
+            updatedAt: record7.updatedAt
           });
       }
     }
@@ -114517,6 +114636,7 @@ var init_project_version_schema_commit = __esm({
   "../src/database/project-version-schema-commit.ts"() {
     "use strict";
     init_dialogue_logic_compile_pure();
+    init_neoscript_compiler_revision();
     init_neoscript_source_catalog();
     init_prepared_collection_bindings();
     init_stored_closure_captures();
@@ -148410,6 +148530,14 @@ function projectCompletions(analysis, document, position) {
       }))
     };
   }
+  const contextualEnum = projectContextualEnumCompletions(
+    analysis,
+    document,
+    position
+  );
+  if (contextualEnum) {
+    return { isIncomplete: false, items: contextualEnum };
+  }
   const constructorFields = projectConstructorArgumentCompletions(
     analysis,
     document,
@@ -148436,14 +148564,6 @@ function projectCompletions(analysis, document, position) {
   if (initializerMembers) {
     return { isIncomplete: false, items: initializerMembers };
   }
-  const contextualEnum = projectContextualEnumCompletions(
-    analysis,
-    document,
-    position
-  );
-  if (contextualEnum) {
-    return { isIncomplete: false, items: contextualEnum };
-  }
   return projectFallbackCompletions(analysis, document, position);
 }
 function projectListenerContext(analysis, document, position) {
@@ -149775,11 +149895,19 @@ function projectCallArguments(tokens, openIndex, delimiterEnds) {
       result.push({
         start: token.range.start,
         named: token.kind === "identifier" && tokens[index + 1]?.text === ":",
+        name: token.kind === "identifier" && tokens[index + 1]?.text === ":" ? token.text : null,
         ...token.kind === "identifier" && (tokens[index + 1]?.text === "," || tokens[index + 1]?.text === ")") ? { identifier: token.text } : {}
       });
       atArgumentStart = false;
     }
-    if (token.text === "(" || token.text === "[" || token.text === "{") {
+    if (token.text === "new" && tokens[index + 2]?.text === "<") {
+      let depth = 0;
+      index += 2;
+      for (; index < tokens.length; index++) {
+        if (tokens[index].text === "<") depth++;
+        else if (tokens[index].text === ">" && --depth === 0) break;
+      }
+    } else if (token.text === "(" || token.text === "[" || token.text === "{") {
       index = delimiterEnds.get(index) ?? tokens.length;
     }
   }
@@ -150387,6 +150515,7 @@ function indexConstructionSites(analysis, document, root) {
   while (end < allTokens.length && positionCompare(allTokens[end].range.start, root.range.end) <= 0)
     end++;
   const tokens = allTokens.slice(start, end).filter((token) => token.kind !== "comment" && token.kind !== "eof");
+  let delimiterEnds;
   const language = listenerSourceContext(analysis, document, root.range.start);
   const resolveSourceType = (type) => {
     if (!type) return null;
@@ -150427,15 +150556,17 @@ function indexConstructionSites(analysis, document, root) {
         const declaration = language.project.typeById.get(frame.typeRef.typeId);
         if (!declaration) return null;
         const constructors = declaration.declaredConstructors;
-        const parameters = constructors?.length === 1 ? constructors[0]?.parameters : declaration.constructorSignature?.parameters;
-        const parameter4 = frame.argumentName ? parameters?.find(
-          (candidate) => candidate.name === frame.argumentName
-        ) : parameters?.[frame.argumentIndex];
-        frame.expectedTypeRef = parameter4 ? substituteTypeParameters(
-          "type" in parameter4 ? parameter4.type : parameter4.valueType,
-          frame.typeRef,
-          declaration
-        ) : fieldType(frame.typeRef, frame.argumentName);
+        const parameters = constructors?.length ? constructors[frame.constructorIndex]?.parameters : declaration.constructorSignature?.parameters;
+        const parameter4 = frame.argumentName ? parameters && neoScriptParameterByName(parameters, frame.argumentName) : parameters?.[frame.argumentIndex];
+        if (parameter4) {
+          frame.expectedTypeRef = substituteTypeParameters(
+            "type" in parameter4 ? parameter4.type : parameter4.valueType,
+            frame.typeRef,
+            declaration
+          );
+        } else if (!constructors?.length) {
+          frame.expectedTypeRef = fieldType(frame.typeRef, frame.argumentName);
+        }
         return frame.expectedTypeRef;
       }
     }
@@ -150458,14 +150589,16 @@ function indexConstructionSites(analysis, document, root) {
   const objects = [];
   const snapshot = () => {
     const expected = expectedType();
+    const resolvedExpected = expectedTypeRef();
+    const expectedTypeName = resolvedExpected?.kind === "named" ? language.project.typeById.get(resolvedExpected.typeId)?.name ?? expected?.name : expected?.name;
     const innermost = stack.at(-1);
     const directly = innermost?.kind === "object" ? innermost : null;
     const keys = directly?.keys ?? [];
     const keyCount = keys.length;
     return {
       expectedType: expected,
-      expectedTypeRef: expectedTypeRef(),
-      expectedTypeName: expected?.name ?? null,
+      expectedTypeRef: resolvedExpected,
+      expectedTypeName: expectedTypeName ?? null,
       enclosingTypeName: objects.at(-1)?.typeName ?? null,
       initializerTypeName: directly?.typeName ?? null,
       get initializerKeys() {
@@ -150581,8 +150714,20 @@ function indexConstructionSites(analysis, document, root) {
     }
     if (token.text === "(") {
       if (sawNew) {
+        const declaration = pendingNewTypeName ? findTypeDeclaration(analysis, pendingNewTypeName) : null;
+        let constructorIndex = 0;
+        if (declaration?.kind === "class" && declaration.constructors.length > 1) {
+          const names = projectCallArguments(
+            tokens,
+            index,
+            delimiterEnds ??= projectDelimiterEnds(tokens)
+          ).map((argument2) => argument2.name);
+          const constructor2 = matchingDeclaredConstructor(declaration, names);
+          constructorIndex = constructor2 ? declaration.constructors.indexOf(constructor2) : -1;
+        }
         stack.push({
           kind: "call",
+          constructorIndex,
           typeName: pendingNewTypeName,
           typeRef: pendingNewTypeRef,
           argumentIndex: 0,
@@ -150669,6 +150814,14 @@ function constructorArgumentType(analysis, frame) {
   if (!declaration || declaration.kind === "global" || declaration.kind === "enum") {
     return null;
   }
+  if (declaration.kind === "class") {
+    const parameters = declaration.headerParameters ?? declaration.constructors[frame.constructorIndex]?.parameters;
+    if (parameters) {
+      const parameter4 = frame.argumentName === null ? parameters[frame.argumentIndex] : neoScriptParameterByName(parameters, frame.argumentName);
+      return parameter4?.type ?? null;
+    }
+    if (declaration.constructors.length > 0) return null;
+  }
   const fields = declarationFields(declaration);
   if (frame.argumentName !== null) {
     return fields.assignableByName.get(frame.argumentName)?.type ?? null;
@@ -150925,6 +151078,7 @@ var init_project_source_language_features = __esm({
     init_project_listener_annotations();
     init_strict_resolver();
     init_type_substitution();
+    init_declared_constructors();
     init_executable_parser();
     init_strict_compile_error();
     init_analyzer();
@@ -190289,7 +190443,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.72.1");
+    console.log("0.72.2");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/dist/test-worker.mjs

@@ -38520,6 +38520,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === callee.name
       );
       if (member) {
+        this.validateFunctionReceiver(receiver, callee.name, optional2, pos);
         if (type !== void 0) this.assertMemberAccessible(type, member, pos);
         if (member.static === true) {
           throw new CompileError(
@@ -39668,12 +39669,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   callableSignatureForReceiver(symbol, receiver) {
     let parameters = symbol.parameters ?? [];
     let returnType = symbol.returnType ?? symbol.type;
-    if (this.context.projectSourceKind !== "spec" && !(receiver?.kind === "instance" && receiver.dispatch === "base")) {
-      return { parameters, returnType };
-    }
     if (receiver?.kind !== "instance") return { parameters, returnType };
     const receiverType = receiver.expression.type;
     if (receiverType.kind !== "named") return { parameters, returnType };
+    if (!receiverType.typeArguments?.length) return { parameters, returnType };
     const declaring = this.project.typeById.get(receiverType.typeId);
     if (declaring === void 0) return { parameters, returnType };
     parameters = parameters.map((parameter3) => ({
@@ -40577,6 +40576,21 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       callSiteId: this.nextCallSite(expression.pos)
     };
   }
+  validateFunctionReceiver(receiver, name, optional2, pos) {
+    if (optional2 && !isNullable(receiver.type)) {
+      throw new CompileError(
+        `\`?.\` requires an optional receiver; got ${this.describe(receiver.type)}`,
+        pos
+      );
+    }
+    const receiverType = receiver.optionalChainType ?? receiver.type;
+    if (!optional2 && isNullable(receiverType)) {
+      throw new CompileError(
+        `Function '${name}' is called on ${this.describe(receiverType)}, which may be null. Use optional chaining, force-unwrapping, or a null check before calling it.`,
+        pos
+      );
+    }
+  }
   resolveFunctionStatement(expression, scope) {
     if (expression.kind !== "call") return null;
     const receiverValue = this.callReceiver(expression.callee, scope);
@@ -40740,12 +40754,19 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       }
     }
     const receiver = receiverValue();
-    if (receiver.type.kind !== "named") return null;
-    const type = this.project.typeById.get(receiver.type.typeId);
+    const memberReceiverType = neoScriptMemberLookupType(receiver.type);
+    if (memberReceiverType.kind !== "named") return null;
+    const type = this.project.typeById.get(memberReceiverType.typeId);
     const symbol = type?.members.find(
       (candidate) => (candidate.kind === "function" || candidate.kind === "method") && candidate.name === memberName
     );
     if (!symbol) return null;
+    this.validateFunctionReceiver(
+      receiver,
+      memberName,
+      expression.callee.optional === true,
+      expression.pos
+    );
     if (type !== void 0) {
       this.assertMemberAccessible(type, symbol, expression.pos);
     }
@@ -40758,7 +40779,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     this.validateCallableInContext(symbol, expression.pos);
     const resolved = this.resolveCallableArguments(
       symbol,
-      { kind: "instance", expression: receiver },
+      {
+        kind: "instance",
+        expression: memberReceiverType === receiver.type ? receiver : { ...receiver, type: memberReceiverType }
+      },
       expression.args,
       scope,
       expression.pos
@@ -54634,7 +54658,7 @@ var SPECIALIZED_RELATION_KINDS = /* @__PURE__ */ new Set([
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.72.1",
+  cliVersion: "0.72.2",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {

package/package.json

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

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

@@ -118,7 +118,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.72.1 -->
+<!-- reviewed-through-cli: 0.72.2 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -176,7 +176,13 @@ indexes only on the original List member. Overrides inherit its indexes, and
 List getter.
 
 Use `.EnumCase` only when context fixes one enum type; otherwise write
-`EnumType.Case`. Defaults and settings must be statically analyzable.
+`EnumType.Case`. Constructor parameters supply this context for positional
+and named arguments, including substituted generic parameter types. Defaults
+and settings must be statically analyzable.
+
+An explicit construction must be assignable to its receiving type. For example,
+`List<Base>` accepts `new Derived()` when `Derived` inherits `Base`, but rejects
+an unrelated class at `new`. Generic arguments must also be compatible.
 
 ## Member and relation rules
 

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

@@ -99,6 +99,10 @@ this.Items.Insert(0, item);
 this.Items.Remove(item);
 ```
 
+A generic receiver may call methods from its class or interface constraint,
+including void calls used as statements. Generic arguments substitute through
+the constraint; nullable receivers still require narrowing or null handling.
+
 Prefer `--json` for automation.
 
 `neo script check --all` reconstructs the prospective project entirely from

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

@@ -84,6 +84,9 @@ This names the initializer row. It does not create a stored global. The inline
 `Quest HardAsStone = @id("...") new Quest();` spelling is also accepted, and
 formatting moves its ID above the declaration. Do not put an ID in both places.
 
+A local initializer such as `Delivery DeliveryRow = new()` retains `Delivery`
+when consumed by a base-class member. Aliases retain that same concrete type.
+
 Nested class/list rows remain independently addressable and keep inline IDs:
 
 ```neo