@doenet/v06-to-v07 0.7.20-dev.318 → 0.7.20-dev.319

package/{index-BBh2EPqg.js → index-CyEKEyxP.js}

@@ -40963,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-B-uuLxXp-p9edzkPO.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-C0vj3HDn-BN2lLQ1h-1QSWShIW.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -50806,6 +50806,711 @@ function returnDefaultArrayVarNameFromPropIndex(numDim, arrayEntryPrefix) {
     };
   }
 }
+function getStaleStateVariableValue() {
+  return this.svComponent.coreFunctions.getStateVariableValue({
+    component: this.svComponent,
+    stateVariable: this.svVarName
+  });
+}
+const STALE_VALUE_DESCRIPTOR = Object.freeze({
+  get: getStaleStateVariableValue,
+  configurable: true
+});
+function installStaleValueGetter(stateVarObj) {
+  delete stateVarObj.value;
+  Object.defineProperty(stateVarObj, "value", STALE_VALUE_DESCRIPTOR);
+}
+async function entryGetValueViaGetEntryValues() {
+  const arrayStateVarObj = this.svComponent.state[this.arrayStateVariable];
+  return await arrayStateVarObj.getEntryValues({
+    varName: this.svVarName
+  });
+}
+async function entryGetValueFromArrayValues() {
+  const arrayStateVarObj = this.svComponent.state[this.arrayStateVariable];
+  const arrayKeys = await this.arrayKeys;
+  if (arrayKeys.length === 0) {
+    return;
+  }
+  const value = [];
+  for (const arrayKey of arrayKeys) {
+    value.push(arrayStateVarObj.getArrayValue({ arrayKey }));
+  }
+  if (value.length === 1) {
+    return value[0];
+  } else {
+    return value;
+  }
+}
+function getEntryArrayKeys() {
+  return (async () => {
+    await this.svComponent.state[this.arrayStateVariable].arraySize;
+    return this._arrayKeys;
+  })();
+}
+const ENTRY_ARRAY_KEYS_DESCRIPTOR = Object.freeze({
+  get: getEntryArrayKeys
+});
+function getEntryUnflattenedArrayKeys() {
+  return (async () => {
+    await this.svComponent.state[this.arrayStateVariable].arraySize;
+    return this._unflattenedArrayKeys;
+  })();
+}
+const ENTRY_UNFLATTENED_ARRAY_KEYS_DESCRIPTOR = Object.freeze({ get: getEntryUnflattenedArrayKeys });
+function getEntryArraySize() {
+  return this.svComponent.state[this.arrayStateVariable].arraySize;
+}
+const ENTRY_ARRAY_SIZE_DESCRIPTOR = Object.freeze({
+  get: getEntryArraySize
+});
+function getEntryArrayEntrySize() {
+  return (async () => {
+    let unflattenedArrayKeys = await this.unflattenedArrayKeys;
+    let arrayEntrySize = [];
+    let subArray = [unflattenedArrayKeys];
+    for (let i2 = 0; i2 < this.numDimensions; i2++) {
+      subArray = subArray[0];
+      arrayEntrySize.push(subArray.length);
+    }
+    arrayEntrySize.reverse();
+    return arrayEntrySize;
+  })();
+}
+const ENTRY_ARRAY_ENTRY_SIZE_DESCRIPTOR = Object.freeze({
+  get: getEntryArrayEntrySize
+});
+function multiDimKeyToIndex(key) {
+  return key.split(",").map((x2) => Number(x2));
+}
+function oneDimKeyToIndex(key) {
+  return Number(key);
+}
+function arrayIndexToKey(index2) {
+  return String(index2);
+}
+function defaultReturnEntryDimensions() {
+  return 0;
+}
+function multiDimSetArrayValue({ value, arrayKey, arraySize: arraySize2, arrayValues = this.arrayValues }) {
+  const component = this.svComponent;
+  const addDiagnostic = component.coreFunctions.addDiagnostic;
+  const numDimensions = this.numDimensions;
+  let index2 = this.keyToIndex(arrayKey);
+  let numDimensionsInArrayKey = index2.length;
+  if (numDimensionsInArrayKey > numDimensions) {
+    addDiagnostic({
+      type: "info",
+      message: "Cannot set array value.  Number of dimensions is too large.",
+      position: component.position,
+      sourceDoc: component.sourceDoc
+    });
+    return { nFailures: 1 };
+  }
+  let arrayValuesDrillDown = arrayValues;
+  let arraySizeDrillDown = arraySize2;
+  for (let indComponent of index2.slice(0, index2.length - 1)) {
+    if (indComponent >= 0 && indComponent < arraySizeDrillDown[0]) {
+      if (!arrayValuesDrillDown[indComponent]) {
+        arrayValuesDrillDown[indComponent] = [];
+      }
+      arrayValuesDrillDown = arrayValuesDrillDown[indComponent];
+      arraySizeDrillDown = arraySizeDrillDown.slice(1);
+    } else {
+      addDiagnostic({
+        type: "info",
+        message: "ignore setting array value out of bounds",
+        position: component.position,
+        sourceDoc: component.sourceDoc
+      });
+      return { nFailures: 1 };
+    }
+  }
+  let nFailures = 0;
+  if (numDimensionsInArrayKey < numDimensions) {
+    let setArrayValuesPiece = function(desiredValue, arrayValuesPiece, arraySizePiece) {
+      if (!Array.isArray(desiredValue)) {
+        addDiagnostic({
+          type: "info",
+          message: "ignoring array values with insufficient dimensions",
+          position: component.position,
+          sourceDoc: component.sourceDoc
+        });
+        return { nFailures: 1 };
+      }
+      let nFailuresSub = 0;
+      let currentSize = arraySizePiece[0];
+      if (desiredValue.length > currentSize) {
+        addDiagnostic({
+          type: "info",
+          message: "ignoring array values out of bounds",
+          position: component.position,
+          sourceDoc: component.sourceDoc
+        });
+        nFailuresSub += desiredValue.length - currentSize;
+        desiredValue = desiredValue.slice(0, currentSize);
+      }
+      if (arraySizePiece.length === 1) {
+        for (let [ind, val] of desiredValue.entries()) {
+          arrayValuesPiece[ind] = val;
+        }
+      } else {
+        for (let [ind, val] of desiredValue.entries()) {
+          if (!arrayValuesPiece[ind]) {
+            arrayValuesPiece[ind] = [];
+          }
+          let result22 = setArrayValuesPiece(
+            val,
+            arrayValuesPiece[ind],
+            arraySizePiece.slice(1)
+          );
+          nFailuresSub += result22.nFailures;
+        }
+      }
+      return { nFailures: nFailuresSub };
+    };
+    let result2 = setArrayValuesPiece(
+      value,
+      arrayValuesDrillDown,
+      arraySizeDrillDown
+    );
+    nFailures += result2.nFailures;
+  } else {
+    arrayValuesDrillDown[index2[index2.length - 1]] = value;
+  }
+  return { nFailures };
+}
+function oneDimSetArrayValue({ value, arrayKey, arraySize: arraySize2, arrayValues = this.arrayValues }) {
+  let ind = this.keyToIndex(arrayKey);
+  if (ind >= 0 && ind < arraySize2[0]) {
+    arrayValues[ind] = value;
+    return { nFailures: 0 };
+  } else {
+    const component = this.svComponent;
+    component.coreFunctions.addDiagnostic({
+      type: "info",
+      message: `Ignoring setting array values out of bounds: ${arrayKey} of ${this.svVarName}`,
+      position: component.position,
+      sourceDoc: component.sourceDoc
+    });
+    return { nFailures: 1 };
+  }
+}
+function multiDimGetArrayValue({ arrayKey, arrayValues = this.arrayValues }) {
+  let index2 = this.keyToIndex(arrayKey);
+  let aVals = arrayValues;
+  for (let indComponent of index2.slice(0, index2.length - 1)) {
+    aVals = aVals[indComponent];
+    if (!aVals) {
+      return void 0;
+    }
+  }
+  return aVals[index2[index2.length - 1]];
+}
+function oneDimGetArrayValue({ arrayKey, arrayValues = this.arrayValues }) {
+  return arrayValues[arrayKey];
+}
+function multiDimGetAllArrayKeys(arraySize2, flatten2 = true, desiredSize) {
+  function prependToAllKeys(keys2, newStuff) {
+    for (let [ind, key] of keys2.entries()) {
+      if (Array.isArray(key)) {
+        prependToAllKeys(key, newStuff);
+      } else {
+        keys2[ind] = newStuff + "," + key;
+      }
+    }
+  }
+  function getAllArrayKeysSub(subArraySize) {
+    if (subArraySize.length === 1) {
+      return Array.from(Array(subArraySize[0]), (_2, i2) => String(i2));
+    } else {
+      let currentSize = subArraySize[0];
+      let subSubKeys = getAllArrayKeysSub(subArraySize.slice(1));
+      let subKeys = [];
+      for (let ind = 0; ind < currentSize; ind++) {
+        if (flatten2) {
+          subKeys.push(...subSubKeys.map((x2) => ind + "," + x2));
+        } else {
+          let newSubSubKeys = deepClone(subSubKeys);
+          prependToAllKeys(newSubSubKeys, ind);
+          subKeys.push(newSubSubKeys);
+        }
+      }
+      return subKeys;
+    }
+  }
+  if (desiredSize) {
+    if (desiredSize.length === 0) {
+      return [];
+    } else {
+      return getAllArrayKeysSub(desiredSize);
+    }
+  } else if (!arraySize2 || arraySize2.length === 0) {
+    return [];
+  } else {
+    return getAllArrayKeysSub(arraySize2);
+  }
+}
+function oneDimGetAllArrayKeys(arraySize2, flatten2, desiredSize) {
+  if (desiredSize) {
+    if (desiredSize.length === 0) {
+      return [];
+    } else {
+      return Array.from(Array(desiredSize[0]), (_2, i2) => String(i2));
+    }
+  } else if (!arraySize2 || arraySize2.length === 0) {
+    return [];
+  } else {
+    return Array.from(Array(arraySize2[0]), (_2, i2) => String(i2));
+  }
+}
+function defaultMultiDimArrayVarNameFromArrayKey(arrayKey) {
+  return this.entryPrefixes[0] + arrayKey.split(",").map((x2) => Number(x2) + 1).join("_");
+}
+function defaultOneDimArrayVarNameFromArrayKey(arrayKey) {
+  return this.entryPrefixes[0] + String(Number(arrayKey) + 1);
+}
+async function multiDimAdjustArrayToNewArraySize() {
+  function resizeSubArray(subArray, subArraySize) {
+    subArray.length = subArraySize[0];
+    if (subArraySize.length > 1) {
+      let subSubArraySize = subArraySize.slice(1);
+      for (let [ind, subSubArray] of subArray.entries()) {
+        if (!subSubArray) {
+          subSubArray = subArray[ind] = [];
+        }
+        resizeSubArray(subSubArray, subSubArraySize);
+      }
+    }
+  }
+  let arraySize2 = await this.arraySize;
+  resizeSubArray(this.arrayValues, arraySize2);
+}
+async function oneDimAdjustArrayToNewArraySize() {
+  let arraySize2 = await this.arraySize;
+  this.arrayValues.length = arraySize2[0];
+}
+function resolveArrayStateVarObj(svObj) {
+  return svObj.isArrayEntry ? svObj.svComponent.state[svObj.arrayStateVariable] : svObj;
+}
+function defaultReturnWrappingComponents(prefix) {
+  return [];
+}
+async function arrayReturnDependencies(args) {
+  const arrayStateVarObj = resolveArrayStateVarObj(this);
+  const component = arrayStateVarObj.svComponent;
+  const arrayVarName = arrayStateVarObj.svVarName;
+  args.arraySize = await arrayStateVarObj.arraySize;
+  for (let key in args.stateValues) {
+    if (key.slice(0, 8) === "__array_") {
+      delete args.stateValues[key];
+    }
+  }
+  if (args.arrayKeys === void 0) {
+    args.arrayKeys = arrayStateVarObj.getAllArrayKeys(args.arraySize);
+  }
+  if (!arrayStateVarObj.dependencyNames) {
+    arrayStateVarObj.dependencyNames = {
+      namesByKey: {},
+      keysByName: {},
+      global: []
+    };
+    if (arrayStateVarObj.additionalStateVariablesDefined) {
+      for (let vName of arrayStateVarObj.additionalStateVariablesDefined) {
+        component.state[vName].dependencyNames = arrayStateVarObj.dependencyNames;
+      }
+    }
+  }
+  let dependencies2 = {};
+  if (arrayStateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
+    const allStateVariablesAffected = [
+      arrayVarName,
+      ...arrayStateVarObj.additionalStateVariablesDefined ?? []
+    ];
+    for (let arrayKey of args.arrayKeys) {
+      for (let vName of allStateVariablesAffected) {
+        let sObj = component.state[vName];
+        dependencies2[vName + "_" + arrayKey] = {
+          dependencyType: "stateVariable",
+          variableName: sObj.arrayVarNameFromArrayKey(arrayKey)
+        };
+      }
+    }
+  } else {
+    let arrayDependencies = arrayStateVarObj.returnArrayDependenciesByKey(args);
+    if (arrayDependencies.globalDependencies) {
+      arrayStateVarObj.dependencyNames.global = Object.keys(
+        arrayDependencies.globalDependencies
+      );
+      Object.assign(dependencies2, arrayDependencies.globalDependencies);
+    }
+    if (!arrayDependencies.dependenciesByKey) {
+      arrayDependencies.dependenciesByKey = {};
+    }
+    for (let arrayKey of args.arrayKeys) {
+      if (!(arrayKey in arrayStateVarObj.dependencyNames.namesByKey)) {
+        args.changedDependency = true;
+      }
+      arrayStateVarObj.dependencyNames.namesByKey[arrayKey] = {};
+      for (let depName in arrayDependencies.dependenciesByKey[arrayKey]) {
+        let extendedDepName = "__" + arrayKey + "_" + depName;
+        dependencies2[extendedDepName] = arrayDependencies.dependenciesByKey[arrayKey][depName];
+        arrayStateVarObj.dependencyNames.namesByKey[arrayKey][depName] = extendedDepName;
+        if (!arrayStateVarObj.dependencyNames.keysByName[extendedDepName]) {
+          arrayStateVarObj.dependencyNames.keysByName[extendedDepName] = [];
+        }
+        if (!arrayStateVarObj.dependencyNames.keysByName[extendedDepName].includes(arrayKey)) {
+          arrayStateVarObj.dependencyNames.keysByName[extendedDepName].push(arrayKey);
+        }
+      }
+    }
+    arrayStateVarObj.dependencyNames.global.push("__array_size");
+  }
+  dependencies2.__array_size = {
+    dependencyType: "stateVariable",
+    variableName: arrayStateVarObj.arraySizeStateVariable
+  };
+  return dependencies2;
+}
+function arrayGetCurrentFreshness({ freshnessInfo, arrayKeys, arraySize: arraySize2 }) {
+  const arrayStateVarObj = resolveArrayStateVarObj(this);
+  const arrayVarName = arrayStateVarObj.svVarName;
+  if (arrayKeys === void 0) {
+    arrayKeys = arrayStateVarObj.getAllArrayKeys(arraySize2);
+  }
+  let freshByKey = freshnessInfo.freshByKey;
+  let numberFresh = freshnessInfo.freshArraySize ? 1 : 0;
+  for (let arrayKey of arrayKeys) {
+    if (freshByKey[arrayKey]) {
+      numberFresh += 1;
+    }
+  }
+  if (numberFresh > 0) {
+    if (numberFresh === arrayKeys.length + 1) {
+      return { fresh: { [arrayVarName]: true } };
+    } else {
+      return { partiallyFresh: { [arrayVarName]: numberFresh } };
+    }
+  } else {
+    return { fresh: { [arrayVarName]: false } };
+  }
+}
+function arrayMarkStale({ freshnessInfo, changes, arrayKeys, arraySize: arraySize2 }) {
+  const arrayStateVarObj = resolveArrayStateVarObj(this);
+  const arrayVarName = arrayStateVarObj.svVarName;
+  let result2 = {};
+  if (arrayKeys === void 0) {
+    arrayKeys = arrayStateVarObj.getAllArrayKeys(arraySize2);
+  }
+  if (arrayStateVarObj.markStaleByKey) {
+    result2 = arrayStateVarObj.markStaleByKey({ arrayKeys, changes });
+  }
+  let freshByKey = freshnessInfo.freshByKey;
+  if (changes.__array_size) {
+    freshnessInfo.freshArraySize = false;
+    freshnessInfo.freshByKey = {};
+    result2.fresh = { [arrayVarName]: false };
+    return result2;
+  }
+  if (Object.keys(freshByKey).length === 0) {
+    freshnessInfo.freshByKey = {};
+    if (freshnessInfo.freshArraySize) {
+      result2.partiallyFresh = { [arrayVarName]: 1 };
+      return result2;
+    } else {
+      result2.fresh = { [arrayVarName]: false };
+      return result2;
+    }
+  }
+  for (let changeName in changes) {
+    if (arrayStateVarObj.dependencyNames.global.includes(changeName)) {
+      freshnessInfo.freshByKey = {};
+      if (freshnessInfo.freshArraySize) {
+        result2.partiallyFresh = { [arrayVarName]: 1 };
+        return result2;
+      } else {
+        result2.fresh = { [arrayVarName]: false };
+        return result2;
+      }
+    }
+    if (arrayStateVarObj.basedOnArrayKeyStateVariables && arrayKeys.length > 1) {
+      delete freshByKey[changeName];
+    } else {
+      for (let key of arrayStateVarObj.dependencyNames.keysByName[changeName]) {
+        delete freshByKey[key];
+      }
+    }
+  }
+  let numberFresh = freshnessInfo.freshArraySize ? 1 : 0;
+  for (let arrayKey of arrayKeys) {
+    if (freshByKey[arrayKey]) {
+      numberFresh += 1;
+    }
+  }
+  if (numberFresh > 0) {
+    if (numberFresh === arrayKeys.length + 1) {
+      result2.fresh = { [arrayVarName]: true };
+      return result2;
+    } else {
+      result2.partiallyFresh = { [arrayVarName]: numberFresh };
+      return result2;
+    }
+  } else {
+    result2.fresh = { [arrayVarName]: false };
+    return result2;
+  }
+}
+function arrayFreshenOnNoChanges({ arrayKeys, freshnessInfo, arraySize: arraySize2 }) {
+  const arrayStateVarObj = resolveArrayStateVarObj(this);
+  let freshByKey = freshnessInfo.freshByKey;
+  if (arrayKeys === void 0) {
+    arrayKeys = arrayStateVarObj.getAllArrayKeys(arraySize2);
+  }
+  for (let arrayKey of arrayKeys) {
+    freshByKey[arrayKey] = true;
+  }
+}
+function extractArrayDependencies(arrayStateVarObj, dependencyValues, arrayKeys, usedDefault) {
+  let globalDependencyValues = {};
+  let globalUsedDefault = {};
+  for (let dependencyName of arrayStateVarObj.dependencyNames.global) {
+    globalDependencyValues[dependencyName] = dependencyValues[dependencyName];
+    globalUsedDefault[dependencyName] = usedDefault[dependencyName];
+  }
+  let dependencyValuesByKey = {};
+  let usedDefaultByKey = {};
+  let foundAllDependencyValuesForKey = {};
+  for (let arrayKey of arrayKeys) {
+    dependencyValuesByKey[arrayKey] = {};
+    usedDefaultByKey[arrayKey] = {};
+    if (arrayKey in arrayStateVarObj.dependencyNames.namesByKey) {
+      foundAllDependencyValuesForKey[arrayKey] = true;
+      for (let dependencyName in arrayStateVarObj.dependencyNames.namesByKey[arrayKey]) {
+        let extendedDepName = arrayStateVarObj.dependencyNames.namesByKey[arrayKey][dependencyName];
+        if (extendedDepName in dependencyValues) {
+          dependencyValuesByKey[arrayKey][dependencyName] = dependencyValues[extendedDepName];
+          usedDefaultByKey[arrayKey][dependencyName] = usedDefault[extendedDepName];
+        } else {
+          foundAllDependencyValuesForKey[arrayKey] = false;
+        }
+      }
+    }
+  }
+  return {
+    globalDependencyValues,
+    globalUsedDefault,
+    dependencyValuesByKey,
+    usedDefaultByKey,
+    foundAllDependencyValuesForKey
+  };
+}
+function arrayDefinition(args) {
+  const arrayStateVarObj = resolveArrayStateVarObj(this);
+  const arrayVarName = arrayStateVarObj.svVarName;
+  const component = arrayStateVarObj.svComponent;
+  if (args.arrayKeys === void 0) {
+    args.arrayKeys = arrayStateVarObj.getAllArrayKeys(args.arraySize);
+  }
+  if (arrayStateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
+    return {};
+  } else {
+    let extractedDeps = extractArrayDependencies(
+      arrayStateVarObj,
+      args.dependencyValues,
+      args.arrayKeys,
+      args.usedDefault
+    );
+    let globalDependencyValues = extractedDeps.globalDependencyValues;
+    let globalUsedDefault = extractedDeps.globalUsedDefault;
+    let dependencyValuesByKey = extractedDeps.dependencyValuesByKey;
+    let usedDefaultByKey = extractedDeps.usedDefaultByKey;
+    let foundAllDependencyValuesForKey = extractedDeps.foundAllDependencyValuesForKey;
+    delete args.dependencyValues;
+    args.globalDependencyValues = globalDependencyValues;
+    args.globalUsedDefault = globalUsedDefault;
+    args.dependencyValuesByKey = dependencyValuesByKey;
+    args.usedDefaultByKey = usedDefaultByKey;
+    let arrayKeysToRecalculate = [];
+    let freshByKey = args.freshnessInfo.freshByKey;
+    for (let arrayKey of args.arrayKeys) {
+      if (!freshByKey[arrayKey] && foundAllDependencyValuesForKey[arrayKey]) {
+        freshByKey[arrayKey] = true;
+        arrayKeysToRecalculate.push(arrayKey);
+      }
+    }
+    let result2;
+    if (arrayKeysToRecalculate.length === 0) {
+      result2 = {};
+    } else {
+      args.arrayKeys = arrayKeysToRecalculate;
+      if (!arrayStateVarObj.arrayDefinitionByKey) {
+        throw Error(
+          `For ${arrayVarName} of ${component.componentType}, arrayDefinitionByKey must be a function`
+        );
+      }
+      result2 = arrayStateVarObj.arrayDefinitionByKey(args);
+      if (result2.setValue && result2.setValue[arrayVarName]) {
+        for (let arrayKey in result2.setValue[arrayVarName]) {
+          freshByKey[arrayKey] = true;
+        }
+      }
+      if (result2.useEssentialOrDefaultValue && result2.useEssentialOrDefaultValue[arrayVarName]) {
+        for (let arrayKey in result2.useEssentialOrDefaultValue[arrayVarName]) {
+          freshByKey[arrayKey] = true;
+        }
+      }
+    }
+    if (!args.freshnessInfo.freshArraySize) {
+      if (args.changes.__array_size) {
+        result2.arraySizeChanged = [arrayVarName];
+        if (arrayStateVarObj.additionalStateVariablesDefined) {
+          for (let varName of arrayStateVarObj.additionalStateVariablesDefined) {
+            if (component.state[varName].isArray) {
+              result2.arraySizeChanged.push(varName);
+            }
+          }
+        }
+      }
+      args.freshnessInfo.freshArraySize = true;
+    }
+    return result2;
+  }
+}
+function arrayInverseDefinition(args) {
+  const arrayStateVarObj = resolveArrayStateVarObj(this);
+  const arrayVarName = arrayStateVarObj.svVarName;
+  if (!arrayStateVarObj.inverseArrayDefinitionByKey) {
+    return { success: false };
+  }
+  if (args.arrayKeys === void 0) {
+    args.arrayKeys = arrayStateVarObj.getAllArrayKeys(args.arraySize);
+  }
+  if (arrayStateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
+    const allStateVariablesAffected = [
+      arrayVarName,
+      ...arrayStateVarObj.additionalStateVariablesDefined ?? []
+    ];
+    let instructions = [];
+    for (let vName of allStateVariablesAffected) {
+      for (let key in args.desiredStateVariableValues[vName]) {
+        let depName = vName + "_" + key;
+        if (depName in args.dependencyValues) {
+          instructions.push({
+            setDependency: depName,
+            desiredValue: args.desiredStateVariableValues[vName][key],
+            treatAsInitialChange: args.initialChange
+          });
+        }
+      }
+    }
+    return {
+      success: true,
+      instructions
+    };
+  } else {
+    let extractedDeps = extractArrayDependencies(
+      arrayStateVarObj,
+      args.dependencyValues,
+      args.arrayKeys,
+      args.usedDefault
+    );
+    let globalDependencyValues = extractedDeps.globalDependencyValues;
+    let globalUsedDefault = extractedDeps.globalUsedDefault;
+    let dependencyValuesByKey = extractedDeps.dependencyValuesByKey;
+    let usedDefaultByKey = extractedDeps.usedDefaultByKey;
+    delete args.dependencyValues;
+    args.globalDependencyValues = globalDependencyValues;
+    args.globalUsedDefault = globalUsedDefault;
+    args.dependencyValuesByKey = dependencyValuesByKey;
+    args.usedDefaultByKey = usedDefaultByKey;
+    args.dependencyNamesByKey = arrayStateVarObj.dependencyNames.namesByKey;
+    if (!arrayStateVarObj.allowExtraArrayKeysInInverse) {
+      let newDesiredStateVariableValues = {};
+      for (let vName in args.desiredStateVariableValues) {
+        newDesiredStateVariableValues[vName] = {};
+        for (let key in args.desiredStateVariableValues[vName]) {
+          if (args.arrayKeys.includes(key)) {
+            newDesiredStateVariableValues[vName][key] = args.desiredStateVariableValues[vName][key];
+          }
+        }
+      }
+      args.desiredStateVariableValues = newDesiredStateVariableValues;
+    }
+    let result2 = arrayStateVarObj.inverseArrayDefinitionByKey(args);
+    return result2;
+  }
+}
+function getArrayArraySize() {
+  return (async () => {
+    if (!this.svComponent.state[this.arraySizeStateVariable].initiallyResolved) {
+      return [];
+    }
+    if (this.arraySizeStale) {
+      await this.recalculateArraySizeDependentQuantities();
+    }
+    return await this.svComponent.stateValues[this.arraySizeStateVariable];
+  })();
+}
+const ARRAY_ARRAY_SIZE_DESCRIPTOR = Object.freeze({
+  get: getArrayArraySize
+});
+function arraySizeDefinition({ dependencyValues }) {
+  let arraySize2 = this.svComponent.state[this.arraySizeSourceVarName].returnArraySize({
+    dependencyValues
+  });
+  for (let [ind, value] of arraySize2.entries()) {
+    if (!(Number.isInteger(value) && value >= 0)) {
+      arraySize2[ind] = 0;
+    }
+  }
+  return { setValue: { [this.svVarName]: arraySize2 } };
+}
+function arraySizeMarkStale() {
+  for (let varName of this.arraySizeVarNamesAffected) {
+    this.svComponent.state[varName].arraySizeStale = true;
+  }
+  return {};
+}
+async function arrayRecalculateArraySizeDependentQuantities() {
+  const component = this.svComponent;
+  let newArraySize = await component.stateValues[this.arraySizeStateVariable];
+  if (this.previousArraySize.length !== newArraySize.length || this.previousArraySize.some((v2, i2) => v2 != newArraySize[i2])) {
+    this.previousArraySize = [...newArraySize];
+    let varNamesIncluding = this.varNamesIncludingArrayKeys = {};
+    for (let entryName of this.arrayEntryNames) {
+      let entryStateVarObj = component.state[entryName];
+      let arrayKeys = this.getArrayKeysFromVarName({
+        arrayEntryPrefix: entryStateVarObj.entryPrefix,
+        varEnding: entryStateVarObj.varEnding,
+        arraySize: newArraySize,
+        numDimensions: this.numDimensions
+      });
+      entryStateVarObj._unflattenedArrayKeys = arrayKeys;
+      entryStateVarObj._arrayKeys = flattenDeep(arrayKeys);
+      for (let arrayKey of entryStateVarObj._arrayKeys) {
+        if (!varNamesIncluding[arrayKey]) {
+          varNamesIncluding[arrayKey] = [];
+        }
+        varNamesIncluding[arrayKey].push(entryName);
+      }
+    }
+  }
+  this.arraySizeStale = false;
+}
+async function entryReturnDependencies(args) {
+  const arrayStateVarObj = this.svComponent.state[this.arrayStateVariable];
+  args.arraySize = await this.arraySize;
+  args.arrayKeys = await this.arrayKeys;
+  let dependencies2 = await arrayStateVarObj.returnDependencies(args);
+  let numNames = Object.keys(
+    arrayStateVarObj.dependencyNames.namesByKey
+  ).length;
+  if (this.numberNamesInPreviousReturnDep !== numNames) {
+    args.changedDependency = true;
+  }
+  this.numberNamesInPreviousReturnDep = numNames;
+  return dependencies2;
+}
 async function initializeComponentStateVariables({
   core: core2,
   component
@@ -50833,16 +51538,14 @@ async function initializeStateVariable({
   arrayStateVariable,
   arrayEntryPrefix
 }) {
-  let getStateVar = core2.getStateVariableValue;
   if (!component.state[stateVariable]) {
     component.state[stateVariable] = {};
   }
   let stateVarObj = component.state[stateVariable];
+  stateVarObj.svComponent = component;
+  stateVarObj.svVarName = stateVariable;
   stateVarObj.isResolved = false;
-  Object.defineProperty(stateVarObj, "value", {
-    get: () => getStateVar({ component, stateVariable }),
-    configurable: true
-  });
+  installStaleValueGetter(stateVarObj);
   if (arrayEntryPrefix !== void 0) {
     await initializeArrayEntryStateVariable({
       stateVarObj,
@@ -50931,47 +51634,23 @@ async function initializeArrayEntryStateVariable({
     }
   }
   if (arrayStateVarObj.getEntryValues) {
-    stateVarObj.getValueFromArrayValues = async function() {
-      return await arrayStateVarObj.getEntryValues({
-        varName: stateVariable
-      });
-    };
+    stateVarObj.getValueFromArrayValues = entryGetValueViaGetEntryValues;
   } else {
-    stateVarObj.getValueFromArrayValues = async function() {
-      let arrayKeys = await stateVarObj.arrayKeys;
-      if (arrayKeys.length === 0) {
-        return;
-      }
-      let value = [];
-      for (let arrayKey of arrayKeys) {
-        value.push(arrayStateVarObj.getArrayValue({ arrayKey }));
-      }
-      if (value.length === 1) {
-        return value[0];
-      } else {
-        return value;
-      }
-    };
+    stateVarObj.getValueFromArrayValues = entryGetValueFromArrayValues;
   }
   stateVarObj.arraySizeStateVariable = arrayStateVarObj.arraySizeStateVariable;
   stateVarObj._arrayKeys = [];
   stateVarObj._unflattenedArrayKeys = [];
-  Object.defineProperty(stateVarObj, "arrayKeys", {
-    get: function() {
-      return (async () => {
-        await arrayStateVarObj.arraySize;
-        return stateVarObj._arrayKeys;
-      })();
-    }
-  });
-  Object.defineProperty(stateVarObj, "unflattenedArrayKeys", {
-    get: function() {
-      return (async () => {
-        await arrayStateVarObj.arraySize;
-        return stateVarObj._unflattenedArrayKeys;
-      })();
-    }
-  });
+  Object.defineProperty(
+    stateVarObj,
+    "arrayKeys",
+    ENTRY_ARRAY_KEYS_DESCRIPTOR
+  );
+  Object.defineProperty(
+    stateVarObj,
+    "unflattenedArrayKeys",
+    ENTRY_UNFLATTENED_ARRAY_KEYS_DESCRIPTOR
+  );
   if (component.state[stateVarObj.arraySizeStateVariable].initiallyResolved) {
     let arraySize2 = await arrayStateVarObj.arraySize;
     let arrayKeys = arrayStateVarObj.getArrayKeysFromVarName({
@@ -50991,24 +51670,16 @@ async function initializeArrayEntryStateVariable({
     }
   }
   arrayStateVarObj.arrayEntryNames.push(stateVariable);
-  Object.defineProperty(stateVarObj, "arraySize", {
-    get: () => arrayStateVarObj.arraySize
-  });
-  Object.defineProperty(stateVarObj, "arrayEntrySize", {
-    get: function() {
-      return (async () => {
-        let unflattenedArrayKeys = await stateVarObj.unflattenedArrayKeys;
-        let arrayEntrySize = [];
-        let subArray = [unflattenedArrayKeys];
-        for (let i2 = 0; i2 < stateVarObj.numDimensions; i2++) {
-          subArray = subArray[0];
-          arrayEntrySize.push(subArray.length);
-        }
-        arrayEntrySize.reverse();
-        return arrayEntrySize;
-      })();
-    }
-  });
+  Object.defineProperty(
+    stateVarObj,
+    "arraySize",
+    ENTRY_ARRAY_SIZE_DESCRIPTOR
+  );
+  Object.defineProperty(
+    stateVarObj,
+    "arrayEntrySize",
+    ENTRY_ARRAY_ENTRY_SIZE_DESCRIPTOR
+  );
   if (arrayStateVarObj.stateVariablesDeterminingDependencies) {
     if (!stateVarObj.stateVariablesDeterminingDependencies) {
       stateVarObj.stateVariablesDeterminingDependencies = [];
@@ -51021,20 +51692,7 @@ async function initializeArrayEntryStateVariable({
       }
     }
   }
-  let arrayReturnDependencies = arrayStateVarObj.returnDependencies.bind(arrayStateVarObj);
-  stateVarObj.returnDependencies = async function(args) {
-    args.arraySize = await stateVarObj.arraySize;
-    args.arrayKeys = await stateVarObj.arrayKeys;
-    let dependencies2 = await arrayReturnDependencies(args);
-    let numNames = Object.keys(
-      arrayStateVarObj.dependencyNames.namesByKey
-    ).length;
-    if (stateVarObj.numberNamesInPreviousReturnDep !== numNames) {
-      args.changedDependency = true;
-    }
-    stateVarObj.numberNamesInPreviousReturnDep = numNames;
-    return dependencies2;
-  };
+  stateVarObj.returnDependencies = entryReturnDependencies;
 }
 async function initializeArrayStateVariable({
   core: core2,
@@ -51057,173 +51715,14 @@ async function initializeArrayStateVariable({
     component.arrayEntryPrefixes[prefix] = stateVariable;
   }
   if (stateVarObj.numDimensions > 1) {
-    stateVarObj.keyToIndex = (key) => key.split(",").map((x2) => Number(x2));
-    stateVarObj.setArrayValue = function({
-      value,
-      arrayKey,
-      arraySize: arraySize2,
-      arrayValues = stateVarObj.arrayValues
-    }) {
-      let index2 = stateVarObj.keyToIndex(arrayKey);
-      let numDimensionsInArrayKey = index2.length;
-      if (numDimensionsInArrayKey > stateVarObj.numDimensions) {
-        core2.addDiagnostic({
-          type: "info",
-          message: "Cannot set array value.  Number of dimensions is too large.",
-          position: component.position,
-          sourceDoc: component.sourceDoc
-        });
-        return { nFailures: 1 };
-      }
-      let arrayValuesDrillDown = arrayValues;
-      let arraySizeDrillDown = arraySize2;
-      for (let indComponent of index2.slice(0, index2.length - 1)) {
-        if (indComponent >= 0 && indComponent < arraySizeDrillDown[0]) {
-          if (!arrayValuesDrillDown[indComponent]) {
-            arrayValuesDrillDown[indComponent] = [];
-          }
-          arrayValuesDrillDown = arrayValuesDrillDown[indComponent];
-          arraySizeDrillDown = arraySizeDrillDown.slice(1);
-        } else {
-          core2.addDiagnostic({
-            type: "info",
-            message: "ignore setting array value out of bounds",
-            position: component.position,
-            sourceDoc: component.sourceDoc
-          });
-          return { nFailures: 1 };
-        }
-      }
-      let nFailures = 0;
-      if (numDimensionsInArrayKey < stateVarObj.numDimensions) {
-        let setArrayValuesPiece = function(desiredValue, arrayValuesPiece, arraySizePiece) {
-          if (!Array.isArray(desiredValue)) {
-            core2.addDiagnostic({
-              type: "info",
-              message: "ignoring array values with insufficient dimensions",
-              position: component.position,
-              sourceDoc: component.sourceDoc
-            });
-            return { nFailures: 1 };
-          }
-          let nFailuresSub = 0;
-          let currentSize = arraySizePiece[0];
-          if (desiredValue.length > currentSize) {
-            core2.addDiagnostic({
-              type: "info",
-              message: "ignoring array values out of bounds",
-              position: component.position,
-              sourceDoc: component.sourceDoc
-            });
-            nFailuresSub += desiredValue.length - currentSize;
-            desiredValue = desiredValue.slice(0, currentSize);
-          }
-          if (arraySizePiece.length === 1) {
-            for (let [
-              ind,
-              val
-            ] of desiredValue.entries()) {
-              arrayValuesPiece[ind] = val;
-            }
-          } else {
-            for (let [
-              ind,
-              val
-            ] of desiredValue.entries()) {
-              if (!arrayValuesPiece[ind]) {
-                arrayValuesPiece[ind] = [];
-              }
-              let result22 = setArrayValuesPiece(
-                val,
-                arrayValuesPiece[ind],
-                arraySizePiece.slice(1)
-              );
-              nFailuresSub += result22.nFailures;
-            }
-          }
-          return { nFailures: nFailuresSub };
-        };
-        let result2 = setArrayValuesPiece(
-          value,
-          arrayValuesDrillDown,
-          arraySizeDrillDown
-        );
-        nFailures += result2.nFailures;
-      } else {
-        arrayValuesDrillDown[index2[index2.length - 1]] = value;
-      }
-      return { nFailures };
-    };
-    stateVarObj.getArrayValue = function({
-      arrayKey,
-      arrayValues = stateVarObj.arrayValues
-    }) {
-      let index2 = stateVarObj.keyToIndex(arrayKey);
-      let aVals = arrayValues;
-      for (let indComponent of index2.slice(0, index2.length - 1)) {
-        aVals = aVals[indComponent];
-        if (!aVals) {
-          return void 0;
-        }
-      }
-      return aVals[index2[index2.length - 1]];
-    };
+    stateVarObj.keyToIndex = multiDimKeyToIndex;
+    stateVarObj.setArrayValue = multiDimSetArrayValue;
+    stateVarObj.getArrayValue = multiDimGetArrayValue;
     if (!stateVarObj.getAllArrayKeys) {
-      stateVarObj.getAllArrayKeys = function(arraySize2, flatten2 = true, desiredSize) {
-        function prependToAllKeys(keys2, newStuff) {
-          for (let [ind, key] of keys2.entries()) {
-            if (Array.isArray(key)) {
-              prependToAllKeys(key, newStuff);
-            } else {
-              keys2[ind] = newStuff + "," + key;
-            }
-          }
-        }
-        function getAllArrayKeysSub(subArraySize) {
-          if (subArraySize.length === 1) {
-            return Array.from(
-              Array(subArraySize[0]),
-              (_2, i2) => String(i2)
-            );
-          } else {
-            let currentSize = subArraySize[0];
-            let subSubKeys = getAllArrayKeysSub(
-              subArraySize.slice(1)
-            );
-            let subKeys = [];
-            for (let ind = 0; ind < currentSize; ind++) {
-              if (flatten2) {
-                subKeys.push(
-                  ...subSubKeys.map(
-                    (x2) => ind + "," + x2
-                  )
-                );
-              } else {
-                let newSubSubKeys = deepClone(subSubKeys);
-                prependToAllKeys(newSubSubKeys, ind);
-                subKeys.push(newSubSubKeys);
-              }
-            }
-            return subKeys;
-          }
-        }
-        if (desiredSize) {
-          if (desiredSize.length === 0) {
-            return [];
-          } else {
-            return getAllArrayKeysSub(desiredSize);
-          }
-        } else if (!arraySize2 || arraySize2.length === 0) {
-          return [];
-        } else {
-          return getAllArrayKeysSub(arraySize2);
-        }
-      };
+      stateVarObj.getAllArrayKeys = multiDimGetAllArrayKeys;
     }
     if (!stateVarObj.arrayVarNameFromArrayKey) {
-      stateVarObj.arrayVarNameFromArrayKey = function(arrayKey) {
-        return entryPrefixes[0] + arrayKey.split(",").map((x2) => Number(x2) + 1).join("_");
-      };
+      stateVarObj.arrayVarNameFromArrayKey = defaultMultiDimArrayVarNameFromArrayKey;
     }
     if (!stateVarObj.arrayVarNameFromPropIndex) {
       stateVarObj.arrayVarNameFromPropIndex = returnDefaultArrayVarNameFromPropIndex(
@@ -51231,443 +51730,44 @@ async function initializeArrayStateVariable({
         entryPrefixes[0]
       );
     }
-    stateVarObj.adjustArrayToNewArraySize = async function() {
-      function resizeSubArray(subArray, subArraySize) {
-        subArray.length = subArraySize[0];
-        if (subArraySize.length > 1) {
-          let subSubArraySize = subArraySize.slice(1);
-          for (let [
-            ind,
-            subSubArray
-          ] of subArray.entries()) {
-            if (!subSubArray) {
-              subSubArray = subArray[ind] = [];
-            }
-            resizeSubArray(subSubArray, subSubArraySize);
-          }
-        }
-      }
-      let arraySize2 = await stateVarObj.arraySize;
-      resizeSubArray(stateVarObj.arrayValues, arraySize2);
-    };
+    stateVarObj.adjustArrayToNewArraySize = multiDimAdjustArrayToNewArraySize;
   } else {
-    stateVarObj.keyToIndex = (key) => Number(key);
-    stateVarObj.setArrayValue = function({
-      value,
-      arrayKey,
-      arraySize: arraySize2,
-      arrayValues = stateVarObj.arrayValues
-    }) {
-      let ind = stateVarObj.keyToIndex(arrayKey);
-      if (ind >= 0 && ind < arraySize2[0]) {
-        arrayValues[ind] = value;
-        return { nFailures: 0 };
-      } else {
-        core2.addDiagnostic({
-          type: "info",
-          message: `Ignoring setting array values out of bounds: ${arrayKey} of ${stateVariable}`,
-          position: component.position,
-          sourceDoc: component.sourceDoc
-        });
-        return { nFailures: 1 };
-      }
-    };
-    stateVarObj.getArrayValue = function({
-      arrayKey,
-      arrayValues = stateVarObj.arrayValues
-    }) {
-      return arrayValues[arrayKey];
-    };
+    stateVarObj.keyToIndex = oneDimKeyToIndex;
+    stateVarObj.setArrayValue = oneDimSetArrayValue;
+    stateVarObj.getArrayValue = oneDimGetArrayValue;
     if (!stateVarObj.getAllArrayKeys) {
-      stateVarObj.getAllArrayKeys = function(arraySize2, flatten2, desiredSize) {
-        if (desiredSize) {
-          if (desiredSize.length === 0) {
-            return [];
-          } else {
-            return Array.from(
-              Array(desiredSize[0]),
-              (_2, i2) => String(i2)
-            );
-          }
-        } else if (!arraySize2 || arraySize2.length === 0) {
-          return [];
-        } else {
-          return Array.from(Array(arraySize2[0]), (_2, i2) => String(i2));
-        }
-      };
+      stateVarObj.getAllArrayKeys = oneDimGetAllArrayKeys;
     }
     if (!stateVarObj.arrayVarNameFromArrayKey) {
-      stateVarObj.arrayVarNameFromArrayKey = function(arrayKey) {
-        return entryPrefixes[0] + String(Number(arrayKey) + 1);
-      };
+      stateVarObj.arrayVarNameFromArrayKey = defaultOneDimArrayVarNameFromArrayKey;
     }
     if (!stateVarObj.arrayVarNameFromPropIndex) {
       stateVarObj.arrayVarNameFromPropIndex = returnDefaultArrayVarNameFromPropIndex(1, entryPrefixes[0]);
     }
-    stateVarObj.adjustArrayToNewArraySize = async function() {
-      let arraySize2 = await stateVarObj.arraySize;
-      stateVarObj.arrayValues.length = arraySize2[0];
-    };
+    stateVarObj.adjustArrayToNewArraySize = oneDimAdjustArrayToNewArraySize;
   }
   if (!stateVarObj.getArrayKeysFromVarName) {
     stateVarObj.getArrayKeysFromVarName = returnDefaultGetArrayKeysFromVarName(stateVarObj.numDimensions);
   }
-  stateVarObj.indexToKey = (index2) => String(index2);
+  stateVarObj.indexToKey = arrayIndexToKey;
   if (!stateVarObj.returnEntryDimensions) {
-    stateVarObj.returnEntryDimensions = () => 0;
+    stateVarObj.returnEntryDimensions = defaultReturnEntryDimensions;
   }
   if (stateVarObj.shadowingInstructions) {
     if (!stateVarObj.shadowingInstructions.returnWrappingComponents) {
-      stateVarObj.shadowingInstructions.returnWrappingComponents = (prefix) => [];
+      stateVarObj.shadowingInstructions.returnWrappingComponents = defaultReturnWrappingComponents;
     }
     stateVarObj.wrappingComponents = stateVarObj.shadowingInstructions.returnWrappingComponents();
   }
   stateVarObj.usedDefaultByArrayKey = {};
   stateVarObj.arrayEntryNames = [];
   stateVarObj.varNamesIncludingArrayKeys = {};
-  let allStateVariablesAffected = [stateVariable];
-  if (stateVarObj.additionalStateVariablesDefined) {
-    allStateVariablesAffected.push(
-      ...stateVarObj.additionalStateVariablesDefined
-    );
-  }
-  stateVarObj.returnDependencies = async function(args) {
-    args.arraySize = await stateVarObj.arraySize;
-    for (let key in args.stateValues) {
-      if (key.slice(0, 8) === "__array_") {
-        delete args.stateValues[key];
-      }
-    }
-    if (args.arrayKeys === void 0) {
-      args.arrayKeys = stateVarObj.getAllArrayKeys(args.arraySize);
-    }
-    if (!stateVarObj.dependencyNames) {
-      stateVarObj.dependencyNames = {
-        namesByKey: {},
-        keysByName: {},
-        global: []
-      };
-      if (stateVarObj.additionalStateVariablesDefined) {
-        for (let vName of stateVarObj.additionalStateVariablesDefined) {
-          component.state[vName].dependencyNames = stateVarObj.dependencyNames;
-        }
-      }
-    }
-    let dependencies2 = {};
-    if (stateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
-      for (let arrayKey of args.arrayKeys) {
-        for (let vName of allStateVariablesAffected) {
-          let sObj = component.state[vName];
-          dependencies2[vName + "_" + arrayKey] = {
-            dependencyType: "stateVariable",
-            variableName: sObj.arrayVarNameFromArrayKey(arrayKey)
-          };
-        }
-      }
-    } else {
-      let arrayDependencies = stateVarObj.returnArrayDependenciesByKey(args);
-      if (arrayDependencies.globalDependencies) {
-        stateVarObj.dependencyNames.global = Object.keys(
-          arrayDependencies.globalDependencies
-        );
-        Object.assign(
-          dependencies2,
-          arrayDependencies.globalDependencies
-        );
-      }
-      if (!arrayDependencies.dependenciesByKey) {
-        arrayDependencies.dependenciesByKey = {};
-      }
-      for (let arrayKey of args.arrayKeys) {
-        if (!(arrayKey in stateVarObj.dependencyNames.namesByKey)) {
-          args.changedDependency = true;
-        }
-        stateVarObj.dependencyNames.namesByKey[arrayKey] = {};
-        for (let depName in arrayDependencies.dependenciesByKey[arrayKey]) {
-          let extendedDepName = "__" + arrayKey + "_" + depName;
-          dependencies2[extendedDepName] = arrayDependencies.dependenciesByKey[arrayKey][depName];
-          stateVarObj.dependencyNames.namesByKey[arrayKey][depName] = extendedDepName;
-          if (!stateVarObj.dependencyNames.keysByName[extendedDepName]) {
-            stateVarObj.dependencyNames.keysByName[extendedDepName] = [];
-          }
-          if (!stateVarObj.dependencyNames.keysByName[extendedDepName].includes(arrayKey)) {
-            stateVarObj.dependencyNames.keysByName[extendedDepName].push(arrayKey);
-          }
-        }
-      }
-      stateVarObj.dependencyNames.global.push("__array_size");
-    }
-    dependencies2.__array_size = {
-      dependencyType: "stateVariable",
-      variableName: stateVarObj.arraySizeStateVariable
-    };
-    return dependencies2;
-  };
-  stateVarObj.getCurrentFreshness = function({
-    freshnessInfo,
-    arrayKeys,
-    arraySize: arraySize2
-  }) {
-    if (arrayKeys === void 0) {
-      arrayKeys = stateVarObj.getAllArrayKeys(arraySize2);
-    }
-    let freshByKey = freshnessInfo.freshByKey;
-    let numberFresh = freshnessInfo.freshArraySize ? 1 : 0;
-    for (let arrayKey of arrayKeys) {
-      if (freshByKey[arrayKey]) {
-        numberFresh += 1;
-      }
-    }
-    if (numberFresh > 0) {
-      if (numberFresh === arrayKeys.length + 1) {
-        return { fresh: { [stateVariable]: true } };
-      } else {
-        return { partiallyFresh: { [stateVariable]: numberFresh } };
-      }
-    } else {
-      return { fresh: { [stateVariable]: false } };
-    }
-  };
-  stateVarObj.markStale = function({
-    freshnessInfo,
-    changes,
-    arrayKeys,
-    arraySize: arraySize2
-  }) {
-    let result2 = {};
-    if (arrayKeys === void 0) {
-      arrayKeys = stateVarObj.getAllArrayKeys(arraySize2);
-    }
-    if (stateVarObj.markStaleByKey) {
-      result2 = stateVarObj.markStaleByKey({ arrayKeys, changes });
-    }
-    let freshByKey = freshnessInfo.freshByKey;
-    if (changes.__array_size) {
-      freshnessInfo.freshArraySize = false;
-      freshnessInfo.freshByKey = {};
-      result2.fresh = { [stateVariable]: false };
-      return result2;
-    }
-    if (Object.keys(freshByKey).length === 0) {
-      freshnessInfo.freshByKey = {};
-      if (freshnessInfo.freshArraySize) {
-        result2.partiallyFresh = { [stateVariable]: 1 };
-        return result2;
-      } else {
-        result2.fresh = { [stateVariable]: false };
-        return result2;
-      }
-    }
-    for (let changeName in changes) {
-      if (stateVarObj.dependencyNames.global.includes(changeName)) {
-        freshnessInfo.freshByKey = {};
-        if (freshnessInfo.freshArraySize) {
-          result2.partiallyFresh = { [stateVariable]: 1 };
-          return result2;
-        } else {
-          result2.fresh = { [stateVariable]: false };
-          return result2;
-        }
-      }
-      if (stateVarObj.basedOnArrayKeyStateVariables && arrayKeys.length > 1) {
-        delete freshByKey[changeName];
-      } else {
-        for (let key of stateVarObj.dependencyNames.keysByName[changeName]) {
-          delete freshByKey[key];
-        }
-      }
-    }
-    let numberFresh = freshnessInfo.freshArraySize ? 1 : 0;
-    for (let arrayKey of arrayKeys) {
-      if (freshByKey[arrayKey]) {
-        numberFresh += 1;
-      }
-    }
-    if (numberFresh > 0) {
-      if (numberFresh === arrayKeys.length + 1) {
-        result2.fresh = { [stateVariable]: true };
-        return result2;
-      } else {
-        result2.partiallyFresh = { [stateVariable]: numberFresh };
-        return result2;
-      }
-    } else {
-      result2.fresh = { [stateVariable]: false };
-      return result2;
-    }
-  };
-  stateVarObj.freshenOnNoChanges = function({
-    arrayKeys,
-    freshnessInfo,
-    arraySize: arraySize2
-  }) {
-    let freshByKey = freshnessInfo.freshByKey;
-    if (arrayKeys === void 0) {
-      arrayKeys = stateVarObj.getAllArrayKeys(arraySize2);
-    }
-    for (let arrayKey of arrayKeys) {
-      freshByKey[arrayKey] = true;
-    }
-  };
-  function extractArrayDependencies(dependencyValues, arrayKeys, usedDefault) {
-    let globalDependencyValues = {};
-    let globalUsedDefault = {};
-    for (let dependencyName of stateVarObj.dependencyNames.global) {
-      globalDependencyValues[dependencyName] = dependencyValues[dependencyName];
-      globalUsedDefault[dependencyName] = usedDefault[dependencyName];
-    }
-    let dependencyValuesByKey = {};
-    let usedDefaultByKey = {};
-    let foundAllDependencyValuesForKey = {};
-    for (let arrayKey of arrayKeys) {
-      dependencyValuesByKey[arrayKey] = {};
-      usedDefaultByKey[arrayKey] = {};
-      if (arrayKey in stateVarObj.dependencyNames.namesByKey) {
-        foundAllDependencyValuesForKey[arrayKey] = true;
-        for (let dependencyName in stateVarObj.dependencyNames.namesByKey[arrayKey]) {
-          let extendedDepName = stateVarObj.dependencyNames.namesByKey[arrayKey][dependencyName];
-          if (extendedDepName in dependencyValues) {
-            dependencyValuesByKey[arrayKey][dependencyName] = dependencyValues[extendedDepName];
-            usedDefaultByKey[arrayKey][dependencyName] = usedDefault[extendedDepName];
-          } else {
-            foundAllDependencyValuesForKey[arrayKey] = false;
-          }
-        }
-      }
-    }
-    return {
-      globalDependencyValues,
-      globalUsedDefault,
-      dependencyValuesByKey,
-      usedDefaultByKey,
-      foundAllDependencyValuesForKey
-    };
-  }
-  stateVarObj.definition = function(args) {
-    if (args.arrayKeys === void 0) {
-      args.arrayKeys = stateVarObj.getAllArrayKeys(args.arraySize);
-    }
-    if (stateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
-      return {};
-    } else {
-      let extractedDeps = extractArrayDependencies(
-        args.dependencyValues,
-        args.arrayKeys,
-        args.usedDefault
-      );
-      let globalDependencyValues = extractedDeps.globalDependencyValues;
-      let globalUsedDefault = extractedDeps.globalUsedDefault;
-      let dependencyValuesByKey = extractedDeps.dependencyValuesByKey;
-      let usedDefaultByKey = extractedDeps.usedDefaultByKey;
-      let foundAllDependencyValuesForKey = extractedDeps.foundAllDependencyValuesForKey;
-      delete args.dependencyValues;
-      args.globalDependencyValues = globalDependencyValues;
-      args.globalUsedDefault = globalUsedDefault;
-      args.dependencyValuesByKey = dependencyValuesByKey;
-      args.usedDefaultByKey = usedDefaultByKey;
-      let arrayKeysToRecalculate = [];
-      let freshByKey = args.freshnessInfo.freshByKey;
-      for (let arrayKey of args.arrayKeys) {
-        if (!freshByKey[arrayKey] && foundAllDependencyValuesForKey[arrayKey]) {
-          freshByKey[arrayKey] = true;
-          arrayKeysToRecalculate.push(arrayKey);
-        }
-      }
-      let result2;
-      if (arrayKeysToRecalculate.length === 0) {
-        result2 = {};
-      } else {
-        args.arrayKeys = arrayKeysToRecalculate;
-        if (!stateVarObj.arrayDefinitionByKey) {
-          throw Error(
-            `For ${stateVariable} of ${component.componentType}, arrayDefinitionByKey must be a function`
-          );
-        }
-        result2 = stateVarObj.arrayDefinitionByKey(args);
-        if (result2.setValue && result2.setValue[stateVariable]) {
-          for (let arrayKey in result2.setValue[stateVariable]) {
-            freshByKey[arrayKey] = true;
-          }
-        }
-        if (result2.useEssentialOrDefaultValue && result2.useEssentialOrDefaultValue[stateVariable]) {
-          for (let arrayKey in result2.useEssentialOrDefaultValue[stateVariable]) {
-            freshByKey[arrayKey] = true;
-          }
-        }
-      }
-      if (!args.freshnessInfo.freshArraySize) {
-        if (args.changes.__array_size) {
-          result2.arraySizeChanged = [stateVariable];
-          if (stateVarObj.additionalStateVariablesDefined) {
-            for (let varName of stateVarObj.additionalStateVariablesDefined) {
-              if (component.state[varName].isArray) {
-                result2.arraySizeChanged.push(varName);
-              }
-            }
-          }
-        }
-        args.freshnessInfo.freshArraySize = true;
-      }
-      return result2;
-    }
-  };
-  stateVarObj.inverseDefinition = function(args) {
-    if (!stateVarObj.inverseArrayDefinitionByKey) {
-      return { success: false };
-    }
-    if (args.arrayKeys === void 0) {
-      args.arrayKeys = stateVarObj.getAllArrayKeys(args.arraySize);
-    }
-    if (stateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
-      let instructions = [];
-      for (let vName of allStateVariablesAffected) {
-        for (let key in args.desiredStateVariableValues[vName]) {
-          let depName = vName + "_" + key;
-          if (depName in args.dependencyValues) {
-            instructions.push({
-              setDependency: depName,
-              desiredValue: args.desiredStateVariableValues[vName][key],
-              treatAsInitialChange: args.initialChange
-            });
-          }
-        }
-      }
-      return {
-        success: true,
-        instructions
-      };
-    } else {
-      let extractedDeps = extractArrayDependencies(
-        args.dependencyValues,
-        args.arrayKeys,
-        args.usedDefault
-      );
-      let globalDependencyValues = extractedDeps.globalDependencyValues;
-      let globalUsedDefault = extractedDeps.globalUsedDefault;
-      let dependencyValuesByKey = extractedDeps.dependencyValuesByKey;
-      let usedDefaultByKey = extractedDeps.usedDefaultByKey;
-      delete args.dependencyValues;
-      args.globalDependencyValues = globalDependencyValues;
-      args.globalUsedDefault = globalUsedDefault;
-      args.dependencyValuesByKey = dependencyValuesByKey;
-      args.usedDefaultByKey = usedDefaultByKey;
-      args.dependencyNamesByKey = stateVarObj.dependencyNames.namesByKey;
-      if (!stateVarObj.allowExtraArrayKeysInInverse) {
-        let newDesiredStateVariableValues = {};
-        for (let vName in args.desiredStateVariableValues) {
-          newDesiredStateVariableValues[vName] = {};
-          for (let key in args.desiredStateVariableValues[vName]) {
-            if (args.arrayKeys.includes(key)) {
-              newDesiredStateVariableValues[vName][key] = args.desiredStateVariableValues[vName][key];
-            }
-          }
-        }
-        args.desiredStateVariableValues = newDesiredStateVariableValues;
-      }
-      let result2 = stateVarObj.inverseArrayDefinitionByKey(args);
-      return result2;
-    }
-  };
+  stateVarObj.returnDependencies = arrayReturnDependencies;
+  stateVarObj.getCurrentFreshness = arrayGetCurrentFreshness;
+  stateVarObj.markStale = arrayMarkStale;
+  stateVarObj.freshenOnNoChanges = arrayFreshenOnNoChanges;
+  stateVarObj.definition = arrayDefinition;
+  stateVarObj.inverseDefinition = arrayInverseDefinition;
   await createArraySizeStateVariable({
     core: core2,
     stateVarObj,
@@ -51676,46 +51776,12 @@ async function initializeArrayStateVariable({
   });
   stateVarObj.arraySizeStale = true;
   stateVarObj.previousArraySize = [];
-  Object.defineProperty(stateVarObj, "arraySize", {
-    get: function() {
-      return (async () => {
-        if (!component.state[stateVarObj.arraySizeStateVariable].initiallyResolved) {
-          return [];
-        }
-        if (stateVarObj.arraySizeStale) {
-          await stateVarObj.recalculateArraySizeDependentQuantities();
-        }
-        return await component.stateValues[stateVarObj.arraySizeStateVariable];
-      })();
-    }
-  });
-  stateVarObj.recalculateArraySizeDependentQuantities = async function() {
-    let newArraySize = await component.stateValues[stateVarObj.arraySizeStateVariable];
-    if (stateVarObj.previousArraySize.length !== newArraySize.length || stateVarObj.previousArraySize.some(
-      (v2, i2) => v2 != newArraySize[i2]
-    )) {
-      stateVarObj.previousArraySize = [...newArraySize];
-      let varNamesIncluding = stateVarObj.varNamesIncludingArrayKeys = {};
-      for (let entryName of stateVarObj.arrayEntryNames) {
-        let entryStateVarObj = component.state[entryName];
-        let arrayKeys = stateVarObj.getArrayKeysFromVarName({
-          arrayEntryPrefix: entryStateVarObj.entryPrefix,
-          varEnding: entryStateVarObj.varEnding,
-          arraySize: newArraySize,
-          numDimensions: stateVarObj.numDimensions
-        });
-        entryStateVarObj._unflattenedArrayKeys = arrayKeys;
-        entryStateVarObj._arrayKeys = flattenDeep(arrayKeys);
-        for (let arrayKey of entryStateVarObj._arrayKeys) {
-          if (!varNamesIncluding[arrayKey]) {
-            varNamesIncluding[arrayKey] = [];
-          }
-          varNamesIncluding[arrayKey].push(entryName);
-        }
-      }
-    }
-    stateVarObj.arraySizeStale = false;
-  };
+  Object.defineProperty(
+    stateVarObj,
+    "arraySize",
+    ARRAY_ARRAY_SIZE_DESCRIPTOR
+  );
+  stateVarObj.recalculateArraySizeDependentQuantities = arrayRecalculateArraySizeDependentQuantities;
   if (!stateVarObj.freshnessInfo) {
     stateVarObj.freshnessInfo = { freshByKey: {} };
     if (stateVarObj.additionalStateVariablesDefined) {
@@ -51753,34 +51819,17 @@ async function createArraySizeStateVariable({
   if (component.state[arraySizeStateVar]) {
     if (component.state[arraySizeStateVar].isShadow) {
       let arraySizeStateVarObj = component.state[arraySizeStateVar];
-      arraySizeStateVarObj.markStale = function() {
-        for (let varName of allStateVariablesAffected) {
-          component.state[varName].arraySizeStale = true;
-        }
-        return {};
-      };
+      arraySizeStateVarObj.arraySizeVarNamesAffected = allStateVariablesAffected;
+      arraySizeStateVarObj.markStale = arraySizeMarkStale;
     }
     return;
   }
   component.state[arraySizeStateVar] = {
     returnDependencies: stateVarObj.returnArraySizeDependencies,
-    definition({ dependencyValues }) {
-      let arraySize2 = stateVarObj.returnArraySize({
-        dependencyValues
-      });
-      for (let [ind, value] of arraySize2.entries()) {
-        if (!(Number.isInteger(value) && value >= 0)) {
-          arraySize2[ind] = 0;
-        }
-      }
-      return { setValue: { [arraySizeStateVar]: arraySize2 } };
-    },
-    markStale() {
-      for (let varName of allStateVariablesAffected) {
-        component.state[varName].arraySizeStale = true;
-      }
-      return {};
-    }
+    definition: arraySizeDefinition,
+    markStale: arraySizeMarkStale,
+    arraySizeVarNamesAffected: allStateVariablesAffected,
+    arraySizeSourceVarName: stateVariable
   };
   if (stateVarObj.stateVariablesDeterminingArraySizeDependencies) {
     component.state[arraySizeStateVar].stateVariablesDeterminingDependencies = stateVarObj.stateVariablesDeterminingArraySizeDependencies;
@@ -64309,17 +64358,12 @@ class StalenessPropagator {
    * as stale: the next `await stateVarObj.value` will recompute, while
    * `_previousValue` is preserved for change-detection.
    */
-  async _replaceWithStaleGetter(stateVarObj, component, vName) {
+  async _replaceWithStaleGetter(stateVarObj) {
     stateVarObj._previousValue = await stateVarObj.value;
     if (Array.isArray(stateVarObj._previousValue)) {
       stateVarObj._previousValue = [...stateVarObj._previousValue];
     }
-    delete stateVarObj.value;
-    const getStateVar = this.core.getStateVariableValue;
-    Object.defineProperty(stateVarObj, "value", {
-      get: () => getStateVar({ component, stateVariable: vName }),
-      configurable: true
-    });
+    installStaleValueGetter(stateVarObj);
   }
   /**
    * Visit `component` for stale-marking against `varName` plus every
@@ -64444,11 +64488,7 @@ class StalenessPropagator {
       const stateVarObj = allStateVariablesAffectedObj[vName];
       delete stateVarObj.recursiveDependencyValues;
       if (previouslyFreshVars.includes(vName)) {
-        await this._replaceWithStaleGetter(
-          stateVarObj,
-          component,
-          vName
-        );
+        await this._replaceWithStaleGetter(stateVarObj);
       }
     }
     if (freshnessDecreased) {
@@ -67603,7 +67643,13 @@ class Core {
       requestSolutionView: this.requestSolutionView.bind(this),
       requestComponentDoenetML: this.requestComponentDoenetML.bind(this),
       copyToClipboard: this.copyToClipboard.bind(this),
-      navigateToTarget: (args) => navigateToTarget({ core: this, args })
+      navigateToTarget: (args) => navigateToTarget({ core: this, args }),
+      // State-variable runtime plumbing, not component-facing API:
+      // the shared state-variable functions in StateVariableInitializer
+      // reach core through `svComponent.coreFunctions`.
+      getStateVariableValue: this.getStateVariableValue,
+      // bound above
+      addDiagnostic: this.addDiagnostic.bind(this)
     };
     this.updateInfo = {
       componentsToUpdateRenderers: /* @__PURE__ */ new Set(),
@@ -229197,4 +229243,4 @@ export {
   getDefaultExportFromCjs as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-BBh2EPqg.js.map
+//# sourceMappingURL=index-CyEKEyxP.js.map