@doenet/v06-to-v07 0.7.20-dev.307 → 0.7.20-dev.309

package/{index-C0ofSjwe.js → index-BH7K9foM.js}

@@ -10899,6 +10899,50 @@ function answerSugar(node) {
     node.children = [answerElement, videoCreditMessage, callActionElement];
   }
 }
+const SCORED_SECTION_COMPONENT_TYPES = [
+  "document",
+  "section",
+  "subsection",
+  "subsubsection",
+  "paragraphs",
+  "aside",
+  "objectives",
+  "problem",
+  "exercise",
+  "question",
+  "activity",
+  "example",
+  "definition",
+  "note",
+  "theorem",
+  "part",
+  "task",
+  "proof",
+  "problems",
+  "exercises",
+  "standinForFutureLayoutTag",
+  "externalContent",
+  "cascade",
+  "div",
+  "span",
+  "ol",
+  "ul",
+  "li",
+  "p"
+];
+function renamedScoredSectionAttribute(oldName, newName) {
+  const rule = {
+    to: newName,
+    warningMessage: `[deprecation] Attribute \`${oldName}\` is deprecated; use \`${newName}\` instead.`,
+    conflictWarningMessage: `[deprecation] Attribute \`${oldName}\` is deprecated and ignored because \`${newName}\` is also specified.`
+  };
+  return Object.fromEntries(
+    SCORED_SECTION_COMPONENT_TYPES.map((comp) => [
+      comp,
+      { [oldName]: rule }
+    ])
+  );
+}
 function ignoredAttributes(componentName, attributeNames) {
   return Object.fromEntries(
     attributeNames.map((attributeName) => [
@@ -10909,9 +10953,19 @@ function ignoredAttributes(componentName, attributeNames) {
     ])
   );
 }
+const SCORED_SECTION_COLORING_RENAMES = renamedScoredSectionAttribute(
+  "forceIndividualAnswerColoring",
+  "colorAnswersSeparately"
+);
 const DEPRECATION_REGISTRY = {
   attributeRenames: {
+    // Merge per-component rules, spreading scored-section rename rules
+    // first so component-specific rules take precedence on conflict.
+    ...SCORED_SECTION_COLORING_RENAMES,
     document: {
+      // document already has a scored-section rename (spread above) plus
+      // its own documentWideCheckWork rename.
+      ...SCORED_SECTION_COLORING_RENAMES["document"],
       documentWideCheckWork: {
         to: "sectionWideCheckWork",
         warningMessage: "[deprecation] Attribute `documentWideCheckWork` on `<document>` is deprecated; use `sectionWideCheckWork` instead.",
@@ -40909,7 +40963,7 @@ async function cidFromArrayBuffer(data) {
       await crypto.subtle.digest("SHA-256", new Uint8Array());
       digest = (data2) => crypto.subtle.digest("SHA-256", data2);
     } catch (e22) {
-      const sha256 = (await import("./sha256-C0vj3HDn-ILc8kzpi-tZRzzwtP.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-C0vj3HDn-Dy8iD4h--1Hj5Gcpr.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -49562,6 +49616,54 @@ const PRIMITIVE_TO_COMPONENT_TYPE = {
   stringArray: "textList",
   numberArray: "numberList"
 };
+const SHARED_STATE_VARIABLE_DEFINITIONS = /* @__PURE__ */ Symbol(
+  "sharedStateVariableDefinitions"
+);
+const classStateVariableDefinitionsCache = /* @__PURE__ */ new WeakMap();
+function getClassStateVariableDefinitions(core2, componentClass) {
+  let perCore = classStateVariableDefinitionsCache.get(core2);
+  if (!perCore) {
+    perCore = /* @__PURE__ */ new Map();
+    classStateVariableDefinitionsCache.set(core2, perCore);
+  }
+  let entry = perCore.get(componentClass);
+  if (!entry) {
+    const combined = {};
+    createAttributeStateVariableDefinitions({
+      core: core2,
+      stateVariableDefinitions: combined,
+      componentClass
+    });
+    const normalized = componentClass.returnNormalizedStateVariableDefinitions(
+      core2.numerics
+    );
+    Object.assign(combined, normalized);
+    combined[SHARED_STATE_VARIABLE_DEFINITIONS] = true;
+    entry = { combined, normalized };
+    perCore.set(componentClass, entry);
+  }
+  return entry;
+}
+function cloneStateVariableDefinition(def) {
+  const clone2 = Object.assign({}, def);
+  if (clone2.shadowingInstructions) {
+    clone2.shadowingInstructions = Object.assign(
+      {},
+      clone2.shadowingInstructions
+    );
+  }
+  if (clone2.additionalStateVariablesDefined) {
+    clone2.additionalStateVariablesDefined = [
+      ...clone2.additionalStateVariablesDefined
+    ];
+  }
+  if (clone2.stateVariablesDeterminingDependencies) {
+    clone2.stateVariablesDeterminingDependencies = [
+      ...clone2.stateVariablesDeterminingDependencies
+    ];
+  }
+  return clone2;
+}
 async function createStateVariableDefinitions({
   core: core2,
   componentClass,
@@ -49605,32 +49707,33 @@ async function createStateVariableDefinitions({
       }
     }
   }
-  let stateVariableDefinitions = {};
+  const classDefinitions = getClassStateVariableDefinitions(
+    core2,
+    componentClass
+  );
   if (!redefineDependencies) {
-    createAttributeStateVariableDefinitions({
+    return classDefinitions.combined;
+  }
+  let stateVariableDefinitions = {};
+  for (const varName in classDefinitions.normalized) {
+    stateVariableDefinitions[varName] = cloneStateVariableDefinition(
+      classDefinitions.normalized[varName]
+    );
+  }
+  if (redefineDependencies.linkSource === "adapter") {
+    createAdapterStateVariableDefinitions({
       core: core2,
+      redefineDependencies,
+      stateVariableDefinitions,
+      componentClass
+    });
+  } else {
+    await createReferenceShadowStateVariableDefinitions({
+      core: core2,
+      redefineDependencies,
       stateVariableDefinitions,
       componentClass
     });
-  }
-  let newDefinitions = componentClass.returnNormalizedStateVariableDefinitions(core2.numerics);
-  Object.assign(stateVariableDefinitions, newDefinitions);
-  if (redefineDependencies) {
-    if (redefineDependencies.linkSource === "adapter") {
-      createAdapterStateVariableDefinitions({
-        core: core2,
-        redefineDependencies,
-        stateVariableDefinitions,
-        componentClass
-      });
-    } else {
-      await createReferenceShadowStateVariableDefinitions({
-        core: core2,
-        redefineDependencies,
-        stateVariableDefinitions,
-        componentClass
-      });
-    }
   }
   return stateVariableDefinitions;
 }
@@ -52957,6 +53060,7 @@ function cloneChangeMetadataIfNeeded({
 }) {
   return consumeChanges ? changeMetadata : deepClone(changeMetadata);
 }
+const INITIAL_CHANGE_RECORD = Object.freeze({ changed: true });
 const _Dependency = class _Dependency2 {
   constructor({
     component,
@@ -52971,7 +53075,7 @@ const _Dependency = class _Dependency2 {
     this.dependencyHandler = dependencyHandler;
     this.upstreamComponentIdx = component.componentIdx;
     this.upstreamVariableNames = allStateVariablesAffected;
-    this.definition = Object.assign({}, dependencyDefinition);
+    this.definition = dependencyDefinition;
     this.representativeStateVariable = stateVariable;
     if (dependencyDefinition.doNotProxy) {
       this.doNotProxy = true;
@@ -53127,6 +53231,9 @@ const _Dependency = class _Dependency2 {
       }
       let downVarNames = mappedVarNames;
       if (originalVarNames.length > 0 || this.originalVariablesByComponent) {
+        mappedVarNames = this.dependencyHandler.internVariableNameList(
+          mappedVarNames
+        );
         this.mappedDownstreamVariableNamesByComponent.splice(
           index2,
           0,
@@ -53134,7 +53241,7 @@ const _Dependency = class _Dependency2 {
         );
         let valsChanged = {};
         for (let downVar of mappedVarNames) {
-          valsChanged[downVar] = { changed: true };
+          valsChanged[downVar] = INITIAL_CHANGE_RECORD;
         }
         this.valuesChanged.splice(index2, 0, valsChanged);
         if (this.variablesOptional) {
@@ -53234,9 +53341,10 @@ const _Dependency = class _Dependency2 {
         );
         this.valuesChanged.splice(indexToRemove, 1);
         if (this.variablesOptional) {
-          affectedDownstreamVariableNames.push(
+          affectedDownstreamVariableNames = [
+            ...affectedDownstreamVariableNames,
             this.downstreamVariableNameIfNoVariables
-          );
+          ];
         }
       }
       for (let vName of affectedDownstreamVariableNames) {
@@ -53457,7 +53565,7 @@ const _Dependency = class _Dependency2 {
               if (!mappedStateVarObj.deferred) {
                 componentObj.stateValues[nameForOutput] = await mappedStateVarObj.value;
                 let valueChanged = this.valuesChanged[componentInd][mappedVarName];
-                if (valueChanged.changed) {
+                if (valueChanged?.changed) {
                   if (!changes.valuesChanged) {
                     changes.valuesChanged = {};
                   }
@@ -53470,7 +53578,7 @@ const _Dependency = class _Dependency2 {
                   });
                 }
                 if (consumeChanges) {
-                  this.valuesChanged[componentInd][mappedVarName] = {};
+                  delete this.valuesChanged[componentInd][mappedVarName];
                 }
                 if (mappedStateVarObj.usedDefault) {
                   usedDefaultObj[nameForOutput] = true;
@@ -54039,7 +54147,7 @@ const _StateVariableComponentTypeDependency = class _StateVariableComponentTypeD
               }
             }
             let valueChanged0 = this.valuesChanged[0][mappedVarName];
-            if (valueChanged0.changed) {
+            if (valueChanged0?.changed) {
               if (!changes.valuesChanged) {
                 changes.valuesChanged = {};
               }
@@ -54052,7 +54160,7 @@ const _StateVariableComponentTypeDependency = class _StateVariableComponentTypeD
               });
             }
             if (consumeChanges) {
-              this.valuesChanged[0][mappedVarName] = {};
+              delete this.valuesChanged[0][mappedVarName];
             }
             let hasVariableComponentType = stateVarObj.shadowingInstructions?.hasVariableComponentType;
             if (!hasVariableComponentType && stateVarObj.isArrayEntry) {
@@ -57252,6 +57360,30 @@ const _UnlinkedCopySourceDependency = class _UnlinkedCopySourceDependency2 exten
 };
 _UnlinkedCopySourceDependency.dependencyType = "unlinkedCopySource";
 let UnlinkedCopySourceDependency = _UnlinkedCopySourceDependency;
+const _ShadowInfoDependency = class _ShadowInfoDependency2 extends Dependency {
+  setUpParameters() {
+    if (this.definition.componentIdx != void 0) {
+      this.componentIdx = this.definition.componentIdx;
+    } else {
+      this.componentIdx = this.upstreamComponentIdx;
+    }
+  }
+  async getValue() {
+    const component = this.dependencyHandler._components[this.componentIdx];
+    if (!component?.shadows) {
+      return { value: null, changes: {} };
+    }
+    return {
+      value: {
+        componentIdx: component.shadows.componentIdx,
+        propVariable: component.shadows.propVariable ?? null
+      },
+      changes: {}
+    };
+  }
+};
+_ShadowInfoDependency.dependencyType = "shadowInfo";
+let ShadowInfoDependency = _ShadowInfoDependency;
 const _PrimaryShadowDependency = class _PrimaryShadowDependency2 extends Dependency {
   setUpParameters() {
     if (this.definition.componentIdx != void 0) {
@@ -58400,6 +58532,7 @@ const dependencyTypeClasses = [
   ShadowSourceDependency,
   UnlinkedCopySourceDependency,
   PrimaryShadowDependency,
+  ShadowInfoDependency,
   AdapterSourceStateVariableDependency,
   AdapterSourceDependency,
   CountAmongSiblingsDependency,
@@ -58416,6 +58549,7 @@ const dependencyTypeClasses = [
   DetermineDependenciesDependency,
   FileDependency
 ];
+const EMPTY_BLOCKERS = Object.freeze({});
 class DependencyHandler {
   constructor({
     _components,
@@ -58450,6 +58584,16 @@ class DependencyHandler {
       resolveBlockedBy: {}
     };
     this.attributeRefResolutionDependenciesByReferenced = {};
+    this._internedVariableNameLists = /* @__PURE__ */ new Map();
+  }
+  internVariableNameList(names) {
+    const key = names.join("\n");
+    let interned = this._internedVariableNameLists.get(key);
+    if (!interned) {
+      interned = Object.freeze(names);
+      this._internedVariableNameLists.set(key, interned);
+    }
+    return interned;
   }
   async setUpComponentDependencies(component) {
     if (this.downstreamDependencies[component.componentIdx]) {
@@ -59165,26 +59309,11 @@ class DependencyHandler {
           let ind = upDep.downstreamComponentIndices.indexOf(componentIdx);
           let upValuesChanged = upDep.valuesChanged[ind][varName];
           if (!upValuesChanged) {
-            if (component.stateVarAliases) {
-              for (let alias in component.stateVarAliases) {
-                if (component.stateVarAliases[alias] === varName && // @ts-expect-error see "Note (dated July 20, 2023)" above:
-                // `upValuesChangedSub` is undefined; keeping the
-                // reference verbatim so behavior matches the JS source.
-                alias in upValuesChangedSub) {
-                  upValuesChanged = // @ts-expect-error same as above
-                  upValuesChangedSub[alias];
-                }
-              }
-            }
-          }
-          if (!upValuesChanged) {
-            if (!component.state[varName].isArrayEntry) {
-              throw Error(
-                `Something is wrong, as a variable ${varName} of ${component.componentIdx} actually changed, but wasn't marked with a potential change`
-              );
-            }
-            upValuesChanged = // @ts-expect-error same as above
-            upValuesChangedSub[varName] = { changed: {} };
+            upValuesChanged = upDep.valuesChanged[ind][varName] = {};
+          } else if (Object.isFrozen(upValuesChanged)) {
+            upValuesChanged = upDep.valuesChanged[ind][varName] = {
+              changed: upValuesChanged.changed
+            };
           }
           if (component.state[varName] && component.state[varName].isArray) {
             if (upValuesChanged.changed === void 0) {
@@ -59302,6 +59431,45 @@ class DependencyHandler {
       finishedPropagation: parentResult.finishedPropagation
     };
   }
+  /**
+   * Non-creating variant of `getNeededToResolve`: returns the nested entry
+   * if it exists, else `EMPTY_BLOCKERS`, without materializing intermediate
+   * levels. `getNeededToResolve` creates the whole nested chain on every
+   * lookup, and read-only callers used to leave tens of thousands of empty
+   * `{cIdx: {type: {stateVariable: {}}}}` chains behind — the bulk of
+   * `resolveBlockers`' retained memory.
+   */
+  peekNeededToResolve({
+    componentIdx,
+    type,
+    stateVariable,
+    dependency
+  }) {
+    let neededToResolve = this.resolveBlockers.neededToResolve[componentIdx]?.[type];
+    if (neededToResolve && stateVariable) {
+      neededToResolve = neededToResolve[stateVariable];
+      if (neededToResolve && dependency) {
+        neededToResolve = neededToResolve[dependency];
+      }
+    }
+    return neededToResolve ?? EMPTY_BLOCKERS;
+  }
+  /** Non-creating variant of `getResolveBlockedBy`; see `peekNeededToResolve`. */
+  peekResolveBlockedBy({
+    componentIdx,
+    type,
+    stateVariable,
+    dependency
+  }) {
+    let resolveBlockedBy = this.resolveBlockers.resolveBlockedBy[componentIdx]?.[type];
+    if (resolveBlockedBy && stateVariable) {
+      resolveBlockedBy = resolveBlockedBy[stateVariable];
+      if (resolveBlockedBy && dependency) {
+        resolveBlockedBy = resolveBlockedBy[dependency];
+      }
+    }
+    return resolveBlockedBy ?? EMPTY_BLOCKERS;
+  }
   getNeededToResolve({ componentIdx, type, stateVariable, dependency }) {
     let neededToResolveForComponent = this.resolveBlockers.neededToResolve[componentIdx];
     if (!neededToResolveForComponent) {
@@ -59811,7 +59979,7 @@ class DependencyHandler {
         } catch (e32) {
         }
         if (dep) {
-          let neededForItem = this.getNeededToResolve({
+          let neededForItem = this.peekNeededToResolve({
             componentIdx: componentIdxNewlyResolved,
             type: "stateVariable",
             stateVariable: stateVariableNewlyResolved
@@ -59902,7 +60070,7 @@ class DependencyHandler {
         );
       }
     }
-    let resolveBlockedByNewlyResolved = this.getResolveBlockedBy({
+    let resolveBlockedByNewlyResolved = this.peekResolveBlockedBy({
       componentIdx: componentIdxNewlyResolved,
       type: typeNewlyResolved,
       stateVariable: stateVariableNewlyResolved,
@@ -60004,7 +60172,7 @@ class DependencyHandler {
     expandComposites = true,
     numPreviouslyNeeded
   }) {
-    let neededForItem = this.getNeededToResolve({
+    let neededForItem = this.peekNeededToResolve({
       componentIdx,
       type,
       stateVariable,
@@ -60046,7 +60214,7 @@ class DependencyHandler {
         break;
       }
       if (nFailures > 0) {
-        neededForItem = this.getNeededToResolve({
+        neededForItem = this.peekNeededToResolve({
           componentIdx,
           type,
           stateVariable,
@@ -60086,7 +60254,7 @@ class DependencyHandler {
       }
     }
     if (nFailures > 0) {
-      neededForItem = this.getNeededToResolve({
+      neededForItem = this.peekNeededToResolve({
         componentIdx,
         type,
         stateVariable,
@@ -60134,7 +60302,7 @@ class DependencyHandler {
       expandComposites
     });
     if (!finalResult.success) {
-      let stillNeededForItem = this.getNeededToResolve({
+      let stillNeededForItem = this.peekNeededToResolve({
         componentIdx,
         type,
         stateVariable,
@@ -60186,7 +60354,7 @@ class DependencyHandler {
     }
     if (!this.circularResolveBlockedCheckPassed[identifier]) {
       this.circularResolveBlockedCheckPassed[identifier] = true;
-      let neededForItem = this.getNeededToResolve({
+      let neededForItem = this.peekNeededToResolve({
         componentIdx,
         type,
         stateVariable,
@@ -60301,7 +60469,7 @@ class DependencyHandler {
     let identifier = code + "|" + type;
     if (this.circularResolveBlockedCheckPassed[identifier]) {
       delete this.circularResolveBlockedCheckPassed[identifier];
-      let resolveBlockedBy = this.getResolveBlockedBy({
+      let resolveBlockedBy = this.peekResolveBlockedBy({
         componentIdx,
         type,
         stateVariable,
@@ -63755,12 +63923,13 @@ class StalenessPropagator {
             if (!upDep.valuesChanged[componentInd]) {
               upDep.valuesChanged[componentInd] = {};
             }
-            if (!upDep.valuesChanged[componentInd][varName]) {
-              upDep.valuesChanged[componentInd][varName] = {};
+            let changeRecord = upDep.valuesChanged[componentInd][varName];
+            if (!changeRecord || Object.isFrozen(changeRecord)) {
+              changeRecord = upDep.valuesChanged[componentInd][varName] = changeRecord ? { changed: changeRecord.changed } : {};
             }
-            upDep.valuesChanged[componentInd][varName].potentialChange = true;
+            changeRecord.potentialChange = true;
             if (freshnessInfo) {
-              upDep.valuesChanged[componentInd][varName].freshnessInfo = freshnessInfo;
+              changeRecord.freshnessInfo = freshnessInfo;
             }
             foundVarChange = true;
           } else if (varName === upDep.downstreamVariableNameIfNoVariables) {
@@ -68386,11 +68555,52 @@ class BaseComponent {
       this.refResolution = refResolution;
     }
     this.state = {};
-    for (let stateVariable in stateVariableDefinitions) {
-      this.state[stateVariable] = Object.assign(
-        {},
-        stateVariableDefinitions[stateVariable]
-      );
+    if (stateVariableDefinitions[SHARED_STATE_VARIABLE_DEFINITIONS]) {
+      for (let stateVariable in stateVariableDefinitions) {
+        let def = Object.create(
+          stateVariableDefinitions[stateVariable]
+        );
+        if (def.shadowingInstructions) {
+          def.shadowingInstructions = Object.assign(
+            {},
+            def.shadowingInstructions
+          );
+        }
+        if (def.additionalStateVariablesDefined) {
+          def.additionalStateVariablesDefined = [
+            ...def.additionalStateVariablesDefined
+          ];
+        }
+        if (def.stateVariablesDeterminingDependencies) {
+          def.stateVariablesDeterminingDependencies = [
+            ...def.stateVariablesDeterminingDependencies
+          ];
+        }
+        this.state[stateVariable] = def;
+      }
+    } else {
+      for (let stateVariable in stateVariableDefinitions) {
+        this.state[stateVariable] = stateVariableDefinitions[stateVariable];
+      }
+    }
+    let workspaceAssigned = /* @__PURE__ */ new Set();
+    for (let stateVariable in this.state) {
+      let def = this.state[stateVariable];
+      if (!def.createWorkspace || workspaceAssigned.has(stateVariable)) {
+        continue;
+      }
+      let workspace = {};
+      def.workspace = workspace;
+      workspaceAssigned.add(stateVariable);
+      if (def.additionalStateVariablesDefined) {
+        for (let otherVar of def.additionalStateVariablesDefined) {
+          let otherDef = this.state[otherVar];
+          if (otherDef?.createWorkspace) {
+            otherDef.workspace = workspace;
+            workspaceAssigned.add(otherVar);
+          }
+        }
+      }
     }
     this.stateValues = new Proxy(this.state, createStateProxyHandler());
     this.essentialState = {};
@@ -74964,12 +75174,12 @@ function returnScoredSectionAttributes() {
       groupName: "scoring",
       description: "Whether to color-code the answers it contains based on correctness."
     },
-    forceIndividualAnswerColoring: {
+    colorAnswersSeparately: {
       createComponentOfType: "boolean",
-      createStateVariable: "forceIndividualAnswerColoring",
+      createStateVariable: "colorAnswersSeparately",
       defaultValue: false,
       groupName: "scoring",
-      description: "Whether to force per-answer color-correctness even when section-wide check work is enabled."
+      description: "When section-wide check work is enabled, color each answer based on its own correctness rather than the section's overall credit."
     },
     submitLabel: {
       createComponentOfType: "text",
@@ -75415,9 +75625,9 @@ function returnScoredSectionStateVariableDefinition() {
         dependencyType: "stateVariable",
         variableName: "sectionWideCheckWork"
       },
-      forceIndividualAnswerColoring: {
+      colorAnswersSeparately: {
         dependencyType: "stateVariable",
-        variableName: "forceIndividualAnswerColoring"
+        variableName: "colorAnswersSeparately"
       },
       ancestorDeterminingSubmit: {
         dependencyType: "ancestor",
@@ -75437,7 +75647,7 @@ function returnScoredSectionStateVariableDefinition() {
       } else if (dependencyValues.sectionWideCheckWork) {
         createSubmitAllButton = true;
         suppressAnswerSubmitButtons = true;
-        if (!dependencyValues.forceIndividualAnswerColoring) {
+        if (!dependencyValues.colorAnswersSeparately) {
           descendantColorCorrectnessBasedOnIdx = componentIdx;
         }
       }
@@ -111064,7 +111274,8 @@ class Input extends InlineComponent {
             "nextCreditFactor",
             "forceFullCheckWorkButton",
             "forceSmallCheckWorkButton",
-            "labelsForAnswer"
+            "labelsForAnswer",
+            "colorInputsSeparately"
           ]
         }
       }),
@@ -111151,7 +111362,8 @@ class Input extends InlineComponent {
               "justSubmitted",
               "creditAchieved",
               "showCorrectness",
-              "colorCorrectness"
+              "colorCorrectness",
+              "colorInputsSeparately"
             ],
             variablesOptional: true
           };
@@ -111236,18 +111448,63 @@ class Input extends InlineComponent {
         return { setValue: { colorCorrectness } };
       }
     };
+    const variableForImplicitProp = this.variableForImplicitProp ?? "value";
     stateVariableDefinitions.creditAchieved = {
       forRenderer: true,
-      returnDependencies: () => ({
-        componentDeterminingDisplayedCorrectness: {
-          dependencyType: "stateVariable",
-          variableName: "componentDeterminingDisplayedCorrectness"
+      stateVariablesDeterminingDependencies: [
+        "answerAncestor",
+        "answerSpecifiedInForAnswer"
+      ],
+      returnDependencies({ stateValues }) {
+        const deps = {
+          componentDeterminingDisplayedCorrectness: {
+            dependencyType: "stateVariable",
+            variableName: "componentDeterminingDisplayedCorrectness"
+          }
+        };
+        if (stateValues.answerAncestor?.stateValues.colorInputsSeparately) {
+          deps.answerCreditAchievedPerInput = {
+            dependencyType: "ancestor",
+            componentType: "answer",
+            variableNames: ["creditAchievedPerInput"]
+          };
+        } else if (stateValues.answerSpecifiedInForAnswer !== null) {
+          deps.answerColoringState = {
+            dependencyType: "multipleStateVariables",
+            componentIdx: stateValues.answerSpecifiedInForAnswer,
+            variableNames: [
+              "colorInputsSeparately",
+              "creditAchievedPerInput"
+            ],
+            variablesOptional: true
+          };
         }
-      }),
-      definition: function({ dependencyValues }) {
+        return deps;
+      },
+      definition: function({ dependencyValues, componentIdx }) {
         let creditAchieved = 0;
-        if (dependencyValues.componentDeterminingDisplayedCorrectness) {
-          creditAchieved = dependencyValues.componentDeterminingDisplayedCorrectness.stateValues.creditAchieved;
+        const comp = dependencyValues.componentDeterminingDisplayedCorrectness;
+        if (comp) {
+          const overallCredit = comp.stateValues.creditAchieved ?? 0;
+          const creditAchievedPerInput = dependencyValues.answerCreditAchievedPerInput?.stateValues.creditAchievedPerInput ?? (dependencyValues.answerColoringState?.stateValues?.colorInputsSeparately ? dependencyValues.answerColoringState.stateValues.creditAchievedPerInput : void 0);
+          if (comp.stateValues.colorInputsSeparately && creditAchievedPerInput) {
+            const key = `${componentIdx}/${variableForImplicitProp}`;
+            let perInputCredit = creditAchievedPerInput[key];
+            if (perInputCredit === void 0 && variableForImplicitProp !== "value") {
+              const keyPrefix = `${componentIdx}/`;
+              const candidateCredits = Object.entries(
+                creditAchievedPerInput
+              ).filter(
+                ([entryKey]) => entryKey.startsWith(keyPrefix)
+              ).map(([, credit]) => credit);
+              if (candidateCredits.length > 0) {
+                perInputCredit = Math.max(...candidateCredits);
+              }
+            }
+            creditAchieved = perInputCredit !== void 0 ? perInputCredit : overallCredit;
+          } else {
+            creditAchieved = overallCredit;
+          }
         }
         return {
           setValue: { creditAchieved }
@@ -115698,6 +115955,88 @@ class FractionInput extends Input {
         }
       })
     };
+    stateVariableDefinitions.componentIdx = {
+      returnDependencies: () => ({}),
+      definition({ componentIdx }) {
+        return { setValue: { componentIdx } };
+      }
+    };
+    stateVariableDefinitions.colorInputsSeparately = {
+      stateVariablesDeterminingDependencies: [
+        "answerSpecifiedInForAnswer"
+      ],
+      returnDependencies({ stateValues }) {
+        const deps = {
+          answerAncestor: {
+            dependencyType: "stateVariable",
+            variableName: "answerAncestor"
+          }
+        };
+        if (stateValues.answerSpecifiedInForAnswer !== null) {
+          deps.forAnswerColorInputsSeparately = {
+            dependencyType: "stateVariable",
+            componentIdx: stateValues.answerSpecifiedInForAnswer,
+            variableName: "colorInputsSeparately",
+            variablesOptional: true
+          };
+        }
+        return deps;
+      },
+      definition({ dependencyValues }) {
+        if (dependencyValues.answerAncestor) {
+          return {
+            setValue: {
+              colorInputsSeparately: dependencyValues.answerAncestor.stateValues.colorInputsSeparately ?? false
+            }
+          };
+        }
+        return {
+          setValue: {
+            colorInputsSeparately: dependencyValues.forAnswerColorInputsSeparately ?? false
+          }
+        };
+      }
+    };
+    stateVariableDefinitions.creditAchievedPerInput = {
+      stateVariablesDeterminingDependencies: [
+        "colorInputsSeparately",
+        "answerAncestor",
+        "answerSpecifiedInForAnswer"
+      ],
+      returnDependencies({ stateValues }) {
+        if (!stateValues.colorInputsSeparately) {
+          return {};
+        }
+        if (stateValues.answerAncestor) {
+          return {
+            answerCreditAchievedPerInput: {
+              dependencyType: "ancestor",
+              componentType: "answer",
+              variableNames: ["creditAchievedPerInput"]
+            }
+          };
+        }
+        if (stateValues.answerSpecifiedInForAnswer !== null) {
+          return {
+            answerCreditAchievedPerInput: {
+              dependencyType: "stateVariable",
+              componentIdx: stateValues.answerSpecifiedInForAnswer,
+              variableName: "creditAchievedPerInput",
+              returnAsComponentObject: true,
+              variablesOptional: true
+            }
+          };
+        }
+        return {};
+      },
+      definition({ dependencyValues }) {
+        return {
+          setValue: {
+            creditAchievedPerInput: dependencyValues.answerCreditAchievedPerInput?.stateValues?.creditAchievedPerInput ?? {}
+          }
+        };
+      }
+    };
     return stateVariableDefinitions;
   }
   static adapters = [
@@ -115834,18 +116173,49 @@ class FractionComponentInput extends BaseComponent {
     };
     stateVariableDefinitions.creditAchieved = {
       forRenderer: true,
-      returnDependencies: () => ({
-        parentCreditAchieved: {
+      stateVariablesDeterminingDependencies: ["part"],
+      returnDependencies({ stateValues }) {
+        const deps = {
+          parentCreditAchieved: {
+            dependencyType: "parentStateVariable",
+            parentComponentType: "fractionInput",
+            variableName: "creditAchieved"
+          },
+          parentColorInputsSeparately: {
+            dependencyType: "parentStateVariable",
+            parentComponentType: "fractionInput",
+            variableName: "colorInputsSeparately"
+          }
+        };
+        deps.parentCreditAchievedPerInput = {
           dependencyType: "parentStateVariable",
           parentComponentType: "fractionInput",
-          variableName: "creditAchieved"
-        }
-      }),
+          variableName: "creditAchievedPerInput"
+        };
+        deps.parentComponentIdx = {
+          dependencyType: "parentStateVariable",
+          parentComponentType: "fractionInput",
+          variableName: "componentIdx"
+        };
+        deps.part = {
+          dependencyType: "stateVariable",
+          variableName: "part"
+        };
+        return deps;
+      },
       definition({ dependencyValues }) {
+        const fallback = dependencyValues.parentCreditAchieved ?? 0;
+        if (dependencyValues.parentColorInputsSeparately && dependencyValues.parentCreditAchievedPerInput && dependencyValues.parentComponentIdx !== void 0 && dependencyValues.part) {
+          const key = `${dependencyValues.parentComponentIdx}/${dependencyValues.part}`;
+          const perPartCredit = dependencyValues.parentCreditAchievedPerInput[key];
+          return {
+            setValue: {
+              creditAchieved: perPartCredit !== void 0 ? perPartCredit : fallback
+            }
+          };
+        }
         return {
-          setValue: {
-            creditAchieved: dependencyValues.parentCreditAchieved ?? 0
-          }
+          setValue: { creditAchieved: fallback }
         };
       }
     };
@@ -135761,6 +136131,13 @@ class Answer extends InlineComponent {
       public: true,
       description: "Maximum number of matching awards whose credits are summed."
     };
+    attributes.colorInputsSeparately = {
+      createComponentOfType: "boolean",
+      createStateVariable: "colorInputsSeparately",
+      defaultValue: false,
+      public: true,
+      description: "Attempt to color each input separately based on the awards that reference it, rather than all inputs sharing the same overall credit color."
+    };
     attributes.allowedErrorInNumbers = {
       createComponentOfType: "number",
       createStateVariable: "allowedErrorInNumbers",
@@ -136584,6 +136961,35 @@ class Answer extends InlineComponent {
         return { setValue: { inputChildWithValues } };
       }
     };
+    stateVariableDefinitions.allInputComponentIdxs = {
+      stateVariablesDeterminingDependencies: [
+        "inputChildRelativeIndices"
+      ],
+      returnDependencies: ({ stateValues }) => ({
+        inputChildren: {
+          dependencyType: "child",
+          childGroups: ["inputs"],
+          childIndices: stateValues.inputChildRelativeIndices
+        },
+        inputsForAnswer: {
+          dependencyType: "stateVariable",
+          variableName: "inputsForAnswer"
+        }
+      }),
+      definition({ dependencyValues }) {
+        const allInputComponentIdxs = /* @__PURE__ */ new Set([
+          ...dependencyValues.inputChildren.map(
+            (c2) => c2.componentIdx
+          ),
+          ...dependencyValues.inputsForAnswer.map(
+            (c2) => c2.componentIdx
+          )
+        ]);
+        return {
+          setValue: { allInputComponentIdxs }
+        };
+      }
+    };
     stateVariableDefinitions.inputComponentIdxForLabel = {
       stateVariablesDeterminingDependencies: ["inputChildrenWithValues"],
       additionalStateVariablesDefined: [
@@ -137414,6 +137820,50 @@ class Answer extends InlineComponent {
         };
       }
     };
+    stateVariableDefinitions.creditAchievedPerInput = {
+      returnDependencies: () => ({
+        awardChildren: {
+          dependencyType: "child",
+          childGroups: ["awards"],
+          variableNames: [
+            "awarded",
+            "creditAchieved",
+            "credit",
+            "referencedInputStateVars"
+          ]
+        }
+      }),
+      definition({ dependencyValues }) {
+        const maxCreditByKey = {};
+        const actualCreditByKey = {};
+        for (const award of dependencyValues.awardChildren) {
+          const referencedInputStateVars = award.stateValues.referencedInputStateVars;
+          const credit = award.stateValues.credit;
+          const awarded = award.stateValues.awarded;
+          const creditAchieved = award.stateValues.creditAchieved;
+          for (const {
+            componentIdx,
+            propVariable
+          } of referencedInputStateVars) {
+            const key = `${componentIdx}/${propVariable}`;
+            if (maxCreditByKey[key] === void 0 || credit > maxCreditByKey[key]) {
+              maxCreditByKey[key] = credit;
+            }
+            if (awarded && (actualCreditByKey[key] === void 0 || creditAchieved > actualCreditByKey[key])) {
+              actualCreditByKey[key] = creditAchieved;
+            }
+          }
+        }
+        const creditAchievedPerInput = {};
+        for (const key of Object.keys(maxCreditByKey)) {
+          const maxCredit = maxCreditByKey[key];
+          if (maxCredit > 0) {
+            creditAchievedPerInput[key] = (actualCreditByKey[key] ?? 0) / maxCredit;
+          }
+        }
+        return { setValue: { creditAchievedPerInput } };
+      }
+    };
     stateVariableDefinitions.numPreviousIncorrectSubmissions = {
       defaultValue: 0,
       hasEssential: true,
@@ -138490,6 +138940,60 @@ class Award extends BaseComponent {
       targetVariableName: "feedback1",
       description: "The first feedback message produced by this award."
     };
+    stateVariableDefinitions.colorInputsSeparatelyFromAnswer = {
+      returnDependencies: () => ({
+        colorInputsSeparately: {
+          dependencyType: "parentStateVariable",
+          variableName: "colorInputsSeparately"
+        }
+      }),
+      definition({ dependencyValues }) {
+        return {
+          setValue: {
+            colorInputsSeparatelyFromAnswer: dependencyValues.colorInputsSeparately ?? false
+          }
+        };
+      }
+    };
+    stateVariableDefinitions.referencedInputStateVars = {
+      stateVariablesDeterminingDependencies: [
+        "colorInputsSeparatelyFromAnswer"
+      ],
+      returnDependencies({ stateValues }) {
+        const deps = {
+          colorInputsSeparatelyFromAnswer: {
+            dependencyType: "parentStateVariable",
+            variableName: "colorInputsSeparately"
+          }
+        };
+        if (stateValues.colorInputsSeparatelyFromAnswer) {
+          deps.allInputComponentIdxs = {
+            dependencyType: "parentStateVariable",
+            variableName: "allInputComponentIdxs"
+          };
+          deps.whenChild = {
+            dependencyType: "child",
+            childGroups: ["whens"],
+            variableNames: ["referencedStateVars"]
+          };
+        }
+        return deps;
+      },
+      definition({ dependencyValues }) {
+        if (!dependencyValues.colorInputsSeparatelyFromAnswer) {
+          return { setValue: { referencedInputStateVars: [] } };
+        }
+        const allInputComponentIdxs = dependencyValues.allInputComponentIdxs ?? /* @__PURE__ */ new Set();
+        const referencedStateVars = dependencyValues.whenChild?.[0]?.stateValues.referencedStateVars ?? [];
+        return {
+          setValue: {
+            referencedInputStateVars: referencedStateVars.filter(
+              (ref) => allInputComponentIdxs.has(ref.componentIdx)
+            )
+          }
+        };
+      }
+    };
     return stateVariableDefinitions;
   }
   static standardizedFeedback = {
@@ -138721,6 +139225,43 @@ class When extends BooleanComponent {
         };
       }
     };
+    stateVariableDefinitions._descendantIdxs = {
+      returnDependencies: () => ({
+        allDescendants: {
+          dependencyType: "descendant",
+          componentTypes: ["_base"]
+        }
+      }),
+      definition({ dependencyValues }) {
+        return {
+          setValue: {
+            _descendantIdxs: (dependencyValues.allDescendants ?? []).map((d2) => d2.componentIdx)
+          }
+        };
+      }
+    };
+    stateVariableDefinitions.referencedStateVars = {
+      stateVariablesDeterminingDependencies: ["_descendantIdxs"],
+      returnDependencies({ stateValues }) {
+        const deps = {};
+        for (const idx of stateValues._descendantIdxs ?? []) {
+          deps[`shadowInfo_${idx}`] = {
+            dependencyType: "shadowInfo",
+            componentIdx: idx
+          };
+        }
+        return deps;
+      },
+      definition({ dependencyValues }) {
+        const referencedStateVars = [];
+        for (const [key, value] of Object.entries(dependencyValues)) {
+          if (key.startsWith("shadowInfo_") && value !== null) {
+            referencedStateVars.push(value);
+          }
+        }
+        return { setValue: { referencedStateVars } };
+      }
+    };
     return stateVariableDefinitions;
   }
   // "when" does not adapt to "text", even though boolean does
@@ -228313,4 +228854,4 @@ export {
   getDefaultExportFromCjs as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-C0ofSjwe.js.map
+//# sourceMappingURL=index-BH7K9foM.js.map