@neocompose/cli 0.31.6 → 0.31.8

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.31.8] - 2026-08-17
+
+### Fixed
+
+- Propagate `?.` through following required member and index accesses in the
+  same expression chain, so a nullable parent safely short-circuits a deep
+  read while independently nullable descendants still require explicit null
+  handling.
+
+## [0.31.7] - 2026-08-15
+
+### Fixed
+
+- Preserve forwarded type arguments in constructed generic constraints such
+  as `TItem extends InventoryItem<TItemData>` through push, pull, stored-body
+  replay, validation, and C# generation.
+
 ## [0.31.6] - 2026-08-15
 
 ### Added

package/dist/neo.mjs

@@ -11838,13 +11838,15 @@ var init_strict_resolver = __esm({
             };
           }
         }
-        const receiver = this.resolveExpression(receiverAst, scope);
-        if (optional && !isNullable(receiver.type)) {
+        const resolvedReceiver = this.resolveExpression(receiverAst, scope);
+        if (optional && !isNullable(resolvedReceiver.type)) {
           throw new CompileError(
-            `\`?.\` requires an optional receiver; got ${this.describe(receiver.type)}`,
+            `\`?.\` requires an optional receiver; got ${this.describe(resolvedReceiver.type)}`,
             pos
           );
         }
+        const receiver = resolvedReceiver.optionalChainType ? { ...resolvedReceiver, type: resolvedReceiver.optionalChainType } : resolvedReceiver;
+        const nullPropagating = optional || resolvedReceiver.optionalChainType !== void 0;
         if (!optional && isNullable(receiver.type)) {
           throw new CompileError(
             `Member '${name}' is read on ${this.describe(receiver.type)}, which may be null. Handle null before reading through it \u2014 use \`!\` if it is always set, or \`?.\`, \`??\`, or a null check that narrows it.`,
@@ -11852,7 +11854,7 @@ var init_strict_resolver = __esm({
           );
         }
         if (receiver.staticType?.kind === "enum") {
-          if (optional) {
+          if (nullPropagating) {
             throw new CompileError(
               `\`?.\` is not valid on enum type '${receiver.staticType.name}'; enum option access is always defined`,
               pos
@@ -11924,9 +11926,10 @@ var init_strict_resolver = __esm({
                   pointer: receiver.pointer,
                   key: numberPointer(0)
                 },
-                ...optional ? { optional: true } : {}
+                ...nullPropagating ? { optional: true } : {}
               },
-              type: optional ? { ...primitiveMember.type, nullable: true } : primitiveMember.type,
+              type: nullPropagating ? { ...primitiveMember.type, nullable: true } : primitiveMember.type,
+              ...nullPropagating ? { optionalChainType: primitiveMember.type } : {},
               ...receiver.writability ? { writability: receiver.writability } : {}
             };
           }
@@ -11934,7 +11937,7 @@ var init_strict_resolver = __esm({
             receiver,
             primitiveMember.key ?? name,
             primitiveMember.type,
-            optional
+            nullPropagating
           );
           if (!primitiveMember.derived) return resolved;
           return {
@@ -11968,7 +11971,7 @@ var init_strict_resolver = __esm({
               receiver,
               name,
               { kind: "primitive", name: "string" },
-              optional
+              nullPropagating
             );
           }
           const member = type.members.find((candidate) => candidate.name === name);
@@ -12002,9 +12005,10 @@ var init_strict_resolver = __esm({
                 type: "callGetter" /* CallGetter */,
                 memberId: member.id,
                 receiver: { kind: "instance", pointer: receiver.pointer },
-                ...optional ? { optional: true } : {}
+                ...nullPropagating ? { optional: true } : {}
               },
-              type: optional ? { ...memberType2, nullable: true } : memberType2,
+              type: nullPropagating ? { ...memberType2, nullable: true } : memberType2,
+              ...nullPropagating ? { optionalChainType: memberType2 } : {},
               symbol: member,
               ...member.writable ? {
                 writability: member.writability ? toWritability(member.writability) : "setter" /* Setter */
@@ -12028,7 +12032,7 @@ var init_strict_resolver = __esm({
               receiver,
               member.schemaKey ?? member.name,
               memberType2,
-              optional,
+              nullPropagating,
               member.id
             ),
             symbol: member,
@@ -12136,14 +12140,23 @@ var init_strict_resolver = __esm({
             ...optional ? { optional: true } : {}
           },
           type: optional ? { ...type, nullable: true } : type,
+          ...optional ? { optionalChainType: type } : {},
           ...receiver.writability ? { writability: receiver.writability } : {}
         };
       }
       resolveIndex(receiverAst, indexAst, scope, pos, optional) {
-        const receiver = this.resolveExpression(receiverAst, scope);
-        if (optional && !isNullable(receiver.type)) {
+        const resolvedReceiver = this.resolveExpression(receiverAst, scope);
+        if (optional && !isNullable(resolvedReceiver.type)) {
           throw new CompileError(
-            `\`?.[]\` requires an optional receiver; got ${this.describe(receiver.type)}`,
+            `\`?.[]\` requires an optional receiver; got ${this.describe(resolvedReceiver.type)}`,
+            pos
+          );
+        }
+        const receiver = resolvedReceiver.optionalChainType ? { ...resolvedReceiver, type: resolvedReceiver.optionalChainType } : resolvedReceiver;
+        const nullPropagating = optional || resolvedReceiver.optionalChainType !== void 0;
+        if (!optional && isNullable(receiver.type)) {
+          throw new CompileError(
+            `Index access is read on ${this.describe(receiver.type)}, which may be null. Handle null before indexing it \u2014 use \`!\` if it is always set, or \`?.[]\`, \`??\`, or a null check that narrows it.`,
             pos
           );
         }
@@ -12185,9 +12198,10 @@ var init_strict_resolver = __esm({
               pointer: {
                 type: "keyOf" /* KeyOf */,
                 keyOf: { pointer: receiver.pointer, key: requested.pointer },
-                ...optional ? { optional: true } : {}
+                ...nullPropagating ? { optional: true } : {}
               },
-              type: optional ? { ...receiver.type.elementType, nullable: true } : receiver.type.elementType,
+              type: nullPropagating ? { ...receiver.type.elementType, nullable: true } : receiver.type.elementType,
+              ...nullPropagating ? { optionalChainType: receiver.type.elementType } : {},
               ...receiver.writability ? { writability: receiver.writability } : {}
             };
           }
@@ -12218,9 +12232,10 @@ var init_strict_resolver = __esm({
           pointer: {
             type: "keyOf" /* KeyOf */,
             keyOf: { pointer: receiver.pointer, key: index.pointer },
-            ...optional ? { optional: true } : {}
+            ...nullPropagating ? { optional: true } : {}
           },
-          type: optional ? { ...valueType, nullable: true } : valueType,
+          type: nullPropagating ? { ...valueType, nullable: true } : valueType,
+          ...nullPropagating ? { optionalChainType: valueType } : {},
           ...receiver.writability ? { writability: receiver.writability } : {}
         };
       }
@@ -17796,7 +17811,7 @@ var init_project_schema_contract_generated = __esm({
   "../packages/neoscript-language/src/project-schema-contract.generated.ts"() {
     "use strict";
     PROJECT_SCHEMA_MANIFEST_FORMAT_VERSION = 3;
-    PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "3.12";
+    PROJECT_SCHEMA_MANIFEST_CONTRACT_VERSION = "3.13";
     PROJECT_FILE_UPLOAD_BATCH_SIZE = 32;
     NEO_PROJECT_SOURCE_RECORD_CONTRACT = {
       "recordFields": {
@@ -30758,15 +30773,21 @@ function projectSchemaManifest(input, options = {}) {
     "ProjectSchemaManifest.interfaces"
   );
   const genericNames = /* @__PURE__ */ new Map();
+  const genericDeclarations = /* @__PURE__ */ new Map();
+  const genericOwnerClassIds = /* @__PURE__ */ new Map();
   for (const schemaClass2 of classes) {
+    const classId = string2(schemaClass2.id, "schemaClass.id");
     for (const parameter4 of records(
       schemaClass2.genericParameters ?? [],
       "schemaClass.genericParameters"
     )) {
+      const parameterId = string2(parameter4.id, "genericParameter.id");
       genericNames.set(
-        string2(parameter4.id, "genericParameter.id"),
+        parameterId,
         string2(parameter4.name, "genericParameter.name")
       );
+      genericDeclarations.set(parameterId, parameter4);
+      genericOwnerClassIds.set(parameterId, classId);
     }
   }
   const rootMemberIds2 = options.rootMemberIds ?? inferRootMemberIds(members);
@@ -30777,6 +30798,8 @@ function projectSchemaManifest(input, options = {}) {
     interfaces: interfaceById,
     enums: indexById(enums, "ProjectSchemaManifest.enums"),
     genericNames,
+    genericDeclarations,
+    genericOwnerClassIds,
     effectiveWritabilityByMemberId: effectiveMemberWritability(
       members,
       classes,
@@ -31150,7 +31173,7 @@ function schemaClass(value, environment, field) {
       return {
         id: parameterId,
         name,
-        type: { kind: "typeParameter", id: parameterId, name },
+        type: typeParameter(parameterId, environment, false),
         ...spanAndSelectionLocations(
           parameter4.source,
           parameter4.selectionSpan ?? parameter4.source,
@@ -32139,14 +32162,73 @@ function manifestPrimitive(kind) {
       return null;
   }
 }
-function typeParameter(id2, environment, nullable) {
+function typeParameter(id2, environment, nullable, visiting = /* @__PURE__ */ new Set()) {
+  const declaration = environment.genericDeclarations.get(id2);
+  const constraint = declaration?.constraint;
+  const next = new Set(visiting).add(id2);
   return {
     kind: "typeParameter",
     id: id2,
     name: environment.genericNames.get(id2) ?? id2,
+    ...environment.genericOwnerClassIds.has(id2) ? { ownerClassId: environment.genericOwnerClassIds.get(id2) } : {},
+    ...visiting.has(id2) || constraint === void 0 || constraint === null ? {} : {
+      constraint: genericConstraintType(
+        constraint,
+        environment,
+        next,
+        `generic parameter ${id2}.constraint`
+      )
+    },
     nullable
   };
 }
+function genericConstraintType(value, environment, visiting, field) {
+  const constraint = record2(value, field);
+  if (constraint.kind === "enum") {
+    return {
+      kind: "named",
+      typeId: string2(constraint.enumId, `${field}.enumId`),
+      nullable: false
+    };
+  }
+  if (constraint.kind !== "class") {
+    throw new Error(`${field}.kind must be "class" or "enum".`);
+  }
+  const classId = string2(constraint.classId, `${field}.classId`);
+  const target = environment.classes.get(classId);
+  const parameters = target ? records(target.genericParameters ?? [], `${field}.genericParameters`) : [];
+  const bindings = optionalRecord(constraint.classArguments) ?? {};
+  const typeArguments = parameters.flatMap((parameter4) => {
+    const parameterId = string2(parameter4.id, `${field}.genericParameter.id`);
+    const binding = optionalRecord(bindings[parameterId]);
+    if (binding?.kind === "generic" && typeof binding.genericParamId === "string") {
+      return [
+        typeParameter(binding.genericParamId, environment, false, visiting)
+      ];
+    }
+    if (binding?.kind === "member" && typeof binding.memberId === "string") {
+      const member = environment.members.get(binding.memberId);
+      return member ? [
+        {
+          ...memberType(
+            member,
+            environment,
+            /* @__PURE__ */ new Set(),
+            `${field}.classArguments.${parameterId}`
+          ),
+          nullable: false
+        }
+      ] : [];
+    }
+    return [];
+  });
+  return {
+    kind: "named",
+    typeId: classId,
+    nullable: false,
+    ...typeArguments.length === parameters.length && typeArguments.length > 0 ? { typeArguments } : {}
+  };
+}
 function primitive(name, nullable) {
   return { kind: "primitive", name, nullable };
 }
@@ -34673,6 +34755,16 @@ function inferMemberOwners(classes, members) {
       schemaClass2.recordId,
       set
     );
+    if (Array.isArray(schemaClass2.data.genericParams)) {
+      for (const parameterValue of schemaClass2.data.genericParams) {
+        if (!isRecord2(parameterValue)) continue;
+        const parameterId = parameterValue.id;
+        const constraint = parameterValue.constraint;
+        if (typeof parameterId !== "string" || !isRecord2(constraint)) continue;
+        if (constraint.kind !== "class") continue;
+        collectGenericOwners(constraint.classArguments, parameterId, set);
+      }
+    }
   }
   for (const [memberId, member] of members) {
     if (typeof member.entryMemberId === "string") {
@@ -38073,8 +38165,19 @@ function assertGenericParameter(value, path) {
   if (parameter4.constraint === null) return;
   const constraint = requireRecord(parameter4.constraint, `${path}.constraint`);
   if (constraint.kind === "class") {
-    knownKeys(constraint, `${path}.constraint`, ["kind", "classId"]);
+    knownKeysWithOptional(
+      constraint,
+      `${path}.constraint`,
+      ["kind", "classId"],
+      ["classArguments"]
+    );
     nonEmptyString(constraint.classId, `${path}.constraint.classId`);
+    if (constraint.classArguments !== void 0 && constraint.classArguments !== null) {
+      assertGenericBindingRecord(
+        constraint.classArguments,
+        `${path}.constraint.classArguments`
+      );
+    }
     return;
   }
   if (constraint.kind === "enum") {
@@ -41812,7 +41915,9 @@ function isGenericParamConstraint(value) {
   if (v.kind === "class") {
     if (typeof v.classId !== "string") return false;
     if (v.classId.length === 0) return false;
-    return v.enumId === void 0;
+    if (v.enumId !== void 0) return false;
+    const argumentsValue = v.classArguments;
+    return argumentsValue === void 0 || argumentsValue === null || isGenericBindingsRecord(argumentsValue);
   }
   if (v.kind === "enum") {
     if (typeof v.enumId !== "string") return false;
@@ -49582,11 +49687,7 @@ function emitClass(context, schemaClass2, memberIds) {
   const modifier = schemaClass2.isSealed ? "sealed " : schemaClass2.declarationModifier === "abstract" ? "abstract " : "";
   const generics = schemaClass2.genericParameters.length ? `<
 ${schemaClass2.genericParameters.map((parameter4) => {
-    const constraint = parameter4.constraint ? ` extends ${parameter4.constraint.kind === "class" ? required(
-      context.classes,
-      parameter4.constraint.classId,
-      "class"
-    ).name : required(context.enums, parameter4.constraint.enumId, "enum").name}` : "";
+    const constraint = parameter4.constraint ? ` extends ${renderGenericConstraint(context, parameter4.constraint)}` : "";
     return `  ${id(parameter4.id)}  ${parameter4.name}${constraint}`;
   }).join(",\n")}
 >` : "";
@@ -49660,6 +49761,31 @@ ${members.join("\n\n")}
 }
 `;
 }
+function renderGenericConstraint(context, constraint) {
+  if (constraint.kind === "enum") {
+    return required(context.enums, constraint.enumId, "enum").name;
+  }
+  const target = required(context.classes, constraint.classId, "class");
+  if (target.genericParameters.length === 0) return target.name;
+  const bindings = constraint.classArguments;
+  if (bindings === void 0 || bindings === null) return target.name;
+  const argumentsValue = target.genericParameters.map((parameter4) => {
+    const binding = bindings[parameter4.id];
+    if (binding === void 0) {
+      throw new Error(
+        `Generic constraint ${target.name} is missing its argument for ${parameter4.name}.`
+      );
+    }
+    if (binding.kind === "generic") {
+      return genericName(context, binding.genericParamId);
+    }
+    return renderMemberType(
+      context,
+      required(context.members, binding.memberId, "generic constraint binding")
+    ).replace(/\?$/u, "");
+  });
+  return `${target.name}<${argumentsValue.join(", ")}>`;
+}
 function baseConstruction(requiredConstructor) {
   if (requiredConstructor === void 0) return "";
   const args = requiredConstructor.baseArguments ?? [];
@@ -56139,7 +56265,15 @@ function lowerClass(context, declaration) {
     return {
       id: parameterId,
       name: parameter4.name,
-      constraint: parameter4.constraint ? genericConstraint(context, parameter4.constraint) : null,
+      constraint: parameter4.constraint ? genericConstraint(
+        context,
+        declaration,
+        parameterId,
+        parameter4.constraint,
+        base?.genericParameters.find(
+          (candidate) => candidate.id === parameterId
+        )?.constraint
+      ) : null,
       source: span(parameter4.identity),
       selectionSpan: span(parameter4.identity)
     };
@@ -58090,9 +58224,22 @@ function lowerGenericArgument(context, ownerClass, type, memberId, genericParamI
     )
   );
 }
-function genericConstraint(context, type) {
+function genericConstraint(context, ownerClass, parameterId, type, baseConstraint) {
   const classId = context.classIdsByName.get(type.name);
-  if (classId) return { kind: "class", classId };
+  if (classId) {
+    const classArguments2 = type.arguments.length === 0 ? void 0 : lowerClassArguments(
+      context,
+      ownerClass,
+      parameterId,
+      type,
+      baseConstraint?.kind === "class" ? baseConstraint.classArguments ?? void 0 : void 0
+    );
+    return {
+      kind: "class",
+      classId,
+      ...classArguments2 === void 0 ? {} : { classArguments: classArguments2 }
+    };
+  }
   return {
     kind: "enum",
     enumId: requiredName2(context.enumIdsByName, type.name, "enum")
@@ -58998,18 +59145,12 @@ function classToLanguageType(schemaClass2, context) {
       typeParameters: schemaClass2.genericParams.map((parameter4) => ({
         id: parameter4.id,
         name: parameter4.name,
-        type: {
-          kind: "typeParameter",
-          id: parameter4.id,
-          name: parameter4.name,
-          ownerClassId: schemaClass2.id,
-          ...parameter4.constraint === void 0 || parameter4.constraint === null ? {} : {
-            constraint: namedType(
-              parameter4.constraint.kind === "class" ? parameter4.constraint.classId : parameter4.constraint.enumId,
-              true
-            )
-          }
-        },
+        type: genericParameterLanguageType(
+          parameter4.id,
+          true,
+          context,
+          genericEnvironment
+        ),
         location: virtualIdentifierLocation(
           context,
           "Classes",
@@ -59659,31 +59800,12 @@ function memberRuntimeType(record3, context, seen = /* @__PURE__ */ new Set(), g
           );
         }
       }
-      for (const owner of context.vm.classes) {
-        const parameter4 = owner.genericParams?.find(
-          (candidate) => candidate.id === genericParamId
-        );
-        if (parameter4) {
-          if (parameter4.constraint?.kind === "class") {
-            return namedType(parameter4.constraint.classId, required2);
-          }
-          if (parameter4.constraint?.kind === "enum") {
-            return namedType(parameter4.constraint.enumId, required2);
-          }
-          return {
-            kind: "typeParameter",
-            id: genericParamId,
-            name: parameter4.name,
-            nullable: !required2
-          };
-        }
-      }
-      return {
-        kind: "typeParameter",
-        id: genericParamId,
-        name: genericParamId,
-        nullable: !required2
-      };
+      return genericParameterLanguageType(
+        genericParamId,
+        required2,
+        context,
+        genericEnvironment
+      );
     }
     case 27 /* Variant */: {
       if (!isMemberVariantBase(member)) return UNKNOWN_TYPE2;
@@ -59746,13 +59868,13 @@ function classArguments(member, context, seen, genericEnvironment) {
           )
         ] : [];
       }
-      const declaration = context.vm.classes.flatMap((schemaClass2) => schemaClass2.genericParams ?? []).find((candidate) => candidate.id === binding.genericParamId);
       return [
-        {
-          kind: "typeParameter",
-          id: binding.genericParamId,
-          name: declaration?.name ?? binding.genericParamId
-        }
+        genericParameterLanguageType(
+          binding.genericParamId,
+          true,
+          context,
+          genericEnvironment
+        )
       ];
     }
     const argument2 = analyzerMemberById(context.vm, binding.memberId);
@@ -59900,33 +60022,89 @@ function toLanguageType(type, context, genericEnvironment) {
           );
         }
       }
-      const effectiveParamId = environmentEntry?.kind === "unbound" ? environmentEntry.paramId : type.genericParamId;
-      const owner = context.vm.classes.find(
-        (item) => item.id === type.ownerClassId || item.genericParams?.some(
-          (parameter4) => parameter4.id === effectiveParamId
-        )
+      return genericParameterLanguageType(
+        environmentEntry?.kind === "unbound" ? environmentEntry.paramId : type.genericParamId,
+        required2,
+        context,
+        genericEnvironment
       );
-      const name = owner?.genericParams?.find(
-        (parameter4) => parameter4.id === effectiveParamId
-      )?.name ?? effectiveParamId;
-      const declaration = owner?.genericParams?.find(
-        (parameter4) => parameter4.id === effectiveParamId
+    }
+  }
+}
+function genericParameterLanguageType(genericParamId, required2, context, genericEnvironment, visiting = /* @__PURE__ */ new Set()) {
+  const environmentEntry = genericEnvironment?.get(genericParamId);
+  if (environmentEntry?.kind === "member") {
+    const binding = analyzerMemberById(context.vm, environmentEntry.memberId);
+    if (binding) {
+      return requiredType(
+        memberRuntimeType(binding, context, /* @__PURE__ */ new Set(), genericEnvironment)
       );
-      return {
-        kind: "typeParameter",
-        id: effectiveParamId,
-        name,
-        ...owner === void 0 ? {} : { ownerClassId: owner.id },
-        ...declaration?.constraint === void 0 || declaration.constraint === null ? {} : {
-          constraint: namedType(
-            declaration.constraint.kind === "class" ? declaration.constraint.classId : declaration.constraint.enumId,
-            true
-          )
-        },
-        nullable: !required2
-      };
     }
   }
+  const effectiveParamId = environmentEntry?.kind === "unbound" ? environmentEntry.paramId : genericParamId;
+  const owner = context.vm.classes.find(
+    (schemaClass2) => schemaClass2.genericParams?.some(
+      (parameter4) => parameter4.id === effectiveParamId
+    )
+  );
+  const declaration = owner?.genericParams?.find(
+    (parameter4) => parameter4.id === effectiveParamId
+  );
+  const next = new Set(visiting).add(effectiveParamId);
+  return {
+    kind: "typeParameter",
+    id: effectiveParamId,
+    name: declaration?.name ?? effectiveParamId,
+    ...owner === void 0 ? {} : { ownerClassId: owner.id },
+    ...visiting.has(effectiveParamId) || declaration?.constraint == null ? {} : {
+      constraint: genericConstraintLanguageType(
+        declaration.constraint,
+        context,
+        genericEnvironment,
+        next
+      )
+    },
+    nullable: !required2
+  };
+}
+function genericConstraintLanguageType(constraint, context, genericEnvironment, visiting = /* @__PURE__ */ new Set()) {
+  if (constraint.kind === "enum") {
+    return namedType(constraint.enumId, true);
+  }
+  const target = context.vm.classes.find(
+    (schemaClass2) => schemaClass2.id === constraint.classId
+  );
+  const bindings = constraint.classArguments;
+  if (!target?.genericParams?.length || bindings == null) {
+    return namedType(constraint.classId, true);
+  }
+  const typeArguments = target.genericParams.flatMap((parameter4) => {
+    const binding = bindings[parameter4.id];
+    if (binding === void 0) return [];
+    if (binding.kind === "generic") {
+      return [
+        genericParameterLanguageType(
+          binding.genericParamId,
+          true,
+          context,
+          genericEnvironment,
+          visiting
+        )
+      ];
+    }
+    const member = analyzerMemberById(context.vm, binding.memberId);
+    return member ? [
+      requiredType(
+        memberRuntimeType(member, context, /* @__PURE__ */ new Set(), genericEnvironment)
+      )
+    ] : [];
+  });
+  return {
+    kind: "named",
+    typeId: constraint.classId,
+    nullable: false,
+    ...typeArguments.length === target.genericParams.length ? { typeArguments } : {}
+  };
 }
 function functionReturnType(type, context, genericEnvironment) {
   return type.type === NS_TYPE_VOID ? primitive2("void", true) : toLanguageType(type, context, genericEnvironment);
@@ -60094,12 +60272,68 @@ function virtualNeoSchemaClassHeader(schemaClass2, context) {
     )?.name ?? constraint.classId : context.vm.enums.find(
       (candidate) => candidate.id === constraint.enumId
     )?.name ?? constraint.enumId;
+    const targetClass = constraint.kind === "class" ? context.vm.classes.find(
+      (candidate) => candidate.id === constraint.classId
+    ) : void 0;
+    const bindings = constraint.kind === "class" ? constraint.classArguments : void 0;
+    const argumentsValue = targetClass?.genericParams?.flatMap(
+      (targetParameter) => {
+        const binding = bindings?.[targetParameter.id];
+        if (binding?.kind === "generic") {
+          const declaration = context.vm.classes.flatMap((candidate) => candidate.genericParams ?? []).find((candidate) => candidate.id === binding.genericParamId);
+          return [
+            virtualCSharpIdentifier(
+              declaration?.name ?? binding.genericParamId
+            )
+          ];
+        }
+        if (binding?.kind === "member") {
+          const member = analyzerMemberById(context.vm, binding.memberId);
+          return [
+            member ? virtualConstraintMemberType(member, context) : "object"
+          ];
+        }
+        return [];
+      }
+    );
+    const argumentSuffix = targetClass?.genericParams?.length && argumentsValue?.length === targetClass.genericParams.length ? `<${argumentsValue.join(", ")}>` : "";
     return [
-      ` where ${virtualCSharpIdentifier(parameter4.name)} : ${virtualCSharpIdentifier(target)}`
+      ` where ${virtualCSharpIdentifier(parameter4.name)} : ${virtualCSharpIdentifier(target)}${argumentSuffix}`
     ];
   });
   return `public ${schemaClass2.isAbstract ? "abstract " : ""}partial class ${virtualCSharpIdentifier(schemaClass2.name)}${genericParameters}${inheritance}${constraints.join("")} // Neo class ${schemaClass2.id}`;
 }
+function virtualConstraintMemberType(member, context) {
+  const resolved = resolveMember2(member, context.vm.members);
+  switch (resolved.kind) {
+    case 1 /* Bool */:
+      return "bool";
+    case 2 /* Int */:
+      return "int";
+    case 3 /* String */:
+      return "string";
+    case 4 /* Float */:
+      return "double";
+    case 20 /* Decimal */:
+      return "decimal";
+    case 7 /* Class */: {
+      const classId = getOptionalString(resolved, "classId");
+      const schemaClass2 = context.vm.classes.find(
+        (candidate) => candidate.id === classId
+      );
+      return virtualCSharpIdentifier(schemaClass2?.name ?? classId ?? "object");
+    }
+    case 8 /* Enum */: {
+      const enumId = getOptionalString(resolved, "enumId");
+      const neoEnum = context.vm.enums.find(
+        (candidate) => candidate.id === enumId
+      );
+      return virtualCSharpIdentifier(neoEnum?.name ?? enumId ?? "object");
+    }
+    default:
+      return "object";
+  }
+}
 function virtualNeoSchemaClassMemberLine(schemaKey, displayName, memberId) {
   return `    public object? ${virtualCSharpIdentifier(schemaKey)} { get; init; } // ${displayName}; Neo member ${memberId}`;
 }
@@ -60135,7 +60369,7 @@ var init_neoscript_language_context_adapter = __esm({
     init_project_root_members();
     init_project_file_registry();
     init_analyzer_types();
-    NEOSCRIPT_COMPILER_ADAPTER_REVISION = 1;
+    NEOSCRIPT_COMPILER_ADAPTER_REVISION = 2;
     UNKNOWN_TYPE2 = {
       kind: "primitive",
       name: "unknown"
@@ -82237,10 +82471,13 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
       `Class "${schemaClass2.name}" (${schemaClass2.id}) cannot extend sealed class "${baseClass.name}" (${baseClass.id}).`
     );
   }
-  const genericParamConstraintsById = new Map(
+  const genericParamDeclarationsById = new Map(
     classes.flatMap(
       (schemaClass2) => (schemaClass2.genericParams ?? []).map(
-        (param) => [param.id, param.constraint]
+        (param) => [
+          param.id,
+          { constraint: param.constraint, ownerClassId: schemaClass2.id }
+        ]
       )
     )
   );
@@ -83155,13 +83392,40 @@ function assertProjectInterfaceDocumentValid(view, options = {}) {
     if (!isRecord7(typeInfo) || typeInfo.type !== 21 || typeof typeInfo.genericParamId !== "string") {
       return null;
     }
-    const constraint = genericParamConstraintsById.get(typeInfo.genericParamId);
+    const constraint = genericParamDeclarationsById.get(
+      typeInfo.genericParamId
+    )?.constraint;
     if (!constraint) return null;
-    return constraint.kind === "class" ? {
-      type: 7,
-      required: typeInfo.required === true,
-      classId: constraint.classId
-    } : {
+    if (constraint.kind === "class") {
+      const typeArguments = Object.fromEntries(
+        Object.entries(constraint.classArguments ?? {}).flatMap(
+          ([parameterId, binding]) => {
+            if (binding.kind !== "generic") return [];
+            const ownerClassId = genericParamDeclarationsById.get(
+              binding.genericParamId
+            )?.ownerClassId;
+            return ownerClassId === void 0 ? [] : [
+              [
+                parameterId,
+                {
+                  type: 21,
+                  required: true,
+                  ownerClassId,
+                  genericParamId: binding.genericParamId
+                }
+              ]
+            ];
+          }
+        )
+      );
+      return {
+        type: 7,
+        required: typeInfo.required === true,
+        classId: constraint.classId,
+        ...Object.keys(typeArguments).length > 0 ? { typeArguments } : {}
+      };
+    }
+    return {
       type: 8,
       required: typeInfo.required === true,
       enumId: constraint.enumId
@@ -111011,8 +111275,8 @@ var init_registry2 = __esm({
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
-      contractVersion: "3.12",
-      cliVersion: "0.31.6",
+      contractVersion: "3.13",
+      cliVersion: "0.31.8",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -117607,7 +117871,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.31.6");
+    console.log("0.31.8");
     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.31.6",
+  "version": "0.31.8",
   "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.31.6 -->
+<!-- reviewed-through-cli: 0.31.8 -->
 
 # 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.31.6 -->
+<!-- reviewed-through-cli: 0.31.8 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -287,3 +287,16 @@ class Child(string name) : Base {
 Bind generic base arguments explicitly when needed. Reject a subclass that
 omits required base arguments or leaves any inherited required member
 unsettled.
+
+Generic constraints may construct another generic from a parameter in the
+same declaration. This preserves the relationship between the parameters in
+source checks, stored initializer replay, and generated C#:
+
+```neo
+class PlacedItem<
+  TData extends InventoryStackData,
+  TItem extends InventoryItem<TData>
+>(TItem item) {
+  public TData Data = item.DefaultData.Clone();
+}
+```

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

@@ -49,6 +49,11 @@ if (player.Target != null) {
 return player.Target?.Name ?? "Unknown";
 ```
 
+Null propagation remains active across following required accesses in the same
+chain, so `config.Hat?.Head.Idle.Down.Frames` safely returns null when `Hat` is
+null. A descendant that is itself nullable still needs its own `?.`, `??`, `!`,
+or narrowing guard before the next access.
+
 Treat lookup-return values with the same nullable narrowing rules.
 
 Let runtime ownership—not body kind—decide whether a write target is Immutable,