@doenet/v06-to-v07 0.7.20-dev.316 → 0.7.20-dev.317

package/{index-CgX2sNWV.js → index-DiShf3LI.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-CiX8mjgB-LkkwAqwy.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-C0vj3HDn-B8ugC21B-Cq92odhc.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -50172,6 +50172,142 @@ async function createReferenceShadowStateVariableDefinitions({
     targetComponent
   });
 }
+function shadowReturnDependencies(args) {
+  let dependencies2 = Object.assign(
+    {},
+    this.shadowOriginalReturnDependencies?.(args)
+  );
+  dependencies2.targetVariable = {
+    dependencyType: "stateVariable",
+    componentIdx: this.shadowOfComponentIdx,
+    variableName: this.shadowVarNameInTarget
+  };
+  if (this.shadowCopyComponentType) {
+    dependencies2.targetVariableComponentType = {
+      dependencyType: "stateVariableComponentType",
+      componentIdx: this.shadowOfComponentIdx,
+      variableName: this.shadowVarNameInTarget
+    };
+  }
+  return dependencies2;
+}
+function shadowDefinition({ dependencyValues, usedDefault }) {
+  const varName = this.shadowVarName;
+  let result2 = {};
+  if ("targetVariableComponentType" in dependencyValues) {
+    result2.setCreateComponentOfType = {
+      [varName]: dependencyValues.targetVariableComponentType
+    };
+  }
+  if (usedDefault.targetVariable && "defaultValue" in this && this.hasEssential) {
+    result2.useEssentialOrDefaultValue = {
+      [varName]: {
+        defaultValue: dependencyValues.targetVariable
+      }
+    };
+  } else {
+    result2.setValue = {
+      [varName]: dependencyValues.targetVariable
+    };
+  }
+  return result2;
+}
+function shadowInverseDefinition({ desiredStateVariableValues }) {
+  return {
+    success: true,
+    instructions: [
+      {
+        setDependency: "targetVariable",
+        desiredValue: desiredStateVariableValues[this.shadowVarName],
+        shadowedVariable: true
+      }
+    ]
+  };
+}
+function shadowReturnArrayDependenciesByKey({ arrayKeys }) {
+  let dependenciesByKey = {};
+  for (let key of arrayKeys) {
+    dependenciesByKey[key] = {
+      targetVariable: {
+        dependencyType: "stateVariable",
+        componentIdx: this.shadowOfComponentIdx,
+        variableName: this.shadowOverrideVarName || this.arrayVarNameFromArrayKey(key)
+      }
+    };
+  }
+  let globalDependencies = {};
+  if (this.shadowCopyComponentType) {
+    globalDependencies.targetVariableComponentType = {
+      dependencyType: "stateVariableComponentType",
+      componentIdx: this.shadowOfComponentIdx,
+      variableName: this.shadowVarName
+    };
+  }
+  if (this.inverseShadowToSetEntireArray) {
+    globalDependencies.targetArray = {
+      dependencyType: "stateVariable",
+      componentIdx: this.shadowOfComponentIdx,
+      variableName: this.shadowVarName
+    };
+  }
+  return { globalDependencies, dependenciesByKey };
+}
+function shadowArrayDefinitionByKey({ globalDependencyValues, dependencyValuesByKey, arrayKeys }) {
+  const varName = this.shadowVarName;
+  let newEntries = {};
+  for (let arrayKey of arrayKeys) {
+    if ("targetVariable" in dependencyValuesByKey[arrayKey]) {
+      newEntries[arrayKey] = dependencyValuesByKey[arrayKey].targetVariable;
+    } else {
+      newEntries[arrayKey] = this.defaultValueByArrayKey?.(arrayKey);
+    }
+  }
+  let result2 = {
+    setValue: { [varName]: newEntries }
+  };
+  if ("targetVariableComponentType" in globalDependencyValues) {
+    result2.setCreateComponentOfType = {
+      [varName]: globalDependencyValues.targetVariableComponentType
+    };
+  }
+  return result2;
+}
+function shadowInverseArrayDefinitionByKey({
+  desiredStateVariableValues,
+  dependencyValuesByKey,
+  dependencyNamesByKey,
+  arraySize: arraySize2,
+  initialChange
+}) {
+  const varName = this.shadowVarName;
+  if (this.inverseShadowToSetEntireArray) {
+    return {
+      success: true,
+      instructions: [
+        {
+          setDependency: "targetArray",
+          desiredValue: desiredStateVariableValues[varName],
+          treatAsInitialChange: initialChange
+        }
+      ]
+    };
+  }
+  let instructions = [];
+  for (let key in desiredStateVariableValues[varName]) {
+    if (!dependencyValuesByKey[key]) {
+      continue;
+    }
+    instructions.push({
+      setDependency: dependencyNamesByKey[key].targetVariable,
+      desiredValue: desiredStateVariableValues[varName][key],
+      shadowedVariable: true
+    });
+  }
+  return {
+    success: true,
+    instructions
+  };
+}
 function modifyStateDefsToBeShadows({
   stateVariablesToShadow,
   stateVariableDefinitions,
@@ -50205,157 +50341,23 @@ function modifyStateDefsToBeShadows({
       delete stateDef.stateVariablesDeterminingDependencies;
     }
     let copyComponentType = stateDef.public && stateDef.shadowingInstructions.hasVariableComponentType;
+    stateDef.shadowOfComponentIdx = targetComponent.componentIdx;
+    stateDef.shadowVarName = varName;
+    stateDef.shadowCopyComponentType = copyComponentType;
     if (stateDef.isArray) {
-      let overrideVarNameWith = differentStateVariablesInTarget[varInd];
-      stateDef.returnArrayDependenciesByKey = function({ arrayKeys }) {
-        let dependenciesByKey = {};
-        for (let key of arrayKeys) {
-          dependenciesByKey[key] = {
-            targetVariable: {
-              dependencyType: "stateVariable",
-              componentIdx: targetComponent.componentIdx,
-              variableName: overrideVarNameWith || this.arrayVarNameFromArrayKey(key)
-            }
-          };
-        }
-        let globalDependencies = {};
-        if (copyComponentType) {
-          globalDependencies.targetVariableComponentType = {
-            dependencyType: "stateVariableComponentType",
-            componentIdx: targetComponent.componentIdx,
-            variableName: varName
-          };
-        }
-        if (stateDef.inverseShadowToSetEntireArray) {
-          globalDependencies.targetArray = {
-            dependencyType: "stateVariable",
-            componentIdx: targetComponent.componentIdx,
-            variableName: varName
-          };
-        }
-        return { globalDependencies, dependenciesByKey };
-      };
-      stateDef.arrayDefinitionByKey = function({
-        globalDependencyValues,
-        dependencyValuesByKey,
-        arrayKeys
-      }) {
-        let newEntries = {};
-        for (let arrayKey of arrayKeys) {
-          if ("targetVariable" in dependencyValuesByKey[arrayKey]) {
-            newEntries[arrayKey] = dependencyValuesByKey[arrayKey].targetVariable;
-          } else {
-            newEntries[arrayKey] = stateDef.defaultValueByArrayKey?.(arrayKey);
-          }
-        }
-        let result2 = {
-          setValue: { [varName]: newEntries }
-        };
-        if ("targetVariableComponentType" in globalDependencyValues) {
-          result2.setCreateComponentOfType = {
-            [varName]: globalDependencyValues.targetVariableComponentType
-          };
-        }
-        return result2;
-      };
-      stateDef.inverseArrayDefinitionByKey = function({
-        desiredStateVariableValues,
-        dependencyValuesByKey,
-        dependencyNamesByKey,
-        arraySize: arraySize2,
-        initialChange
-      }) {
-        if (stateDef.inverseShadowToSetEntireArray) {
-          return {
-            success: true,
-            instructions: [
-              {
-                setDependency: "targetArray",
-                desiredValue: desiredStateVariableValues[varName],
-                treatAsInitialChange: initialChange
-              }
-            ]
-          };
-        }
-        let instructions = [];
-        for (let key in desiredStateVariableValues[varName]) {
-          if (!dependencyValuesByKey[key]) {
-            continue;
-          }
-          instructions.push({
-            setDependency: dependencyNamesByKey[key].targetVariable,
-            desiredValue: desiredStateVariableValues[varName][key],
-            shadowedVariable: true
-          });
-        }
-        return {
-          success: true,
-          instructions
-        };
-      };
+      stateDef.shadowOverrideVarName = differentStateVariablesInTarget[varInd];
+      stateDef.returnArrayDependenciesByKey = shadowReturnArrayDependenciesByKey;
+      stateDef.arrayDefinitionByKey = shadowArrayDefinitionByKey;
+      stateDef.inverseArrayDefinitionByKey = shadowInverseArrayDefinitionByKey;
     } else {
-      let returnStartingDependencies = () => ({});
       if (foundReadyToExpandWhenResolved) {
-        returnStartingDependencies = stateDef.returnDependencies.bind(stateDef);
-      }
-      let varNameInTarget = differentStateVariablesInTarget[varInd];
-      if (!varNameInTarget) {
-        varNameInTarget = varName;
+        stateDef.shadowOriginalReturnDependencies = stateDef.returnDependencies.bind(stateDef);
       }
-      stateDef.returnDependencies = function(args) {
-        let dependencies2 = Object.assign(
-          {},
-          returnStartingDependencies(args)
-        );
-        dependencies2.targetVariable = {
-          dependencyType: "stateVariable",
-          componentIdx: targetComponent.componentIdx,
-          variableName: varNameInTarget
-        };
-        if (copyComponentType) {
-          dependencies2.targetVariableComponentType = {
-            dependencyType: "stateVariableComponentType",
-            componentIdx: targetComponent.componentIdx,
-            variableName: varNameInTarget
-          };
-        }
-        return dependencies2;
-      };
-      stateDef.definition = function({ dependencyValues, usedDefault }) {
-        let result2 = {};
-        if ("targetVariableComponentType" in dependencyValues) {
-          result2.setCreateComponentOfType = {
-            [varName]: dependencyValues.targetVariableComponentType
-          };
-        }
-        if (usedDefault.targetVariable && "defaultValue" in stateDef && stateDef.hasEssential) {
-          result2.useEssentialOrDefaultValue = {
-            [varName]: {
-              defaultValue: dependencyValues.targetVariable
-            }
-          };
-        } else {
-          result2.setValue = {
-            [varName]: dependencyValues.targetVariable
-          };
-        }
-        return result2;
-      };
+      stateDef.shadowVarNameInTarget = differentStateVariablesInTarget[varInd] || varName;
+      stateDef.returnDependencies = shadowReturnDependencies;
+      stateDef.definition = shadowDefinition;
       stateDef.excludeDependencyValuesInInverseDefinition = true;
-      stateDef.inverseDefinition = function({
-        desiredStateVariableValues
-      }) {
-        return {
-          success: true,
-          instructions: [
-            {
-              setDependency: "targetVariable",
-              desiredValue: desiredStateVariableValues[varName],
-              shadowedVariable: true
-            }
-          ]
-        };
-      };
+      stateDef.inverseDefinition = shadowInverseDefinition;
     }
   }
   for (let varName in deleteStateVariablesFromDefinition) {
@@ -53120,6 +53122,12 @@ const _Dependency = class _Dependency2 {
     let downComponents = await this.determineDownstreamComponents();
     let downstreamComponentIndices = downComponents.downstreamComponentIndices;
     let downstreamComponentTypes = downComponents.downstreamComponentTypes;
+    this.upstreamVariableNames = this.dependencyHandler.internVariableNameListByCopy(
+      this.upstreamVariableNames
+    );
+    this.originalDownstreamVariableNames = this.dependencyHandler.internVariableNameListByCopy(
+      this.originalDownstreamVariableNames
+    );
     this.componentIdentitiesChanged = true;
     let upCompDownDeps = this.dependencyHandler.downstreamDependencies[this.upstreamComponentIdx];
     if (!upCompDownDeps) {
@@ -53150,6 +53158,112 @@ const _Dependency = class _Dependency2 {
         index: index2
       });
     }
+    this.downstreamComponentIndices = this.dependencyHandler.internComponentIndexList(
+      this.downstreamComponentIndices
+    );
+    this.downstreamComponentTypes = this.dependencyHandler.internComponentTypeList(
+      this.downstreamComponentTypes
+    );
+    if (this.mappedDownstreamVariableNamesByComponent) {
+      this.mappedDownstreamVariableNamesByComponent = this.dependencyHandler.internNameListArray(
+        this.mappedDownstreamVariableNamesByComponent
+      );
+    }
+    if (this.valuesChanged) {
+      this.valuesChanged = this.dependencyHandler.internValuesChangedArray(
+        this.valuesChanged
+      );
+    }
+  }
+  /**
+   * Replace the interned (frozen, shared) parallel downstream arrays with
+   * mutable copies before changing the downstream set.
+   */
+  thawDownstreamArrays() {
+    if (Object.isFrozen(this.downstreamComponentIndices)) {
+      this.downstreamComponentIndices = [
+        ...this.downstreamComponentIndices
+      ];
+    }
+    if (Object.isFrozen(this.downstreamComponentTypes)) {
+      this.downstreamComponentTypes = [...this.downstreamComponentTypes];
+    }
+    if (this.mappedDownstreamVariableNamesByComponent && Object.isFrozen(this.mappedDownstreamVariableNamesByComponent)) {
+      this.mappedDownstreamVariableNamesByComponent = [
+        ...this.mappedDownstreamVariableNamesByComponent
+      ];
+    }
+    if (this.valuesChanged && Object.isFrozen(this.valuesChanged)) {
+      this.valuesChanged = [...this.valuesChanged];
+    }
+  }
+  /**
+   * Replace the interned (frozen, shared) `valuesChanged` outer array
+   * and/or the record at `componentInd` with mutable copies so a caller
+   * can record change metadata on them.
+   */
+  thawValuesChangedRecord(componentInd) {
+    if (!this.valuesChanged) {
+      return;
+    }
+    if (Object.isFrozen(this.valuesChanged)) {
+      this.valuesChanged = [...this.valuesChanged];
+    }
+    const record = this.valuesChanged[componentInd];
+    if (record && Object.isFrozen(record)) {
+      this.valuesChanged[componentInd] = { ...record };
+    }
+  }
+  /**
+   * Remove the change record for `varName` of the downstream component at
+   * `componentInd` after `getValue` consumed it (records are recreated on
+   * demand when marked changed again). Fully-consumed records converge to
+   * the shared frozen empty record, and outer arrays of shared records are
+   * re-interned, so an unchanging dependency retains no per-dependency
+   * change-tracking allocations at all.
+   */
+  consumeChangeRecord(componentInd, varName) {
+    const outer = this.valuesChanged;
+    if (!outer) {
+      return;
+    }
+    const record = outer[componentInd];
+    if (!record) {
+      return;
+    }
+    let replacement = record;
+    if (Object.isFrozen(record)) {
+      if (!(varName in record)) {
+        return;
+      }
+      const remaining = Object.keys(record).filter(
+        (name2) => name2 !== varName
+      );
+      if (remaining.length === 0) {
+        replacement = this.dependencyHandler.emptyValuesChangedRecord;
+      } else {
+        replacement = {};
+        for (const name2 of remaining) {
+          replacement[name2] = record[name2];
+        }
+      }
+    } else {
+      delete record[varName];
+      if (Object.keys(record).length === 0) {
+        replacement = this.dependencyHandler.emptyValuesChangedRecord;
+      }
+    }
+    if (replacement !== record) {
+      if (Object.isFrozen(this.valuesChanged)) {
+        this.valuesChanged = [...this.valuesChanged];
+      }
+      this.valuesChanged[componentInd] = replacement;
+    }
+    if (!Object.isFrozen(this.valuesChanged)) {
+      this.valuesChanged = this.dependencyHandler.internValuesChangedArray(
+        this.valuesChanged
+      );
+    }
   }
   async addDownstreamComponent({
     downstreamComponentIdx,
@@ -53157,6 +53271,7 @@ const _Dependency = class _Dependency2 {
     index: index2
   }) {
     this.componentIdentitiesChanged = true;
+    this.thawDownstreamArrays();
     this.downstreamComponentIndices.splice(
       index2,
       0,
@@ -53239,11 +53354,14 @@ const _Dependency = class _Dependency2 {
           0,
           mappedVarNames
         );
-        let valsChanged = {};
-        for (let downVar of mappedVarNames) {
-          valsChanged[downVar] = INITIAL_CHANGE_RECORD;
-        }
-        this.valuesChanged.splice(index2, 0, valsChanged);
+        this.valuesChanged.splice(
+          index2,
+          0,
+          this.dependencyHandler.internInitialValuesChangedRecord(
+            mappedVarNames,
+            INITIAL_CHANGE_RECORD
+          )
+        );
         if (this.variablesOptional) {
           downVarNames = downVarNames.filter(
             (downVar) => downVar in downComponent.state || this.dependencyHandler.core.checkIfArrayEntry({
@@ -53292,10 +53410,12 @@ const _Dependency = class _Dependency2 {
         downCompUpDeps = this.dependencyHandler.upstreamDependencies[downstreamComponentIdx] = {};
       }
       for (let varName of downVarNames) {
-        if (downCompUpDeps[varName] === void 0) {
-          downCompUpDeps[varName] = [];
+        const existingUpDeps = downCompUpDeps[varName];
+        if (existingUpDeps === void 0) {
+          downCompUpDeps[varName] = [this];
+        } else {
+          downCompUpDeps[varName] = existingUpDeps.concat(this);
         }
-        downCompUpDeps[varName].push(this);
         if (varName !== this.downstreamVariableNameIfNoVariables) {
           for (let upstreamVarName of this.upstreamVariableNames) {
             this.dependencyHandler.resetCircularCheckPassed(
@@ -53324,6 +53444,7 @@ const _Dependency = class _Dependency2 {
     if (recordChange) {
       this.componentIdentitiesChanged = true;
     }
+    this.thawDownstreamArrays();
     let componentIdx = this.downstreamComponentIndices[indexToRemove];
     this.downstreamComponentIndices.splice(indexToRemove, 1);
     this.downstreamComponentTypes.splice(indexToRemove, 1);
@@ -53355,7 +53476,7 @@ const _Dependency = class _Dependency2 {
             if (downCompUpDeps.length === 1) {
               delete this.dependencyHandler.upstreamDependencies[componentIdx][vName];
             } else {
-              downCompUpDeps.splice(ind, 1);
+              this.dependencyHandler.upstreamDependencies[componentIdx][vName] = downCompUpDeps.slice(0, ind).concat(downCompUpDeps.slice(ind + 1));
             }
           }
         }
@@ -53384,6 +53505,7 @@ const _Dependency = class _Dependency2 {
   }
   async swapDownstreamComponents(index1, index2) {
     this.componentIdentitiesChanged = true;
+    this.thawDownstreamArrays();
     [
       this.downstreamComponentIndices[index1],
       this.downstreamComponentIndices[index2]
@@ -53465,7 +53587,7 @@ const _Dependency = class _Dependency2 {
             if (downCompUpDeps.length === 1) {
               delete this.dependencyHandler.upstreamDependencies[downCompIdx][vName];
             } else {
-              downCompUpDeps.splice(ind, 1);
+              this.dependencyHandler.upstreamDependencies[downCompIdx][vName] = downCompUpDeps.slice(0, ind).concat(downCompUpDeps.slice(ind + 1));
             }
           }
         }
@@ -53578,7 +53700,10 @@ const _Dependency = class _Dependency2 {
                   });
                 }
                 if (consumeChanges) {
-                  delete this.valuesChanged[componentInd][mappedVarName];
+                  this.consumeChangeRecord(
+                    componentInd,
+                    mappedVarName
+                  );
                 }
                 if (mappedStateVarObj.usedDefault) {
                   usedDefaultObj[nameForOutput] = true;
@@ -54160,7 +54285,7 @@ const _StateVariableComponentTypeDependency = class _StateVariableComponentTypeD
               });
             }
             if (consumeChanges) {
-              delete this.valuesChanged[0][mappedVarName];
+              this.consumeChangeRecord(0, mappedVarName);
             }
             let hasVariableComponentType = stateVarObj.shadowingInstructions?.hasVariableComponentType;
             if (!hasVariableComponentType && stateVarObj.isArrayEntry) {
@@ -57233,6 +57358,11 @@ const _ShadowSourceDependency = class _ShadowSourceDependency2 extends Dependenc
         if (!this.originalDownstreamVariableNames.includes(
           component.shadows.propVariable
         )) {
+          if (Object.isFrozen(this.originalDownstreamVariableNames)) {
+            this.originalDownstreamVariableNames = [
+              ...this.originalDownstreamVariableNames
+            ];
+          }
           this.originalDownstreamVariableNames.push(
             component.shadows.propVariable
           );
@@ -58585,6 +58715,60 @@ class DependencyHandler {
     };
     this.attributeRefResolutionDependenciesByReferenced = {};
     this._internedVariableNameLists = /* @__PURE__ */ new Map();
+    this._internedComponentIndexLists = /* @__PURE__ */ new Map();
+    this._internedComponentTypeLists = /* @__PURE__ */ new Map();
+    this._internedNameListArrays = /* @__PURE__ */ new Map();
+    this._internedListIds = /* @__PURE__ */ new WeakMap();
+    this._nextInternedListId = 1;
+    this._internedValuesChangedRecords = /* @__PURE__ */ new Map();
+    this._internedValuesChangedArrays = /* @__PURE__ */ new Map();
+    this.emptyValuesChangedRecord = Object.freeze({});
+    this._internedListIds.set(
+      this.emptyValuesChangedRecord,
+      this._nextInternedListId
+    );
+    this._nextInternedListId++;
+  }
+  internComponentIndexList(indices) {
+    const key = indices.join(",");
+    let interned = this._internedComponentIndexLists.get(key);
+    if (!interned) {
+      interned = Object.freeze(indices);
+      this._internedComponentIndexLists.set(key, interned);
+    }
+    return interned;
+  }
+  internComponentTypeList(types) {
+    const key = types.join("\n");
+    let interned = this._internedComponentTypeLists.get(key);
+    if (!interned) {
+      interned = Object.freeze(types);
+      this._internedComponentTypeLists.set(key, interned);
+    }
+    return interned;
+  }
+  /**
+   * Intern an array whose elements are already-interned name lists
+   * (from `internVariableNameList`), keyed by the identity of those
+   * elements. Elements that are not interned lists (no assigned id) make
+   * the array non-internable; it is returned unchanged.
+   */
+  internNameListArray(outer) {
+    const ids = [];
+    for (const inner of outer) {
+      const id2 = typeof inner === "object" && inner !== null ? this._internedListIds.get(inner) : void 0;
+      if (id2 === void 0) {
+        return outer;
+      }
+      ids.push(id2);
+    }
+    const key = ids.join(",");
+    let interned = this._internedNameListArrays.get(key);
+    if (!interned) {
+      interned = Object.freeze(outer);
+      this._internedNameListArrays.set(key, interned);
+    }
+    return interned;
   }
   internVariableNameList(names) {
     const key = names.join("\n");
@@ -58592,6 +58776,76 @@ class DependencyHandler {
     if (!interned) {
       interned = Object.freeze(names);
       this._internedVariableNameLists.set(key, interned);
+      this._internedListIds.set(interned, this._nextInternedListId);
+      this._nextInternedListId++;
+    }
+    return interned;
+  }
+  /**
+   * Like `internVariableNameList`, but never freezes the caller's array:
+   * on a cache miss the interned entry is a frozen copy. For dependency
+   * fields that alias arrays owned elsewhere (state-variable definitions,
+   * constructor arguments), which must stay mutable for their owners.
+   */
+  internVariableNameListByCopy(names) {
+    const key = names.join("\n");
+    const interned = this._internedVariableNameLists.get(key);
+    if (interned) {
+      return interned;
+    }
+    return this.internVariableNameList([...names]);
+  }
+  /**
+   * Return the shared frozen initial `valuesChanged` record (every
+   * variable mapped to the shared initial change record) for the given
+   * interned variable-name list. Falls back to a fresh mutable record if
+   * `names` was not interned. Writers must thaw/replace before mutating;
+   * see `Dependency.thawValuesChangedRecord` and
+   * `Dependency.consumeChangeRecord`.
+   */
+  internInitialValuesChangedRecord(names, initialChangeRecord) {
+    const listId = this._internedListIds.get(names);
+    if (listId === void 0) {
+      const record2 = {};
+      for (const name2 of names) {
+        record2[name2] = initialChangeRecord;
+      }
+      return record2;
+    }
+    let record = this._internedValuesChangedRecords.get(listId);
+    if (!record) {
+      record = {};
+      for (const name2 of names) {
+        record[name2] = initialChangeRecord;
+      }
+      Object.freeze(record);
+      this._internedValuesChangedRecords.set(listId, record);
+      this._internedListIds.set(record, this._nextInternedListId);
+      this._nextInternedListId++;
+    }
+    return record;
+  }
+  /**
+   * Intern a `valuesChanged` outer array whose entries are all interned
+   * records (from `internInitialValuesChangedRecord` or
+   * `emptyValuesChangedRecord`), keyed by the identity of those entries.
+   * Any non-interned (hence mutable) entry makes the array non-internable;
+   * it is returned unchanged.
+   */
+  internValuesChangedArray(outer) {
+    const ids = [];
+    for (const record of outer) {
+      const id2 = typeof record === "object" && record !== null ? this._internedListIds.get(record) : void 0;
+      if (id2 === void 0) {
+        return outer;
+      }
+      ids.push(id2);
+    }
+    const key = ids.join(",");
+    let interned = this._internedValuesChangedArrays.get(key);
+    if (!interned) {
+      interned = Object.freeze(outer);
+      this._internedValuesChangedArrays.set(key, interned);
     }
     return interned;
   }
@@ -59007,6 +59261,19 @@ class DependencyHandler {
       }
     }
   }
+  /**
+   * Drop the circular-check memo records. They are pure caches ("this
+   * state variable already passed the check"), so clearing costs only
+   * re-verification when a later dependency change re-triggers a check.
+   * Called once initial document construction finishes: at that point the
+   * memos cover every state variable created during the load (one record
+   * entry per state variable), but they regrow only for the typically few
+   * components involved in subsequent updates.
+   */
+  clearCircularCheckMemos() {
+    this.circularCheckPassed = {};
+    this.circularResolveBlockedCheckPassed = {};
+  }
   resetCircularCheckPassed(componentIdx, varName) {
     let stateVariableIdentifier = componentIdx + ":" + varName;
     if (this.circularCheckPassed[stateVariableIdentifier]) {
@@ -59307,6 +59574,7 @@ class DependencyHandler {
       for (let upDep of upstream) {
         if (upDep.valuesChanged) {
           let ind = upDep.downstreamComponentIndices.indexOf(componentIdx);
+          upDep.thawValuesChangedRecord(ind);
           let upValuesChanged = upDep.valuesChanged[ind][varName];
           if (!upValuesChanged) {
             upValuesChanged = upDep.valuesChanged[ind][varName] = {};
@@ -59851,12 +60119,12 @@ class DependencyHandler {
     });
     let neededToResolveBlocked = neededForBlocked[blockerType];
     if (!neededToResolveBlocked) {
-      neededToResolveBlocked = neededForBlocked[blockerType] = [];
-    }
-    if (neededToResolveBlocked.includes(blockerCode)) {
+      neededForBlocked[blockerType] = [blockerCode];
+    } else if (neededToResolveBlocked.includes(blockerCode)) {
       return;
+    } else {
+      neededToResolveBlocked.push(blockerCode);
     }
-    neededToResolveBlocked.push(blockerCode);
     if (typeBlocked === "stateVariable") {
       let component = this._components[componentIdxBlocked];
       if (component) {
@@ -59897,9 +60165,8 @@ class DependencyHandler {
     });
     let blockedByBlocker = resolvedBlockedByBlocker[typeBlocked];
     if (!blockedByBlocker) {
-      blockedByBlocker = resolvedBlockedByBlocker[typeBlocked] = [];
-    }
-    if (!blockedByBlocker.includes(codeBlocked)) {
+      resolvedBlockedByBlocker[typeBlocked] = [codeBlocked];
+    } else if (!blockedByBlocker.includes(codeBlocked)) {
       blockedByBlocker.push(codeBlocked);
     }
     this.resetCircularResolveBlockerCheckPassed({
@@ -63920,6 +64187,7 @@ class StalenessPropagator {
             if (!upDep.valuesChanged) {
               upDep.valuesChanged = [];
             }
+            upDep.thawValuesChangedRecord(componentInd);
             if (!upDep.valuesChanged[componentInd]) {
               upDep.valuesChanged[componentInd] = {};
             }
@@ -67501,6 +67769,7 @@ class Core {
         reportTimerError(TimerLabels.generateDastSaveState)
       );
     }
+    this.dependencies.clearCircularCheckMemos();
     const returnResult = {
       coreInfo: this.coreInfo
     };
@@ -228907,4 +229176,4 @@ export {
   getDefaultExportFromCjs as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-CgX2sNWV.js.map
+//# sourceMappingURL=index-DiShf3LI.js.map