@doenet/v06-to-v07 0.7.3 → 0.7.4

package/index.js

@@ -44293,12 +44293,14 @@ class DependencyHandler {
       parentDependenciesByParent: {},
       dependenciesMissingComponentBySpecifiedName: {},
       dependenciesBasedOnDependenciesOfStateVariables: {},
-      primaryShadowDependencies: {}
+      primaryShadowDependencies: {},
+      componentsReferencingAttributeByReferenced: {}
     };
     this.resolveBlockers = {
       neededToResolve: {},
       resolveBlockedBy: {}
     };
+    this.attributeRefResolutionDependenciesByReferenced = {};
   }
   async setUpComponentDependencies(component) {
     if (this.downstreamDependencies[component.componentIdx]) {
@@ -49350,6 +49352,8 @@ class RefResolutionDependency extends Dependency {
     if (!refComponent) {
       this.addUpdateTriggerForMissingComponent(nodeIdx);
       this.missingComponentBlockers.push(nodeIdx);
+      this.extendIdx = -1;
+      this.unresolvedPath = this.originalPath;
       return {
         success: true,
         downstreamComponentIndices: [],
@@ -49591,7 +49595,7 @@ class RefResolutionDependency extends Dependency {
   async getValue() {
     const result2 = await super.getValue();
     result2.value = {
-      extendIdx: this.extendIdx,
+      extendIdx: this.extendIdx ?? -1,
       unresolvedPath: this.unresolvedPath,
       originalPath: this.originalPath
     };
@@ -49623,6 +49627,7 @@ class AttributeRefResolutions extends Dependency {
       "originalPath"
     ];
     this.missingComponentBlockers = [];
+    this.extendIndicesResolved = [];
   }
   async determineDownstreamComponents() {
     let parent = this.dependencyHandler._components[this.parentIdx];
@@ -49658,11 +49663,50 @@ class AttributeRefResolutions extends Dependency {
   }
   async getValue() {
     const result2 = await super.getValue();
-    result2.value = result2.value.map((comp) => ({
-      componentIdx: comp.stateValues.extendIdx,
-      unresolvedPath: comp.stateValues.unresolvedPath,
-      originalPath: comp.stateValues.originalPath
-    }));
+    const newValue = [];
+    for (const comp of result2.value) {
+      const extendIdx = comp.stateValues.extendIdx;
+      newValue.push({
+        componentIdx: extendIdx,
+        unresolvedPath: comp.stateValues.unresolvedPath,
+        originalPath: comp.stateValues.originalPath
+      });
+      if (extendIdx !== -1) {
+        if (!this.extendIndicesResolved.includes(extendIdx)) {
+          this.extendIndicesResolved.push(extendIdx);
+          let attributeRefResolutionDeps = this.dependencyHandler.attributeRefResolutionDependenciesByReferenced[extendIdx];
+          if (!attributeRefResolutionDeps) {
+            attributeRefResolutionDeps = this.dependencyHandler.attributeRefResolutionDependenciesByReferenced[extendIdx] = [];
+          }
+          attributeRefResolutionDeps.push({
+            dependency: this,
+            composite: comp
+          });
+        }
+        if (this.dependencyHandler.updateTriggers.componentsReferencingAttributeByReferenced[extendIdx]) {
+          for (let dep of this.dependencyHandler.updateTriggers.componentsReferencingAttributeByReferenced[extendIdx]) {
+            for (let varName of dep.upstreamVariableNames) {
+              await this.dependencyHandler.addBlocker({
+                blockerComponentIdx: dep.upstreamComponentIdx,
+                blockerType: "recalculateDownstreamComponents",
+                blockerStateVariable: varName,
+                blockerDependency: dep.dependencyName,
+                componentIdxBlocked: dep.upstreamComponentIdx,
+                typeBlocked: "stateVariable",
+                stateVariableBlocked: varName
+              });
+            }
+            await this.dependencyHandler.addBlockersFromChangedStateVariableDependencies(
+              {
+                componentIdx: dep.upstreamComponentIdx,
+                stateVariables: dep.upstreamVariableNames
+              }
+            );
+          }
+        }
+      }
+    }
+    result2.value = newValue;
     result2.usedDefault = !this.foundAttribute;
     return result2;
   }
@@ -49670,9 +49714,89 @@ class AttributeRefResolutions extends Dependency {
     for (const componentIdx of this.missingComponentBlockers) {
       this.deleteUpdateTriggerForMissingComponent(componentIdx);
     }
+    for (const extendIdx of this.extendIndicesResolved) {
+      let attributeRefResolutionDeps = this.dependencyHandler.attributeRefResolutionDependenciesByReferenced[extendIdx];
+      if (attributeRefResolutionDeps) {
+        let ind = attributeRefResolutionDeps.findIndex(
+          (entry) => entry.dependency === this
+        );
+        if (ind !== -1) {
+          attributeRefResolutionDeps.splice(ind, 1);
+        }
+      }
+    }
   }
 }
 dependencyTypeArray.push(AttributeRefResolutions);
+class ComponentsReferencingAttributeDependency extends Dependency {
+  static dependencyType = "componentsReferencingAttribute";
+  setUpParameters() {
+    if (this.definition.referencedIdx != void 0) {
+      this.referencedIdx = this.definition.referencedIdx;
+      this.specifiedComponentName = this.referencedIdx;
+    } else {
+      this.referencedIdx = this.upstreamComponentIdx;
+    }
+    this.attributeName = this.definition.attributeName;
+    this.allowUnresolvedPath = this.definition.allowUnresolvedPath || false;
+    this.missingComponentBlockers = [];
+  }
+  async determineDownstreamComponents() {
+    let referencedComponent = this.dependencyHandler._components[this.referencedIdx];
+    if (!referencedComponent) {
+      this.addBlockerUpdateTriggerForMissingComponent(this.referencedIdx);
+      this.missingComponentBlockers.push(this.referencedIdx);
+      return {
+        success: false,
+        downstreamComponentIndices: [],
+        downstreamComponentTypes: []
+      };
+    }
+    if (!this.dependencyHandler.updateTriggers.componentsReferencingAttributeByReferenced[this.referencedIdx]) {
+      this.dependencyHandler.updateTriggers.componentsReferencingAttributeByReferenced[this.referencedIdx] = [];
+    }
+    this.dependencyHandler.updateTriggers.componentsReferencingAttributeByReferenced[this.referencedIdx].push(this);
+    let attributeRefResolutionDeps = this.dependencyHandler.attributeRefResolutionDependenciesByReferenced[this.referencedIdx];
+    if (attributeRefResolutionDeps) {
+      if (!this.allowUnresolvedPath) {
+        attributeRefResolutionDeps = attributeRefResolutionDeps.filter(
+          (entry) => entry.composite.stateValues.unresolvedPath === null
+        );
+      }
+      if (this.attributeName) {
+        attributeRefResolutionDeps = attributeRefResolutionDeps.filter(
+          (entry) => entry.dependency.attributeName === this.attributeName
+        );
+      }
+      const downstreamComponentIndices = [];
+      const downstreamComponentTypes = [];
+      for (const entry of attributeRefResolutionDeps) {
+        const parentIdx = entry.dependency.parentIdx;
+        const parent = this.dependencyHandler._components[parentIdx];
+        if (parent) {
+          downstreamComponentIndices.push(parentIdx);
+          downstreamComponentTypes.push(parent.componentType);
+        }
+      }
+      return {
+        success: true,
+        downstreamComponentIndices,
+        downstreamComponentTypes
+      };
+    }
+    return {
+      success: false,
+      downstreamComponentIndices: [],
+      downstreamComponentTypes: []
+    };
+  }
+  deleteFromUpdateTriggers() {
+    for (const componentIdx of this.missingComponentBlockers) {
+      this.deleteUpdateTriggerForMissingComponent(componentIdx);
+    }
+  }
+}
+dependencyTypeArray.push(ComponentsReferencingAttributeDependency);
 class StringsFromReferenceAttribute extends Dependency {
   static dependencyType = "stringsFromReferenceAttribute";
   setUpParameters() {
@@ -52477,7 +52601,7 @@ class Core {
       this.visibilityInfo.saveDelay
     );
   }
-  async callUpdateRenderers(args, init = false) {
+  callUpdateRenderers(args, init = false) {
     let errorWarnings = void 0;
     if (this.newErrorWarning) {
       errorWarnings = this.getErrorWarnings().errorWarnings;
@@ -52587,16 +52711,6 @@ class Core {
       let results = await this.initializeRenderedComponentInstruction(
         this.document
       );
-      if (this.updateInfo.compositesToUpdateReplacements.size > 0) {
-        await this.replacementChangesFromCompositesToUpdate();
-        let componentNamesToUpdate = [
-          ...this.updateInfo.componentsToUpdateRenderers
-        ];
-        this.updateInfo.componentsToUpdateRenderers.clear();
-        await this.updateRendererInstructions({
-          componentNamesToUpdate
-        });
-      }
       this.documentRendererInstructions = results.componentToRender;
       let updateInstructions = [
         {
@@ -52614,6 +52728,16 @@ class Core {
         ];
         this.callUpdateRenderers({ updateInstructions: updateInstructions2 });
       }
+      if (this.updateInfo.compositesToUpdateReplacements.size > 0) {
+        await this.replacementChangesFromCompositesToUpdate();
+        let componentNamesToUpdate = [
+          ...this.updateInfo.componentsToUpdateRenderers
+        ];
+        this.updateInfo.componentsToUpdateRenderers.clear();
+        await this.updateRendererInstructions({
+          componentNamesToUpdate
+        });
+      }
       await this.processStateVariableTriggers(true);
     } else {
       if (parent === void 0) {
@@ -62375,6 +62499,12 @@ class BaseComponent {
         defaultValue: false,
         public: true
       },
+      isPotentialResponse: {
+        createPrimitiveOfType: "boolean",
+        createStateVariable: "isPotentialResponse",
+        defaultValue: false,
+        excludeFromSchema: true
+      },
       permid: {
         createPrimitiveOfType: "string",
         createStateVariable: "permid",
@@ -64172,14 +64302,14 @@ function gatherRawRoundingFixedResponseAttributes(component, components) {
     }
     if (componentForRawAttributes.doenetAttributes.extendListViaComposite) {
       const composite = components[componentForRawAttributes.doenetAttributes.extendListViaComposite];
-      if (typeof composite.stateValues.extendIdx === "number") {
+      if (typeof composite.stateValues.extendIdx === "number" && composite.stateValues.extendIdx !== -1) {
         componentForRawAttributes = components[composite.stateValues.extendIdx];
       } else {
         break;
       }
     } else if (componentForRawAttributes.doenetAttributes.copyListViaComposite) {
       const composite = components[componentForRawAttributes.doenetAttributes.copyListViaComposite];
-      if (typeof composite.stateValues.extendIdx === "number") {
+      if (typeof composite.stateValues.extendIdx === "number" && composite.stateValues.extendIdx !== -1) {
         componentForRawAttributes = components[composite.stateValues.extendIdx];
       } else {
         break;
@@ -67357,7 +67487,7 @@ function returnUnorderedListStateVariableDefinitions() {
       }
     },
     definition({ dependencyValues }) {
-      if (dependencyValues.extendListSourceIdx) {
+      if (typeof dependencyValues.extendListSourceIdx === "number" && dependencyValues.extendListSourceIdx !== -1) {
         return {
           setValue: {
             extendListSourceIdx: dependencyValues.extendListSourceIdx
@@ -67449,7 +67579,7 @@ function returnUnorderedListStateVariableDefinitions() {
           variableName: "unorderedFromCopyListSource"
         }
       };
-      if (stateValues.extendListSourceIdx) {
+      if (stateValues.extendListSourceIdx !== null) {
         dependencies2.unorderedFromExtended = {
           dependencyType: "stateVariable",
           componentIdx: stateValues.extendListSourceIdx,
@@ -67520,6 +67650,10 @@ class MathList extends CompositeComponent {
     attributes.isResponse = {
       leaveRaw: true
     };
+    attributes.isPotentialResponse = {
+      leaveRaw: true,
+      excludeFromSchema: true
+    };
     attributes.asList = {
       createPrimitiveOfType: "boolean",
       createStateVariable: "asList",
@@ -67949,11 +68083,13 @@ class MathList extends CompositeComponent {
     const copyChild = component.definingChildren.length === 1 && component.definingChildren[0].componentType === "_copy" ? component.definingChildren[0] : null;
     let copyChildSource;
     if (copyChild) {
-      const cIdx = await copyChild?.stateValues.extendIdx;
-      copyChildSource = {
-        componentIdx: cIdx,
-        componentType: components[cIdx].componentType
-      };
+      const cIdx = await copyChild.stateValues.extendIdx;
+      if (cIdx !== -1) {
+        copyChildSource = {
+          componentIdx: cIdx,
+          componentType: components[cIdx].componentType
+        };
+      }
     }
     let childInfoByComponent = await component.stateValues.childInfoByComponent;
     let numComponents = await component.stateValues.numComponents;
@@ -68100,7 +68236,17 @@ function returnScoredSectionAttributes() {
     showCorrectness: {
       createComponentOfType: "boolean",
       createStateVariable: "showCorrectnessPreliminary",
-      defaultValue: null
+      defaultValue: false
+    },
+    colorCorrectness: {
+      createComponentOfType: "boolean",
+      createStateVariable: "colorCorrectnessPreliminary",
+      defaultValue: false
+    },
+    forceIndividualAnswerColoring: {
+      createComponentOfType: "boolean",
+      createStateVariable: "forceIndividualAnswerColoring",
+      defaultValue: false
     },
     submitLabel: {
       createComponentOfType: "text",
@@ -68211,18 +68357,52 @@ function returnScoredSectionStateVariableDefinition() {
       showCorrectnessFlag: {
         dependencyType: "flag",
         flagName: "showCorrectness"
+      },
+      showCorrectnessAncestor: {
+        dependencyType: "ancestor",
+        variableNames: ["showCorrectness"]
       }
     }),
     definition({ dependencyValues, usedDefault }) {
       let showCorrectness;
       if (!usedDefault.showCorrectnessPreliminary) {
         showCorrectness = dependencyValues.showCorrectnessPreliminary;
+      } else if (dependencyValues.showCorrectnessAncestor) {
+        showCorrectness = dependencyValues.showCorrectnessAncestor.stateValues.showCorrectness;
       } else {
         showCorrectness = dependencyValues.showCorrectnessFlag !== false;
       }
       return { setValue: { showCorrectness } };
     }
   };
+  stateVariableDefinitions.colorCorrectness = {
+    forRenderer: true,
+    returnDependencies: () => ({
+      colorCorrectnessPreliminary: {
+        dependencyType: "stateVariable",
+        variableName: "colorCorrectnessPreliminary"
+      },
+      showCorrectness: {
+        dependencyType: "stateVariable",
+        variableName: "showCorrectness"
+      },
+      colorCorrectnessAncestor: {
+        dependencyType: "ancestor",
+        variableNames: ["colorCorrectness"]
+      }
+    }),
+    definition({ dependencyValues, usedDefault }) {
+      let colorCorrectness = true;
+      if (!dependencyValues.showCorrectness) {
+        colorCorrectness = false;
+      } else if (!usedDefault.colorCorrectnessPreliminary) {
+        colorCorrectness = dependencyValues.colorCorrectnessPreliminary;
+      } else if (dependencyValues.colorCorrectnessAncestor) {
+        colorCorrectness = dependencyValues.colorCorrectnessAncestor.stateValues.colorCorrectness;
+      }
+      return { setValue: { colorCorrectness } };
+    }
+  };
   stateVariableDefinitions.displayDecimalsForCreditAchieved = {
     returnDependencies: () => ({}),
     definition: () => ({
@@ -68405,63 +68585,46 @@ function returnScoredSectionStateVariableDefinition() {
   stateVariableDefinitions.createSubmitAllButton = {
     forRenderer: true,
     additionalStateVariablesDefined: [
-      {
-        variableName: "suppressAnswerSubmitButtons",
-        forRenderer: true
-      }
+      "suppressAnswerSubmitButtons",
+      "descendantColorCorrectnessBasedOnIdx"
     ],
     returnDependencies: () => ({
       sectionWideCheckWork: {
         dependencyType: "stateVariable",
         variableName: "sectionWideCheckWork"
       },
-      sectionAncestor: {
-        dependencyType: "ancestor",
-        componentType: "_sectioningComponent",
-        variableNames: ["suppressAnswerSubmitButtons"]
-      },
-      documentAncestor: {
-        dependencyType: "ancestor",
-        componentType: "document",
-        variableNames: ["suppressAnswerSubmitButtons"]
-      },
-      pAncestor: {
-        dependencyType: "ancestor",
-        componentType: "p",
-        variableNames: ["suppressAnswerSubmitButtons"]
-      },
-      liAncestor: {
-        dependencyType: "ancestor",
-        componentType: "li",
-        variableNames: ["suppressAnswerSubmitButtons"]
-      },
-      divAncestor: {
-        dependencyType: "ancestor",
-        componentType: "div",
-        variableNames: ["suppressAnswerSubmitButtons"]
+      forceIndividualAnswerColoring: {
+        dependencyType: "stateVariable",
+        variableName: "forceIndividualAnswerColoring"
       },
-      spanAncestor: {
+      ancestorDeterminingSubmit: {
         dependencyType: "ancestor",
-        componentType: "span",
-        variableNames: ["suppressAnswerSubmitButtons"]
+        variableNames: [
+          "suppressAnswerSubmitButtons",
+          "descendantColorCorrectnessBasedOnIdx"
+        ]
       }
     }),
-    definition({ dependencyValues }) {
-      let warnings = [];
+    definition({ dependencyValues, componentIdx }) {
       let createSubmitAllButton = false;
       let suppressAnswerSubmitButtons = false;
-      if (dependencyValues.documentAncestor.stateValues.suppressAnswerSubmitButtons || dependencyValues.sectionAncestor?.stateValues.suppressAnswerSubmitButtons || dependencyValues.pAncestor?.stateValues.suppressAnswerSubmitButtons || dependencyValues.liAncestor?.stateValues.suppressAnswerSubmitButtons || dependencyValues.divAncestor?.stateValues.suppressAnswerSubmitButtons || dependencyValues.spanAncestor?.stateValues.suppressAnswerSubmitButtons) {
+      let descendantColorCorrectnessBasedOnIdx = null;
+      if (dependencyValues.ancestorDeterminingSubmit?.stateValues.suppressAnswerSubmitButtons) {
         suppressAnswerSubmitButtons = true;
+        descendantColorCorrectnessBasedOnIdx = dependencyValues.ancestorDeterminingSubmit.stateValues.descendantColorCorrectnessBasedOnIdx;
       } else if (dependencyValues.sectionWideCheckWork) {
         createSubmitAllButton = true;
         suppressAnswerSubmitButtons = true;
+        if (!dependencyValues.forceIndividualAnswerColoring) {
+          descendantColorCorrectnessBasedOnIdx = componentIdx;
+        }
       }
       return {
         setValue: {
           createSubmitAllButton,
-          suppressAnswerSubmitButtons
-        },
-        sendWarnings: warnings
+          suppressAnswerSubmitButtons,
+          descendantColorCorrectnessBasedOnIdx
+        }
       };
     }
   };
@@ -101831,6 +101994,9 @@ class Input extends InlineComponent {
       public: true,
       excludeFromSchema: true
     };
+    attributes.forAnswer = {
+      createReferences: true
+    };
     Object.assign(attributes, returnLabelAttributes());
     return attributes;
   }
@@ -101842,6 +102008,102 @@ class Input extends InlineComponent {
       returnDependencies: () => ({}),
       definition: () => ({ setValue: { numValues: 1 } })
     };
+    stateVariableDefinitions.answerOverrideIdx = {
+      returnDependencies: () => ({
+        ancestorForOverride: {
+          dependencyType: "ancestor",
+          variableNames: ["descendantColorCorrectnessBasedOnIdx"]
+        }
+      }),
+      definition({ dependencyValues }) {
+        let answerOverrideIdx = null;
+        if (typeof dependencyValues.ancestorForOverride?.stateValues.descendantColorCorrectnessBasedOnIdx === "number") {
+          answerOverrideIdx = dependencyValues.ancestorForOverride.stateValues.descendantColorCorrectnessBasedOnIdx;
+        }
+        return {
+          setValue: { answerOverrideIdx }
+        };
+      }
+    };
+    stateVariableDefinitions.answerOverride = {
+      stateVariablesDeterminingDependencies: ["answerOverrideIdx"],
+      returnDependencies({ stateValues }) {
+        let dependencies2 = {};
+        if (stateValues.answerOverrideIdx !== null) {
+          dependencies2.answerOverride = {
+            dependencyType: "multipleStateVariables",
+            componentIdx: stateValues.answerOverrideIdx,
+            variableNames: [
+              "justSubmitted",
+              "creditAchieved",
+              "showCorrectness",
+              "colorCorrectness"
+            ],
+            variablesOptional: true
+          };
+        }
+        return dependencies2;
+      },
+      definition({ dependencyValues }) {
+        let answerOverride = null;
+        if (dependencyValues.answerOverride) {
+          answerOverride = dependencyValues.answerOverride;
+        }
+        return { setValue: { answerOverride } };
+      }
+    };
+    stateVariableDefinitions.answerDelegateIdx = {
+      returnDependencies: () => ({
+        forAnswer: {
+          dependencyType: "attributeRefResolutions",
+          attributeName: "forAnswer"
+        }
+      }),
+      definition({ dependencyValues }) {
+        if (dependencyValues.forAnswer?.length === 1) {
+          const forAnswer = dependencyValues.forAnswer[0];
+          if (!forAnswer.unresolvedPath) {
+            return {
+              setValue: {
+                answerDelegateIdx: forAnswer.componentIdx
+              }
+            };
+          }
+        }
+        return {
+          setValue: {
+            answerDelegateIdx: null
+          }
+        };
+      }
+    };
+    stateVariableDefinitions.answerDelegate = {
+      stateVariablesDeterminingDependencies: ["answerDelegateIdx"],
+      returnDependencies({ stateValues }) {
+        let dependencies2 = {};
+        if (stateValues.answerDelegateIdx !== null) {
+          dependencies2.answerDelegate = {
+            dependencyType: "multipleStateVariables",
+            componentIdx: stateValues.answerDelegateIdx,
+            variableNames: [
+              "justSubmitted",
+              "creditAchieved",
+              "showCorrectness",
+              "colorCorrectness"
+            ],
+            variablesOptional: true
+          };
+        }
+        return dependencies2;
+      },
+      definition({ dependencyValues }) {
+        let answerDelegate = null;
+        if (dependencyValues.answerDelegate && dependencyValues.answerDelegate.componentType === "answer") {
+          answerDelegate = dependencyValues.answerDelegate;
+        }
+        return { setValue: { answerDelegate } };
+      }
+    };
     stateVariableDefinitions.answerAncestor = {
       returnDependencies: () => ({
         answerAncestor: {
@@ -101852,6 +102114,7 @@ class Input extends InlineComponent {
             "justSubmitted",
             "creditAchieved",
             "showCorrectness",
+            "colorCorrectness",
             "submitLabel",
             "submitLabelNoCorrectness",
             "numAttemptsLeft",
@@ -101914,12 +102177,24 @@ class Input extends InlineComponent {
         answerAncestor: {
           dependencyType: "stateVariable",
           variableName: "answerAncestor"
+        },
+        answerDelegate: {
+          dependencyType: "stateVariable",
+          variableName: "answerDelegate"
+        },
+        answerOverride: {
+          dependencyType: "stateVariable",
+          variableName: "answerOverride"
         }
       }),
       definition: function({ dependencyValues }) {
         let creditAchieved = 0;
-        if (dependencyValues.answerAncestor) {
+        if (dependencyValues.answerOverride) {
+          creditAchieved = dependencyValues.answerOverride.stateValues.creditAchieved;
+        } else if (dependencyValues.answerAncestor) {
           creditAchieved = dependencyValues.answerAncestor.stateValues.creditAchieved;
+        } else if (dependencyValues.answerDelegate) {
+          creditAchieved = dependencyValues.answerDelegate.stateValues.creditAchieved;
         }
         return {
           setValue: { creditAchieved }
@@ -101950,12 +102225,30 @@ class Input extends InlineComponent {
         answerAncestor: {
           dependencyType: "stateVariable",
           variableName: "answerAncestor"
+        },
+        answerDelegate: {
+          dependencyType: "stateVariable",
+          variableName: "answerDelegate"
+        },
+        answerOverride: {
+          dependencyType: "stateVariable",
+          variableName: "answerOverride"
         }
       }),
       definition: function({ dependencyValues }) {
         let justSubmitted = false;
-        if (dependencyValues.answerAncestor && dependencyValues.answerAncestor.stateValues.justSubmitted) {
-          justSubmitted = true;
+        if (dependencyValues.answerOverride) {
+          if (dependencyValues.answerOverride.stateValues.justSubmitted) {
+            justSubmitted = true;
+          }
+        } else if (dependencyValues.answerAncestor) {
+          if (dependencyValues.answerAncestor.stateValues.justSubmitted) {
+            justSubmitted = true;
+          }
+        } else if (dependencyValues.answerDelegate) {
+          if (dependencyValues.answerDelegate.stateValues.justSubmitted) {
+            justSubmitted = true;
+          }
         }
         return {
           setValue: { justSubmitted }
@@ -101972,18 +102265,64 @@ class Input extends InlineComponent {
         answerAncestor: {
           dependencyType: "stateVariable",
           variableName: "answerAncestor"
+        },
+        answerDelegate: {
+          dependencyType: "stateVariable",
+          variableName: "answerDelegate"
+        },
+        answerOverride: {
+          dependencyType: "stateVariable",
+          variableName: "answerOverride"
         }
       }),
       definition({ dependencyValues }) {
         let showCorrectness;
-        if (dependencyValues.answerAncestor) {
+        if (dependencyValues.answerOverride) {
+          showCorrectness = dependencyValues.answerOverride.stateValues.showCorrectness;
+        } else if (dependencyValues.answerAncestor) {
           showCorrectness = dependencyValues.answerAncestor.stateValues.showCorrectness;
+        } else if (dependencyValues.answerDelegate) {
+          showCorrectness = dependencyValues.answerDelegate.stateValues.showCorrectness;
         } else {
           showCorrectness = dependencyValues.showCorrectnessFlag !== false;
         }
         return { setValue: { showCorrectness } };
       }
     };
+    stateVariableDefinitions.colorCorrectness = {
+      forRenderer: true,
+      returnDependencies: () => ({
+        answerAncestor: {
+          dependencyType: "stateVariable",
+          variableName: "answerAncestor"
+        },
+        answerDelegate: {
+          dependencyType: "stateVariable",
+          variableName: "answerDelegate"
+        },
+        answerOverride: {
+          dependencyType: "stateVariable",
+          variableName: "answerOverride"
+        },
+        showCorrectness: {
+          dependencyType: "stateVariable",
+          variableName: "showCorrectness"
+        }
+      }),
+      definition({ dependencyValues }) {
+        let colorCorrectness = true;
+        if (!dependencyValues.showCorrectness) {
+          colorCorrectness = false;
+        } else if (dependencyValues.answerOverride) {
+          colorCorrectness = dependencyValues.answerOverride.stateValues.colorCorrectness;
+        } else if (dependencyValues.answerAncestor) {
+          colorCorrectness = dependencyValues.answerAncestor.stateValues.colorCorrectness;
+        } else if (dependencyValues.answerDelegate) {
+          colorCorrectness = dependencyValues.answerDelegate.stateValues.colorCorrectness;
+        }
+        return { setValue: { colorCorrectness } };
+      }
+    };
     stateVariableDefinitions.submitLabel = {
       forRenderer: true,
       returnDependencies: () => ({
@@ -105564,6 +105903,7 @@ class Document extends BaseComponent {
     delete attributes.fixed;
     delete attributes.styleNumber;
     delete attributes.isResponse;
+    delete attributes.isPotentialResponse;
     attributes.documentWideCheckWork = {
       createComponentOfType: "boolean",
       createStateVariable: "documentWideCheckWork",
@@ -105573,7 +105913,17 @@ class Document extends BaseComponent {
     attributes.showCorrectness = {
       createComponentOfType: "boolean",
       createStateVariable: "showCorrectnessPreliminary",
-      defaultValue: null
+      defaultValue: true
+    };
+    attributes.colorCorrectness = {
+      createComponentOfType: "boolean",
+      createStateVariable: "colorCorrectnessPreliminary",
+      defaultValue: true
+    };
+    attributes.forceIndividualAnswerColoring = {
+      createComponentOfType: "boolean",
+      createStateVariable: "forceIndividualAnswerColoring",
+      defaultValue: false
     };
     attributes.submitLabel = {
       createComponentOfType: "text",
@@ -106067,28 +106417,35 @@ class Document extends BaseComponent {
     stateVariableDefinitions.createSubmitAllButton = {
       forRenderer: true,
       additionalStateVariablesDefined: [
-        {
-          variableName: "suppressAnswerSubmitButtons",
-          forRenderer: true
-        }
+        "suppressAnswerSubmitButtons",
+        "descendantColorCorrectnessBasedOnIdx"
       ],
       returnDependencies: () => ({
         documentWideCheckWork: {
           dependencyType: "stateVariable",
           variableName: "documentWideCheckWork"
+        },
+        forceIndividualAnswerColoring: {
+          dependencyType: "stateVariable",
+          variableName: "forceIndividualAnswerColoring"
         }
       }),
       definition({ dependencyValues, componentIdx }) {
         let createSubmitAllButton = false;
         let suppressAnswerSubmitButtons = false;
+        let descendantColorCorrectnessBasedOnIdx = null;
         if (dependencyValues.documentWideCheckWork) {
           createSubmitAllButton = true;
           suppressAnswerSubmitButtons = true;
+          if (!dependencyValues.forceIndividualAnswerColoring) {
+            descendantColorCorrectnessBasedOnIdx = componentIdx;
+          }
         }
         return {
           setValue: {
             createSubmitAllButton,
-            suppressAnswerSubmitButtons
+            suppressAnswerSubmitButtons,
+            descendantColorCorrectnessBasedOnIdx
           }
         };
       }
@@ -106249,6 +106606,10 @@ let TextList$1 = class TextList extends CompositeComponent {
     attributes.isResponse = {
       leaveRaw: true
     };
+    attributes.isPotentialResponse = {
+      leaveRaw: true,
+      excludeFromSchema: true
+    };
     attributes.asList = {
       createPrimitiveOfType: "boolean",
       createStateVariable: "asList",
@@ -106489,7 +106850,7 @@ let TextList$1 = class TextList extends CompositeComponent {
     let replacements = [];
     let componentsCopied = [];
     let attributesToConvert = {};
-    for (let attr of ["fixed", "isResponse"]) {
+    for (let attr of ["fixed", "isResponse", "isPotentialResponse"]) {
       if (attr in component.attributes) {
         attributesToConvert[attr] = component.attributes[attr];
       }
@@ -106874,6 +107235,10 @@ class NumberList extends CompositeComponent {
     attributes.isResponse = {
       leaveRaw: true
     };
+    attributes.isPotentialResponse = {
+      leaveRaw: true,
+      excludeFromSchema: true
+    };
     attributes.asList = {
       createPrimitiveOfType: "boolean",
       createStateVariable: "asList",
@@ -107298,11 +107663,13 @@ class NumberList extends CompositeComponent {
     const copyChild = component.definingChildren.length === 1 && component.definingChildren[0].componentType === "_copy" ? component.definingChildren[0] : null;
     let copyChildSource;
     if (copyChild) {
-      const cIdx = await copyChild?.stateValues.extendIdx;
-      copyChildSource = {
-        componentIdx: cIdx,
-        componentType: components[cIdx].componentType
-      };
+      const cIdx = await copyChild.stateValues.extendIdx;
+      if (cIdx !== -1) {
+        copyChildSource = {
+          componentIdx: cIdx,
+          componentType: components[cIdx].componentType
+        };
+      }
     }
     let childInfoByComponent = await component.stateValues.childInfoByComponent;
     let numComponents = await component.stateValues.numComponents;
@@ -107461,6 +107828,10 @@ class BooleanList extends CompositeComponent {
     attributes.isResponse = {
       leaveRaw: true
     };
+    attributes.isPotentialResponse = {
+      leaveRaw: true,
+      excludeFromSchema: true
+    };
     attributes.asList = {
       createPrimitiveOfType: "boolean",
       createStateVariable: "asList",
@@ -107701,7 +108072,7 @@ class BooleanList extends CompositeComponent {
     let replacements = [];
     let componentsCopied = [];
     let attributesToConvert = {};
-    for (let attr of ["fixed", "isResponse"]) {
+    for (let attr of ["fixed", "isResponse", "isPotentialResponse"]) {
       if (attr in component.attributes) {
         attributesToConvert[attr] = component.attributes[attr];
       }
@@ -107822,6 +108193,7 @@ class Collect extends CompositeComponent {
     delete attributes.fixed;
     delete attributes.styleNumber;
     delete attributes.isResponse;
+    delete attributes.isPotentialResponse;
     delete attributes.hide;
     attributes.maxNumber = {
       createComponentOfType: "number",
@@ -119302,6 +119674,10 @@ class VectorListComponent extends CompositeComponent {
     attributes.isResponse = {
       leaveRaw: true
     };
+    attributes.isPotentialResponse = {
+      leaveRaw: true,
+      excludeFromSchema: true
+    };
     attributes.asList = {
       createPrimitiveOfType: "boolean",
       createStateVariable: "asList",
@@ -119701,11 +120077,13 @@ class VectorListComponent extends CompositeComponent {
     const copyChild = component.definingChildren.length === 1 && component.definingChildren[0].componentType === "_copy" ? component.definingChildren[0] : null;
     let copyChildSource;
     if (copyChild) {
-      const cIdx = await copyChild?.stateValues.extendIdx;
-      copyChildSource = {
-        componentIdx: cIdx,
-        componentType: components[cIdx].componentType
-      };
+      const cIdx = await copyChild.stateValues.extendIdx;
+      if (cIdx !== -1) {
+        copyChildSource = {
+          componentIdx: cIdx,
+          componentType: components[cIdx].componentType
+        };
+      }
     }
     let childIndicesByVector = await component.stateValues.childIndicesByVector;
     let numVectors = await component.stateValues.numVectors;
@@ -119903,6 +120281,10 @@ class PointList extends CompositeComponent {
     attributes.isResponse = {
       leaveRaw: true
     };
+    attributes.isPotentialResponse = {
+      leaveRaw: true,
+      excludeFromSchema: true
+    };
     attributes.asList = {
       createPrimitiveOfType: "boolean",
       createStateVariable: "asList",
@@ -120306,11 +120688,13 @@ class PointList extends CompositeComponent {
     const copyChild = component.definingChildren.length === 1 && component.definingChildren[0].componentType === "_copy" ? component.definingChildren[0] : null;
     let copyChildSource;
     if (copyChild) {
-      const cIdx = await copyChild?.stateValues.extendIdx;
-      copyChildSource = {
-        componentIdx: cIdx,
-        componentType: components[cIdx].componentType
-      };
+      const cIdx = await copyChild.stateValues.extendIdx;
+      if (cIdx !== -1) {
+        copyChildSource = {
+          componentIdx: cIdx,
+          componentType: components[cIdx].componentType
+        };
+      }
     }
     let childIndicesByPoint = await component.stateValues.childIndicesByPoint;
     let numPoints = await component.stateValues.numPoints;
@@ -120487,6 +120871,10 @@ class IntervalList extends CompositeComponent {
     attributes.isResponse = {
       leaveRaw: true
     };
+    attributes.isPotentialResponse = {
+      leaveRaw: true,
+      excludeFromSchema: true
+    };
     attributes.asList = {
       createPrimitiveOfType: "boolean",
       createStateVariable: "asList",
@@ -120787,11 +121175,13 @@ class IntervalList extends CompositeComponent {
     const copyChild = component.definingChildren.length === 1 && component.definingChildren[0].componentType === "_copy" ? component.definingChildren[0] : null;
     let copyChildSource;
     if (copyChild) {
-      const cIdx = await copyChild?.stateValues.extendIdx;
-      copyChildSource = {
-        componentIdx: cIdx,
-        componentType: components[cIdx].componentType
-      };
+      const cIdx = await copyChild.stateValues.extendIdx;
+      if (cIdx !== -1) {
+        copyChildSource = {
+          componentIdx: cIdx,
+          componentType: components[cIdx].componentType
+        };
+      }
     }
     let childIndicesByInterval = await component.stateValues.childIndicesByInterval;
     let numIntervals = await component.stateValues.numIntervals;
@@ -124934,7 +125324,13 @@ function returnStandardAnswerAttributes() {
     showCorrectness: {
       createComponentOfType: "boolean",
       createStateVariable: "showCorrectnessPreliminary",
-      defaultValue: null
+      defaultValue: true
+    },
+    colorCorrectness: {
+      createComponentOfType: "boolean",
+      createStateVariable: "colorCorrectnessPreliminary",
+      defaultValue: true,
+      public: true
     },
     disableAfterCorrect: {
       createComponentOfType: "boolean",
@@ -124986,18 +125382,54 @@ function returnStandardAnswerStateVariableDefinition() {
       handGraded: {
         dependencyType: "stateVariable",
         variableName: "handGraded"
+      },
+      showCorrectnessAncestor: {
+        dependencyType: "ancestor",
+        variableNames: ["showCorrectness"]
       }
     }),
     definition({ dependencyValues, usedDefault }) {
       let showCorrectness;
       if (!usedDefault.showCorrectnessPreliminary) {
         showCorrectness = dependencyValues.showCorrectnessPreliminary;
+      } else if (dependencyValues.handGraded) {
+        showCorrectness = false;
+      } else if (dependencyValues.showCorrectnessAncestor) {
+        showCorrectness = dependencyValues.showCorrectnessAncestor.stateValues.showCorrectness;
       } else {
-        showCorrectness = dependencyValues.showCorrectnessFlag !== false && !dependencyValues.handGraded;
+        showCorrectness = dependencyValues.showCorrectnessFlag !== false;
       }
       return { setValue: { showCorrectness } };
     }
   };
+  stateVariableDefinitions.colorCorrectness = {
+    forRenderer: true,
+    returnDependencies: () => ({
+      colorCorrectnessPreliminary: {
+        dependencyType: "stateVariable",
+        variableName: "colorCorrectnessPreliminary"
+      },
+      showCorrectness: {
+        dependencyType: "stateVariable",
+        variableName: "showCorrectness"
+      },
+      colorCorrectnessAncestor: {
+        dependencyType: "ancestor",
+        variableNames: ["colorCorrectness"]
+      }
+    }),
+    definition({ dependencyValues, usedDefault }) {
+      let colorCorrectness = true;
+      if (!dependencyValues.showCorrectness) {
+        colorCorrectness = false;
+      } else if (!usedDefault.colorCorrectnessPreliminary) {
+        colorCorrectness = dependencyValues.colorCorrectnessPreliminary;
+      } else if (dependencyValues.colorCorrectnessAncestor) {
+        colorCorrectness = dependencyValues.colorCorrectnessAncestor.stateValues.colorCorrectness;
+      }
+      return { setValue: { colorCorrectness } };
+    }
+  };
   stateVariableDefinitions.suppressCheckWork = {
     returnDependencies: () => ({
       autoSubmit: {
@@ -125398,6 +125830,7 @@ class Answer extends InlineComponent {
     attributes.inline = {
       createComponentOfType: "boolean",
       createStateVariable: "inline",
+      forRenderer: true,
       defaultValue: false,
       public: true
     };
@@ -125586,22 +126019,21 @@ class Answer extends InlineComponent {
         }
         return false;
       }
-      function addResponsesToCompositeDescendants(components) {
+      function addPotentialResponsesToReferenceDescendants(components) {
         for (let component of components) {
-          if (componentInfoObjects2.isInheritedComponentType({
-            inheritedComponentType: component.componentType,
-            baseComponentType: "_composite"
-          })) {
+          if (component.componentType === "_copy") {
             if (!component.attributes) {
               component.attributes = {};
             }
-            component.attributes.isResponse = {
+            component.attributes.isPotentialResponse = {
               type: "unresolved",
-              name: "isResponse",
+              name: "isPotentialResponse",
               children: ["true"]
             };
           } else if (component.children) {
-            addResponsesToCompositeDescendants(component.children);
+            addPotentialResponsesToReferenceDescendants(
+              component.children
+            );
           }
         }
       }
@@ -125795,7 +126227,7 @@ class Answer extends InlineComponent {
           for (let child of matchedChildren) {
             if (componentIsSpecifiedType(child, "award")) {
               if (child.children?.length > 0) {
-                addResponsesToCompositeDescendants(
+                addPotentialResponsesToReferenceDescendants(
                   child.children
                 );
               }
@@ -126042,6 +126474,26 @@ class Answer extends InlineComponent {
         };
       }
     };
+    stateVariableDefinitions.haveBlockInputChild = {
+      forRenderer: true,
+      returnDependencies: () => ({
+        allInputChildrenIncludingSugared: {
+          dependencyType: "child",
+          childGroups: ["inputs"],
+          variableNames: ["inline"],
+          variablesOptional: true
+        }
+      }),
+      definition({ dependencyValues }) {
+        return {
+          setValue: {
+            haveBlockInputChild: dependencyValues.allInputChildrenIncludingSugared.some(
+              (child) => child.stateValues.inline === false
+            )
+          }
+        };
+      }
+    };
     stateVariableDefinitions.descriptionChildInd = {
       forRenderer: true,
       returnDependencies: () => ({
@@ -126177,13 +126629,38 @@ class Answer extends InlineComponent {
         };
       }
     };
+    stateVariableDefinitions.inputsForAnswer = {
+      returnDependencies: () => ({
+        inputsReferencing: {
+          dependencyType: "componentsReferencingAttribute",
+          attributeName: "forAnswer"
+        },
+        inputChildren: {
+          dependencyType: "stateVariable",
+          variableName: "inputChildrenWithValues"
+        }
+      }),
+      definition({ dependencyValues }) {
+        const inputsForAnswer = [];
+        if (dependencyValues.inputsReferencing) {
+          inputsForAnswer.push(
+            ...dependencyValues.inputsReferencing.filter(
+              (comp) => !dependencyValues.inputChildren.map((child) => child.componentIdx).includes(comp.componentIdx)
+            )
+          );
+        }
+        return { setValue: { inputsForAnswer } };
+      }
+    };
     stateVariableDefinitions.numResponses = {
+      additionalStateVariablesDefined: ["usePotentialResponses"],
       public: true,
       shadowingInstructions: {
         createComponentOfType: "number"
       },
       stateVariablesDeterminingDependencies: [
-        "awardInputResponseChildren"
+        "awardInputResponseChildren",
+        "inputsForAnswer"
       ],
       returnDependencies({ stateValues, componentInfoObjects: componentInfoObjects2 }) {
         let dependencies2 = {
@@ -126192,8 +126669,23 @@ class Answer extends InlineComponent {
             value: stateValues.awardInputResponseChildren.map(
               (x2) => x2.componentType
             )
+          },
+          numInputsForAnswer: {
+            dependencyType: "value",
+            value: stateValues.inputsForAnswer.length
           }
         };
+        for (let [
+          ind,
+          inputComp
+        ] of stateValues.inputsForAnswer.entries()) {
+          dependencies2["inputForAnswerNValues" + ind] = {
+            dependencyType: "stateVariable",
+            componentIdx: inputComp.componentIdx,
+            variableName: "numValues",
+            variablesOptional: true
+          };
+        }
         for (let [
           ind,
           child
@@ -126206,7 +126698,11 @@ class Answer extends InlineComponent {
               dependencyType: "descendant",
               ancestorIdx: child.componentIdx,
               componentTypes: ["_base"],
-              variableNames: ["isResponse", "numValues"],
+              variableNames: [
+                "isResponse",
+                "isPotentialResponse",
+                "numValues"
+              ],
               variablesOptional: true,
               recurseToMatchedChildren: true,
               includeNonActiveChildren: true,
@@ -126234,6 +126730,15 @@ class Answer extends InlineComponent {
       },
       definition({ dependencyValues, componentInfoObjects: componentInfoObjects2 }) {
         let numResponses = 0;
+        let numPotentialResponses = 0;
+        for (let ind = 0; ind < dependencyValues.numInputsForAnswer; ind++) {
+          let numValues = dependencyValues["inputForAnswerNValues" + ind];
+          if (numValues === void 0) {
+            numResponses += 1;
+          } else {
+            numResponses += numValues;
+          }
+        }
         for (let [
           ind,
           childType
@@ -126243,16 +126748,17 @@ class Answer extends InlineComponent {
             baseComponentType: "award"
           })) {
             for (let descendant of dependencyValues["child" + ind]) {
-              if (!descendant.stateValues.isResponse || componentInfoObjects2.isInheritedComponentType({
+              if (!descendant.stateValues.isResponse && !descendant.stateValues.isPotentialResponse || componentInfoObjects2.isInheritedComponentType({
                 inheritedComponentType: descendant.componentType,
                 baseComponentType: "_composite"
               })) {
                 continue;
               }
-              if (descendant.stateValues.numValues === void 0) {
-                numResponses += 1;
+              let numValues = descendant.stateValues.numValues ?? 1;
+              if (descendant.stateValues.isResponse) {
+                numResponses += numValues;
               } else {
-                numResponses += descendant.stateValues.numValues;
+                numPotentialResponses += numValues;
               }
             }
           } else if (componentInfoObjects2.isInheritedComponentType({
@@ -126275,7 +126781,14 @@ class Answer extends InlineComponent {
             }
           }
         }
-        return { setValue: { numResponses } };
+        let usePotentialResponses = false;
+        if (numResponses === 0 && numPotentialResponses > 0) {
+          numResponses = numPotentialResponses;
+          usePotentialResponses = true;
+        }
+        return {
+          setValue: { numResponses, usePotentialResponses }
+        };
       }
     };
     stateVariableDefinitions.currentResponses = {
@@ -126291,7 +126804,8 @@ class Answer extends InlineComponent {
       isArray: true,
       entryPrefixes: ["currentResponse"],
       stateVariablesDeterminingDependencies: [
-        "awardInputResponseChildren"
+        "awardInputResponseChildren",
+        "inputsForAnswer"
       ],
       returnArraySizeDependencies: () => ({
         numResponses: {
@@ -126312,8 +126826,27 @@ class Answer extends InlineComponent {
             value: stateValues.awardInputResponseChildren.map(
               (x2) => x2.componentType
             )
+          },
+          numInputsForAnswer: {
+            dependencyType: "value",
+            value: stateValues.inputsForAnswer.length
+          },
+          usePotentialResponses: {
+            dependencyType: "stateVariable",
+            variableName: "usePotentialResponses"
           }
         };
+        for (let [
+          ind,
+          inputComp
+        ] of stateValues.inputsForAnswer.entries()) {
+          globalDependencies["inputForAnswer" + ind] = {
+            dependencyType: "multipleStateVariables",
+            componentIdx: inputComp.componentIdx,
+            variableNames: ["value", "values", "componentType"],
+            variablesOptional: true
+          };
+        }
         for (let [
           ind,
           child
@@ -126328,6 +126861,7 @@ class Answer extends InlineComponent {
               componentTypes: ["_base"],
               variableNames: [
                 "isResponse",
+                "isPotentialResponse",
                 "value",
                 "values",
                 "formula",
@@ -126343,22 +126877,10 @@ class Answer extends InlineComponent {
             inheritedComponentType: child.componentType,
             baseComponentType: "_input"
           })) {
-            globalDependencies["childValue" + ind] = {
-              dependencyType: "stateVariable",
-              componentIdx: child.componentIdx,
-              variableName: "value",
-              variablesOptional: true
-            };
-            globalDependencies["childValues" + ind] = {
-              dependencyType: "stateVariable",
-              componentIdx: child.componentIdx,
-              variableName: "values",
-              variablesOptional: true
-            };
-            globalDependencies["childComponentType" + ind] = {
-              dependencyType: "stateVariable",
+            globalDependencies["child" + ind] = {
+              dependencyType: "multipleStateVariables",
               componentIdx: child.componentIdx,
-              variableName: "componentType",
+              variableNames: ["value", "values", "componentType"],
               variablesOptional: true
             };
           } else {
@@ -126378,6 +126900,11 @@ class Answer extends InlineComponent {
         let currentResponses = [];
         let componentType = [];
         let responseComponents = [];
+        for (let ind = 0; ind < globalDependencyValues.numInputsForAnswer; ind++) {
+          const input = globalDependencyValues["inputForAnswer" + ind];
+          input.componentType = input.stateValues.componentType;
+          responseComponents.push(input);
+        }
         for (let [
           ind,
           childType
@@ -126387,7 +126914,7 @@ class Answer extends InlineComponent {
             baseComponentType: "award"
           })) {
             for (let descendant of globalDependencyValues["child" + ind]) {
-              if (!descendant.stateValues.isResponse || componentInfoObjects2.isInheritedComponentType({
+              if (!descendant.stateValues.isResponse && (!globalDependencyValues.usePotentialResponses || !descendant.stateValues.isPotentialResponse) || componentInfoObjects2.isInheritedComponentType({
                 inheritedComponentType: descendant.componentType,
                 baseComponentType: "_composite"
               })) {
@@ -126399,14 +126926,8 @@ class Answer extends InlineComponent {
             inheritedComponentType: childType,
             baseComponentType: "_input"
           })) {
-            let child = {
-              componentType: childType,
-              stateValues: {
-                value: globalDependencyValues["childValue" + ind],
-                values: globalDependencyValues["childValues" + ind],
-                componentType: globalDependencyValues["childComponentType" + ind]
-              }
-            };
+            const child = globalDependencyValues["child" + ind];
+            child.componentType = child.stateValues.componentType;
             responseComponents.push(child);
           } else {
             responseComponents.push(
@@ -136048,6 +136569,10 @@ class Repeat extends CompositeComponent {
     attributes.isResponse = {
       leaveRaw: true
     };
+    attributes.isPotentialResponse = {
+      leaveRaw: true,
+      excludeFromSchema: true
+    };
     attributes.asList = {
       createPrimitiveOfType: "boolean",
       createStateVariable: "asList",
@@ -136839,6 +137364,10 @@ class RepeatForSequence extends CompositeComponent {
     attributes.isResponse = {
       leaveRaw: true
     };
+    attributes.isPotentialResponse = {
+      leaveRaw: true,
+      excludeFromSchema: true
+    };
     attributes.asList = {
       createPrimitiveOfType: "boolean",
       createStateVariable: "asList",
@@ -181675,6 +182204,10 @@ class Group extends CompositeComponent {
     attributes.isResponse = {
       leaveRaw: true
     };
+    attributes.isPotentialResponse = {
+      leaveRaw: true,
+      excludeFromSchema: true
+    };
     attributes.createComponentOfType = {
       createPrimitiveOfType: "string"
     };
@@ -181835,15 +182368,20 @@ class Group extends CompositeComponent {
         prefix: `${component.stateId}|`,
         num: workspace.replacementsCreated
       };
-      if ("isResponse" in component.attributes) {
+      if ("isResponse" in component.attributes || "isPotentialResponse" in component.attributes) {
+        const attributes = {};
+        if ("isResponse" in component.attributes) {
+          attributes.isResponse = component.attributes.isResponse;
+        }
+        if ("isPotentialResponse" in component.attributes) {
+          attributes.isPotentialResponse = component.attributes.isPotentialResponse;
+        }
         for (let repl of replacements) {
           if (typeof repl !== "object") {
             continue;
           }
           const res = convertUnresolvedAttributesForComponentType({
-            attributes: {
-              isResponse: component.attributes.isResponse
-            },
+            attributes,
             componentType: repl.componentType,
             componentInfoObjects: componentInfoObjects2,
             nComponents,
@@ -203575,6 +204113,7 @@ class Copy extends CompositeComponent {
     delete attributes.fixed;
     delete attributes.styleNumber;
     delete attributes.isResponse;
+    delete attributes.isPotentialResponse;
     delete attributes.hide;
     attributes.createComponentOfType = {
       createPrimitiveOfType: "string"
@@ -203686,7 +204225,7 @@ class Copy extends CompositeComponent {
       // then remove the relevant code from `Dependencies`
       // determineDependenciesImmediately: true,
       returnDependencies({ stateValues }) {
-        if (stateValues.extendIdx != void 0) {
+        if (stateValues.extendIdx !== -1) {
           return {
             extendedComponent: {
               dependencyType: "componentIdentity",