@markw65/monkeyc-optimizer 1.1.81 → 1.1.83

package/build/{chunk-W4QVHCFN.cjs → chunk-UNU55JJ3.cjs}

@@ -26,8 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_W4QVHCFN_exports = {};
-__export(chunk_W4QVHCFN_exports, {
+var chunk_UNU55JJ3_exports = {};
+__export(chunk_UNU55JJ3_exports, {
   EnumTagsConst: () => EnumTagsConst,
   LastTypeTag: () => LastTypeTag,
   ObjectLikeTagsConst: () => ObjectLikeTagsConst,
@@ -139,7 +139,7 @@ __export(chunk_W4QVHCFN_exports, {
   visitorNode: () => visitorNode,
   xml_util_exports: () => xml_util_exports
 });
-module.exports = __toCommonJS(chunk_W4QVHCFN_exports);
+module.exports = __toCommonJS(chunk_UNU55JJ3_exports);
 var import_chunk_X7QCZR3F = require("./chunk-X7QCZR3F.cjs");
 var import_chunk_JDC43A3I = require("./chunk-JDC43A3I.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
@@ -5726,6 +5726,12 @@ var init_build_config = (0, import_chunk_ABYVSU2C.__esm)({
             default: "YES",
             scope: "resource"
           },
+          extraReferenceTypeChecks: {
+            type: "boolean",
+            description: "Whether to warn about [unsafe operations on Arrays and Dictionaries](https://github.com/markw65/monkeyc-optimizer/wiki/Extra-Reference-Type-Checks-(prettierMonkeyC.extraReferenceTypeChecks)) that Garmin's compiler allows",
+            default: true,
+            scope: "resource"
+          },
           compilerLookupRules: {
             type: "string",
             description: "Whether to perform lookups as compiler1, compiler2, or based on the currently selected sdk",
@@ -7613,6 +7619,9 @@ var init_control_flow = (0, import_chunk_ABYVSU2C.__esm)({
   }
 });
 function unionInto(to, from) {
+  return unionHelper(to, from, -Infinity);
+}
+function unionHelper(to, from, widenDepth) {
   if (to == null || from == null) {
     throw new Error("Null");
   }
@@ -7638,14 +7647,14 @@ function unionInto(to, from) {
       clearValuesUnder(to, from.type);
       return true;
     }
-    return mergeMultiple(to, from);
+    return mergeMultiple(to, from, widenDepth);
   }
   if (to.value != null) {
     if (from.value == null) {
       clearValuesUnder(to, from.type);
       return true;
     }
-    mergeMultiple(to, from);
+    mergeMultiple(to, from, widenDepth);
     return true;
   }
   if (from.value == null) {
@@ -7658,7 +7667,7 @@ function unionInto(to, from) {
   to.value = tmp.value;
   return true;
 }
-function mergeMultiple(to, from) {
+function mergeMultiple(to, from, widenDepth) {
   const newTags = to.type | from.type;
   let anyChanged = newTags !== to.type;
   let mask = 0;
@@ -7667,11 +7676,14 @@ function mergeMultiple(to, from) {
     const fromv = getUnionComponent(from, ac.type);
     if (ac.value != null) {
       if (fromv != null) {
-        const [value2, changed] = mergeSingle({
-          type: ac.type,
-          avalue: ac.value,
-          bvalue: fromv
-        });
+        const [value2, changed] = ac.value === fromv ? [fromv, false] : mergeSingle(
+          {
+            type: ac.type,
+            avalue: ac.value,
+            bvalue: fromv
+          },
+          widenDepth
+        );
         if (changed)
           anyChanged = true;
         if (value2) {
@@ -7708,13 +7720,13 @@ function mergeMultiple(to, from) {
   to.value = result[mask];
   return true;
 }
-function tryUnion(to, from) {
-  to = cloneType(to);
-  if (unionInto(to, from))
-    return to;
-  return null;
-}
-function mergeSingle(pair) {
+function mergeSingle(pair, widenDepth) {
+  function tryUnion(to, from) {
+    to = cloneType(to);
+    if (unionHelper(to, from, widenDepth + 1))
+      return to;
+    return null;
+  }
   switch (pair.type) {
     case 1:
     case 2:
@@ -7727,31 +7739,58 @@ function mergeSingle(pair) {
     case 128:
     case 256:
     case 131072:
-      if (pair.avalue === pair.bvalue) {
-        return [pair.avalue, false];
-      }
       return [null, true];
     case 512: {
-      if (Array.isArray(pair.avalue)) {
-        const bv = pair.bvalue;
-        if (Array.isArray(bv)) {
-          if (pair.avalue.length === bv.length) {
-            let changed = false;
-            const u = pair.avalue.map((a, i) => {
-              const merged2 = tryUnion(a, bv[i]);
-              if (merged2)
-                changed = true;
-              return merged2 || a;
-            });
-            return [u, changed];
+      if (widenDepth > MaxWidenDepth) {
+        return [null, true];
+      }
+      const tupleTypes = /* @__PURE__ */ new Map();
+      const arrayTypes = [];
+      tupleForEach(
+        pair.avalue,
+        (v) => {
+          const t = tupleTypes.get(v.length);
+          if (t) {
+            t.push(v);
+          } else {
+            tupleTypes.set(v.length, [v]);
+          }
+        },
+        (v) => arrayTypes.push(v)
+      );
+      const extraTypes = [];
+      tupleForEach(
+        pair.bvalue,
+        (v) => {
+          const tuples = tupleTypes.get(v.length);
+          if (!tuples?.some(
+            (t) => t.every((at, i) => {
+              const bt = v[i];
+              return subtypeOf(at, bt) && subtypeOf(bt, at);
+            })
+          )) {
+            extraTypes.push(v);
+          }
+        },
+        (v) => {
+          if (!arrayTypes.some((at) => subtypeOf(at, v) && subtypeOf(v, at))) {
+            extraTypes.push(v);
           }
         }
+      );
+      if (extraTypes.length) {
+        if (widenDepth >= 0) {
+          return [null, true];
+        }
+        const allTypes = (pair.avalue instanceof Set ? Array.from(pair.avalue) : [pair.avalue]).concat(extraTypes);
+        return [tupleReduce(allTypes), true];
       }
-      const av = reducedType(pair.avalue);
-      const merged = tryUnion(av, reducedType(pair.bvalue));
-      return [merged || av, merged != null];
+      return [pair.avalue, false];
     }
     case 1024: {
+      if (widenDepth > MaxWidenDepth) {
+        return [null, true];
+      }
       const avalue = pair.avalue;
       const bvalue = pair.bvalue;
       if (!avalue.value) {
@@ -7766,7 +7805,7 @@ function mergeSingle(pair) {
               return;
             }
             av = cloneType(av);
-            if (unionInto(av, bv))
+            if (unionHelper(av, bv, widenDepth + 1))
               merged = true;
             result.set(key2, av);
           });
@@ -7842,7 +7881,8 @@ function mergeSingle(pair) {
       let klass = pair.avalue.klass;
       const [obj, objChanged] = mergeObjectValues(
         pair.avalue.obj,
-        pair.bvalue.obj
+        pair.bvalue.obj,
+        widenDepth
       );
       const klassChanged = tryUnion(klass, pair.bvalue.klass);
       if (klassChanged || objChanged) {
@@ -7857,34 +7897,39 @@ function mergeSingle(pair) {
     case 65536: {
       const toE = pair.avalue;
       const fromE = pair.bvalue;
-      if (toE.enum !== fromE.enum) {
-        if (toE.value && fromE.value) {
-          const result = cloneType(toE.value);
-          unionInto(result, fromE.value);
-          const e = { value: result };
-          return [e, true];
+      let changed = false;
+      let resultEnum = toE.enum;
+      const s = new Set(
+        Array.isArray(toE.enum) ? toE.enum : [toE.enum]
+      );
+      const size = s.size;
+      (0, import_chunk_X7QCZR3F.forEach)(fromE.enum, (e) => s.add(e));
+      if (size !== s.size) {
+        resultEnum = Array.from(s);
+        changed = true;
+      }
+      let resultValue = toE.value;
+      if (resultValue) {
+        if (fromE.value) {
+          resultValue = cloneType(resultValue);
+          if (unionHelper(resultValue, fromE.value, widenDepth + 1)) {
+            changed = true;
+          }
+        } else {
+          resultValue = void 0;
+          changed = true;
         }
-        return [null, true];
       }
-      if (!toE.value) {
+      if (!changed) {
         return [toE, false];
       }
-      if (!fromE.value) {
-        delete toE.value;
-        return [toE, true];
-      }
-      const toValue = tryUnion(toE.value, fromE.value);
-      if (toValue) {
-        const e = { enum: toE.enum, value: toValue };
-        return [e, true];
-      }
-      return [toE, false];
+      return resultValue ? [{ enum: resultEnum, value: resultValue }, changed] : [{ enum: resultEnum }, changed];
     }
     default:
       unhandledType(pair);
   }
 }
-function mergeObjectValues(to, from) {
+function mergeObjectValues(to, from, widenDepth) {
   if (!to) {
     return [to, false];
   }
@@ -7901,7 +7946,7 @@ function mergeObjectValues(to, from) {
       return;
     }
     const rep = cloneType(value2);
-    if (unionInto(rep, from[key])) {
+    if (unionHelper(rep, from[key], widenDepth + 1)) {
       if (result === to)
         result = { ...result };
       result[key] = rep;
@@ -7991,94 +8036,7 @@ function clearValuesUnder(v, tag, clearTag = false) {
     v.value = newData;
   }
 }
-function widenTypeHelper(t, depth2) {
-  let result = null;
-  forEachUnionComponent(
-    t,
-    t.type & (512 | 1024),
-    (ac) => {
-      if (ac.value == null)
-        return;
-      switch (ac.type) {
-        case 512:
-          if (depth2 > 4) {
-            if (!result)
-              result = cloneType(t);
-            clearValuesUnder(result, ac.type);
-          } else {
-            if (Array.isArray(ac.value)) {
-              let newAData = ac.value;
-              ac.value.forEach((avalue, index) => {
-                const data = widenTypeHelper(avalue, depth2 + 1);
-                if (data) {
-                  if (newAData === ac.value) {
-                    newAData = newAData.slice();
-                  }
-                  newAData[index] = data;
-                }
-              });
-              if (newAData !== ac.value) {
-                if (!result)
-                  result = cloneType(t);
-                setUnionComponent(result, ac.type, newAData);
-              }
-            } else {
-              const v = widenTypeHelper(ac.value, depth2 + 1);
-              if (v) {
-                if (!result)
-                  result = cloneType(t);
-                setUnionComponent(result, ac.type, v);
-              }
-            }
-          }
-          return;
-        case 1024:
-          if (depth2 > 4) {
-            if (!result)
-              result = cloneType(t);
-            clearValuesUnder(result, ac.type);
-          } else {
-            const ddata = ac.value;
-            if (ddata.value) {
-              const key = widenTypeHelper(ddata.key, depth2 + 1);
-              const data = widenTypeHelper(ddata.value, depth2 + 1);
-              if (key || data) {
-                if (!result)
-                  result = cloneType(t);
-                const newDData = { ...ddata };
-                if (key)
-                  newDData.key = key;
-                if (data)
-                  newDData.value = data;
-                setUnionComponent(result, ac.type, newDData);
-              }
-            } else {
-              let newDData = ddata;
-              ddata.forEach((dvalue, dkey) => {
-                const data = widenTypeHelper(dvalue, depth2 + 1);
-                if (data) {
-                  if (newDData === ddata) {
-                    newDData = new Map(newDData);
-                  }
-                  newDData.set(dkey, data);
-                }
-              });
-              if (newDData !== ddata) {
-                if (!result)
-                  result = cloneType(t);
-                setUnionComponent(result, ac.type, newDData);
-              }
-            }
-          }
-          return;
-      }
-    }
-  );
-  return result;
-}
-function widenType(t) {
-  return widenTypeHelper(t, 0);
-}
+var MaxWidenDepth;
 var init_union_type = (0, import_chunk_ABYVSU2C.__esm)({
   "src/type-flow/union-type.ts"() {
     "use strict";
@@ -8089,6 +8047,7 @@ var init_union_type = (0, import_chunk_ABYVSU2C.__esm)({
     init_intersection_type();
     init_sub_type();
     init_types();
+    MaxWidenDepth = 4;
   }
 });
 function expandTypedef(t) {
@@ -8109,10 +8068,7 @@ function intersectEnum(t, e) {
     /* Enum */
   );
   const e2 = cloneType(e);
-  const i = intersection(
-    t,
-    !enumData ? { type: EnumTagsConst } : enumData.value ? enumData.value : enumData.enum?.resolvedType || { type: EnumTagsConst }
-  );
+  const i = intersection(t, typeFromEnumValue(enumData));
   if (e2.value != null) {
     clearValuesUnder(e2, 65536, true);
   } else {
@@ -8221,35 +8177,49 @@ function intersectionValue(pair) {
     case 128:
     case 131072:
       return pair.avalue === pair.bvalue ? pair.avalue : null;
-    case 512: {
-      if (Array.isArray(pair.avalue)) {
-        const bv = pair.bvalue;
-        if (Array.isArray(bv)) {
-          if (pair.avalue.length !== bv.length) {
-            return null;
-          }
-          const isect2 = pair.avalue.map((t, i) => intersection(t, bv[i]));
-          return isect2.some(
-            (t) => t.type === 0
-            /* Never */
-          ) ? null : isect2;
+    case 512:
+      return tupleMap(
+        pair.avalue,
+        (av) => tupleMap(
+          pair.bvalue,
+          (bv) => {
+            if (av.length !== bv.length)
+              return null;
+            const isect = av.map((t, i) => intersection(t, bv[i]));
+            return isect.some(
+              (t) => t.type === 0
+              /* Never */
+            ) ? null : isect;
+          },
+          (bv) => {
+            const isect = av.map((t) => intersection(bv, t));
+            return isect.some(
+              (t) => t.type === 0
+              /* Never */
+            ) ? null : isect;
+          },
+          (bv) => bv.length === 0 ? null : bv
+        ),
+        (av) => tupleMap(
+          pair.bvalue,
+          (bv) => {
+            const isect = bv.map((t) => intersection(av, t));
+            return isect.some(
+              (t) => t.type === 0
+              /* Never */
+            ) ? null : isect;
+          },
+          (bv) => {
+            const atype = intersection(av, bv);
+            return atype.type === 0 ? null : atype;
+          },
+          (bv) => bv.length === 0 ? null : bv
+        ),
+        (av) => {
+          const result = av.flat(1);
+          return result.length === 0 ? null : tupleReduce(result);
         }
-        const isect = pair.avalue.map((t) => intersection(t, bv));
-        return isect.some(
-          (t) => t.type === 0
-          /* Never */
-        ) ? null : isect;
-      } else if (Array.isArray(pair.bvalue)) {
-        const av = pair.avalue;
-        const isect = pair.bvalue.map((t) => intersection(av, t));
-        return isect.some(
-          (t) => t.type === 0
-          /* Never */
-        ) ? null : isect;
-      }
-      const atype = intersection(pair.avalue, pair.bvalue);
-      return atype.type === 0 ? null : atype;
-    }
+      );
     case 1024: {
       if (!pair.avalue.value) {
         if (!pair.bvalue.value) {
@@ -8327,19 +8297,21 @@ function intersectionValue(pair) {
       return klass.type !== 16384 || klass.value == null ? null : obj ? { klass, obj } : { klass };
     }
     case 65536: {
-      if (pair.avalue.enum !== pair.bvalue.enum && pair.avalue.enum && pair.bvalue.enum) {
-        return null;
-      }
-      const enumDecl = pair.avalue.enum || pair.bvalue.enum;
-      if (pair.avalue.value != null) {
-        if (pair.bvalue.value != null) {
-          const value2 = intersection(pair.avalue.value, pair.bvalue.value);
-          const e = { enum: enumDecl, value: value2 };
-          return e;
+      let enumDecl;
+      if (Array.isArray(pair.avalue.enum)) {
+        const s = new Set(pair.avalue.enum);
+        const enums = [];
+        (0, import_chunk_X7QCZR3F.forEach)(pair.bvalue.enum, (b) => s.has(b) && enums.push(b));
+        if (enums.length) {
+          enumDecl = enums.length === 1 ? enums[0] : enums;
         }
-        return pair.avalue.value;
+      } else {
+        (0, import_chunk_X7QCZR3F.some)(pair.bvalue.enum, (b) => b === pair.avalue.enum) && (enumDecl = pair.bvalue.enum);
       }
-      return pair.bvalue;
+      if (!enumDecl)
+        return null;
+      const enumValue = pair.avalue.value != null ? pair.bvalue.value != null ? intersection(pair.avalue.value, pair.bvalue.value) : pair.avalue.value : pair.bvalue.value;
+      return { enum: enumDecl, value: enumValue };
     }
     default:
       unhandledType(pair);
@@ -8371,12 +8343,7 @@ function fixupEnum(a, b_restricted, b) {
       65536
       /* Enum */
     );
-    const br = restrictByEquality(
-      a,
-      bvalue && (bvalue.value || bvalue.enum?.resolvedType) || {
-        type: EnumTagsConst
-      }
-    );
+    const br = restrictByEquality(a, typeFromEnumValue(bvalue));
     if (br.type) {
       b_restricted = cloneType(b_restricted);
       unionInto(
@@ -8544,12 +8511,7 @@ function restrictExactTypesByEquality(a, b) {
     case 131072:
       return intersection(a, b);
     case 65536: {
-      return restrictByEquality(
-        a.value && (a.value.value || a.value.enum?.resolvedType) || {
-          type: EnumTagsConst
-        },
-        b
-      );
+      return restrictByEquality(typeFromEnumValue(a.value), b);
     }
     case 262144:
       return restrictByEquality(
@@ -8640,12 +8602,7 @@ function subtypeOf(a, b) {
       65536
       /* Enum */
     );
-    if (!subtypeOf(
-      value2 != null && (value2.value || value2.enum?.resolvedType) || {
-        type: EnumTagsConst
-      },
-      b
-    )) {
+    if (!subtypeOf(typeFromEnumValue(value2), b)) {
       return false;
     }
     if (a.type === 65536)
@@ -8693,19 +8650,34 @@ function subtypeOfValue(pair) {
     case 131072:
       return pair.avalue === pair.bvalue;
     case 512: {
-      if (Array.isArray(pair.avalue)) {
-        const bv = pair.bvalue;
-        if (Array.isArray(bv)) {
-          if (pair.avalue.length !== bv.length) {
-            return false;
-          }
-          return pair.avalue.every((t, i) => subtypeOf(t, bv[i]));
+      let result = true;
+      tupleForEach(
+        pair.avalue,
+        (av) => {
+          let some2 = false;
+          tupleForEach(
+            pair.bvalue,
+            (bv) => {
+              some2 = av.length === bv.length && bv.every((b, i) => subtypeOf(av[i], b));
+              return some2 === false;
+            },
+            (bv) => (some2 = av.every((a) => subtypeOf(a, bv))) === false
+          );
+          return result = some2;
+        },
+        (av) => {
+          let some2 = false;
+          tupleForEach(
+            pair.bvalue,
+            () => {
+              return true;
+            },
+            (bv) => (some2 = subtypeOf(av, bv)) === false
+          );
+          return result = some2;
         }
-        return pair.avalue.every((t) => subtypeOf(t, bv));
-      } else if (Array.isArray(pair.bvalue)) {
-        return false;
-      }
-      return subtypeOf(pair.avalue, pair.bvalue);
+      );
+      return result;
     }
     case 1024: {
       const adict = pair.avalue;
@@ -8757,7 +8729,12 @@ function subtypeOfValue(pair) {
     case 65536: {
       const aenum = pair.avalue;
       const benum = pair.bvalue;
-      return aenum.enum === benum.enum && (!aenum.value || !benum.value || subtypeOf(aenum.value, benum.value));
+      if (benum.value) {
+        if (!aenum.value || !subtypeOf(aenum.value, benum.value)) {
+          return false;
+        }
+      }
+      return (0, import_chunk_X7QCZR3F.every)(aenum.enum, (ea) => (0, import_chunk_X7QCZR3F.some)(benum.enum, (eb) => ea === eb));
     }
     default:
       unhandledType(pair);
@@ -9472,7 +9449,7 @@ function checkCallArgs(istate, node, callees, args) {
       if (object) {
         const info = sysCallInfo(istate.state, cur);
         if (info) {
-          const result2 = info(istate.state, cur, object, () => args);
+          const result2 = info(istate, cur, object, () => args);
           if (result2.argTypes)
             argTypes = result2.argTypes;
           if (result2.returnType)
@@ -9481,6 +9458,8 @@ function checkCallArgs(istate, node, callees, args) {
             effects = false;
           if (!result2.argEffects)
             argEffects = false;
+          if (result2.diagnostic)
+            curDiags.push([node, result2.diagnostic]);
         }
       }
       if (cur.info === false) {
@@ -9514,7 +9493,7 @@ function checkCallArgs(istate, node, callees, args) {
             paramType = typeFromTypespec(istate.state, param.right, cur.stack);
           }
           if (checker(arg, paramType)) {
-            if (istate.state.config?.covarianceWarnings && effects && argEffects) {
+            if (istate.state.config?.extraReferenceTypeChecks && effects && argEffects && !safeReferenceArg(node.arguments[i])) {
               if (arg.type & 512) {
                 const atype = getUnionComponent(
                   arg,
@@ -9527,7 +9506,7 @@ function checkCallArgs(istate, node, callees, args) {
                     512
                     /* Array */
                   );
-                  if (!ptype || Array.isArray(ptype) || Array.isArray(atype) || !subtypeOf(ptype, atype)) {
+                  if (!ptype || !checkArrayCovariance(atype, ptype)) {
                     curDiags.push([
                       node.arguments[i],
                       `Argument ${i + 1} to ${cur.fullName}: passing ${display(
@@ -9709,7 +9688,7 @@ function getSystemCallTable(state) {
     }
     return ret;
   };
-  const arrayAdd = (state2, callee, calleeObj, getArgs) => {
+  const arrayAdd = (istate, callee, calleeObj, getArgs) => {
     const ret = {};
     if (calleeObj.type & 512) {
       const adata = getUnionComponent(
@@ -9722,54 +9701,97 @@ function getSystemCallTable(state) {
         const args = getArgs();
         if (args.length === 1) {
           const arg = args[0];
+          let hasTuple = false;
           if (callee.name === "add") {
-            if (Array.isArray(adata)) {
-              const relaxed = relaxType(arg);
-              const newAData = [...adata, relaxed];
-              ret.returnType.value = newAData;
-              ret.argTypes = [relaxed];
-              ret.calleeObj = ret.returnType;
-            } else if (!subtypeOf(arg, adata)) {
-              const newAData = cloneType(adata);
-              unionInto(newAData, arg);
-              const newObj = cloneType(calleeObj);
-              setUnionComponent(newObj, 512, newAData);
-              ret.calleeObj = newObj;
-              ret.argTypes = [adata];
-            }
+            const relaxed = relaxType(arg);
+            tupleMap(
+              adata,
+              (v) => {
+                hasTuple = true;
+                return [...v, relaxed];
+              },
+              (v) => {
+                if (subtypeOf(arg, v))
+                  return v;
+                const newAData = cloneType(v);
+                unionInto(newAData, arg);
+                if (!ret.argTypes) {
+                  ret.argTypes = [v];
+                } else {
+                  ret.argTypes = [intersection(ret.argTypes[0], v)];
+                }
+                return newAData;
+              },
+              (v) => {
+                const newAData = tupleReduce(v);
+                ret.returnType.value = newAData;
+                const newObj = cloneType(calleeObj);
+                setUnionComponent(newObj, 512, newAData);
+                ret.calleeObj = newObj;
+                if (!ret.argTypes) {
+                  ret.argTypes = [relaxed];
+                }
+              }
+            );
           } else {
-            if (Array.isArray(adata)) {
-              if (arg.type & 512) {
-                const argSubtypes = getUnionComponent(
-                  arg,
-                  512
-                  /* Array */
-                );
-                if (argSubtypes) {
-                  if (Array.isArray(argSubtypes)) {
-                    const newAData2 = [...adata, ...argSubtypes];
-                    ret.returnType.value = newAData2;
-                    ret.argTypes = [arg];
-                    ret.calleeObj = ret.returnType;
-                    return ret;
+            const argSubtypes = arg.type & 512 ? getUnionComponent(
+              arg,
+              512
+              /* Array */
+            ) : null;
+            if (argSubtypes) {
+              tupleMap(
+                adata,
+                (v) => {
+                  hasTuple = true;
+                  return tupleMap(
+                    argSubtypes,
+                    (a) => [...v, ...a],
+                    (a) => {
+                      const at = cloneType(reducedType(v));
+                      unionInto(at, a);
+                      return at;
+                    },
+                    (a) => a
+                  );
+                },
+                (v) => {
+                  const addedType = reducedArrayType(argSubtypes);
+                  if (subtypeOf(addedType, v))
+                    return [v];
+                  if (!ret.argTypes) {
+                    ret.argTypes = [v];
+                  } else {
+                    ret.argTypes = [intersection(ret.argTypes[0], v)];
                   }
-                  const newAData = reducedType(adata);
-                  unionInto(newAData, argSubtypes);
+                  v = cloneType(v);
+                  unionInto(v, addedType);
+                  return [v];
+                },
+                (va) => {
+                  const newAData = tupleReduce(va.flat());
                   ret.returnType.value = newAData;
-                  ret.argTypes = [arg];
-                  ret.calleeObj = ret.returnType;
-                  return ret;
+                  const newObj = cloneType(calleeObj);
+                  setUnionComponent(newObj, 512, newAData);
+                  ret.calleeObj = newObj;
+                  if (!ret.argTypes) {
+                    ret.argTypes = [
+                      { type: 512, value: argSubtypes }
+                    ];
+                  }
                 }
-              }
-              ret.returnType.value = reducedType(adata);
-            }
-            if (!subtypeOf(arg, ret.returnType)) {
-              ret.argTypes = [ret.returnType];
-              const newObj = cloneType(calleeObj);
-              unionInto(newObj, arg);
-              ret.calleeObj = newObj;
+              );
+            } else {
+              tupleForEach(
+                adata,
+                () => hasTuple = true,
+                () => false
+              );
             }
           }
+          if (hasTuple && istate.typeChecker && istate.state.config?.extraReferenceTypeChecks !== false) {
+            ret.diagnostic = "Adding to a tuple would change its type";
+          }
         }
       }
     }
@@ -9959,7 +9981,7 @@ function getSystemCallTable(state) {
     ret.argTypes = getArgs();
     return ret;
   };
-  const method = (state2, callee, calleeObj, getArgs) => {
+  const method = (istate, callee, calleeObj, getArgs) => {
     const ret = {};
     const args = getArgs();
     if (args.length === 1 && hasValue(args[0]) && args[0].type === 131072) {
@@ -9974,7 +9996,7 @@ function getSystemCallTable(state) {
         computed: false
       };
       const [, trueDecls] = findObjectDeclsByProperty(
-        state2,
+        istate.state,
         calleeObj,
         next.property
       );
@@ -9988,7 +10010,7 @@ function getSystemCallTable(state) {
       ret.returnType = callees.reduce(
         (type, callee2) => {
           const result = callee2.node.returnType ? typeFromTypespec(
-            state2,
+            istate.state,
             callee2.node.returnType.argument,
             callee2.stack
           ) : {
@@ -9996,7 +10018,7 @@ function getSystemCallTable(state) {
             /* Any */
           };
           const args2 = callee2.node.params.map(
-            (param) => param.type === "BinaryExpression" ? typeFromTypespec(state2, param.right, callee2.stack) : {
+            (param) => param.type === "BinaryExpression" ? typeFromTypespec(istate.state, param.right, callee2.stack) : {
               type: 524287
               /* Any */
             }
@@ -10017,7 +10039,7 @@ function getSystemCallTable(state) {
   };
   const nop = () => ({ effectFree: true });
   const mod = () => ({});
-  const rounder = (state2, callee, calleeObj, getArgs) => {
+  const rounder = (istate, callee, calleeObj, getArgs) => {
     const results = {};
     const fn = Math[callee.name];
     results.effectFree = true;
@@ -10039,7 +10061,7 @@ function getSystemCallTable(state) {
     };
     return results;
   };
-  const mathHelper = (state2, callee, calleeObj, getArgs, helper) => {
+  const mathHelper = (istate, callee, calleeObj, getArgs, helper) => {
     const results = {};
     const fn = helper && typeof helper === "function" ? helper : (0, import_chunk_JDC43A3I.hasProperty)(Math, helper || callee.name) && Math[helper || callee.name];
     if (fn && typeof fn === "function") {
@@ -10188,6 +10210,7 @@ var init_interp_call = (0, import_chunk_ABYVSU2C.__esm)({
     init_optimizer_types();
     (0, import_chunk_X7QCZR3F.init_util)();
     init_interp();
+    init_intersection_type();
     init_sub_type();
     init_type_flow_util();
     init_types();
@@ -10447,32 +10470,31 @@ function deEnumerate(t) {
     );
     t = cloneType(t);
     clearValuesUnder(t, 65536, true);
-    unionInto(
-      t,
-      data && (data.value || data.enum?.resolvedType) || {
-        type: EnumTagsConst
-      }
-    );
+    unionInto(t, typeFromEnumValue(data));
   }
   return t;
 }
-function arrayTypeAtIndex(arr, elemType) {
-  if (Array.isArray(arr)) {
-    if (elemType && isExact(elemType) && elemType.type === 8 && elemType.value != null && arr[elemType.value] != null) {
-      return arr[elemType.value];
+function arrayTypeAtIndex(arr, elemType, forStrictAssign, enforceTuples) {
+  const reduce2 = (v) => forStrictAssign ? v.reduce(
+    (t, c) => t ? intersection(t, c) : c,
+    null
+  ) ?? {
+    type: 0
+    /* Never */
+  } : reducedType(v);
+  const key = elemType && isExact(elemType) && elemType.type === 8 ? elemType.value : null;
+  return tupleMap(
+    arr,
+    (v) => key != null ? v[key] ?? null : reduce2(v),
+    (v) => v,
+    (v) => v.length ? reduce2(v) : enforceTuples ? {
+      type: 0
+      /* Never */
+    } : {
+      type: 524287
+      /* Any */
     }
-    return arr.reduce(
-      (p, v) => {
-        unionInto(p, v);
-        return p;
-      },
-      {
-        type: 0
-        /* Never */
-      }
-    );
-  }
-  return arr;
+  );
 }
 function getLhsConstraint(istate, node) {
   if (istate.localLvals?.has(node)) {
@@ -10502,7 +10524,15 @@ function getLhsConstraint(istate, node) {
               /* Array */
             );
             if (arr) {
-              result = arrayTypeAtIndex(arr, istate.typeMap.get(node.property));
+              result = arrayTypeAtIndex(
+                arr,
+                istate.typeMap.get(node.property) ?? {
+                  type: 8,
+                  value: arrayLiteralKeyFromExpr(node.property) ?? void 0
+                },
+                strict,
+                istate.state.config?.extraReferenceTypeChecks !== false
+              );
             }
           }
           const updateResult = (value2) => {
@@ -10968,7 +10998,7 @@ function evaluateNode(istate, node) {
               type: 524287
               /* Any */
             };
-            const atype = arrayTypeAtIndex(avalue, property.value);
+            const atype = arrayTypeAtIndex(avalue, property.value, false, true);
             if (result) {
               unionInto(result = cloneType(result), atype);
             } else {
@@ -11983,11 +12013,8 @@ function mcExprFromType(type) {
       if (type.value.value && hasValue(type.value.value)) {
         const left = mcExprFromType(type.value.value);
         if (left) {
-          if (!type.value.enum) {
-            return left;
-          }
-          const enumStr = type.value.enum.fullName.slice(2);
-          if (enumStr === "Toybox.Graphics.ColorValue" && left.type === "Literal" && typeof left.value === "number" && left.value >= 0 && left.value <= 16777215 && /^\d+$/.test(left.raw)) {
+          const enumStrs = (0, import_chunk_X7QCZR3F.map)(type.value.enum, (e) => e.fullName.slice(2));
+          if (enumStrs.length === 1 && enumStrs[0] === "Toybox.Graphics.ColorValue" && left.type === "Literal" && typeof left.value === "number" && left.value >= 0 && left.value <= 16777215 && /^\d+$/.test(left.raw)) {
             left.raw = "0x" + `00000${left.value.toString(16)}`.slice(-6);
           }
           return {
@@ -11996,7 +12023,7 @@ function mcExprFromType(type) {
             left,
             right: {
               type: "TypeSpecList",
-              ts: [type.value.enum.fullName.slice(2)]
+              ts: enumStrs
             }
           };
         }
@@ -12085,7 +12112,7 @@ function reducedType(elems) {
   if (!Array.isArray(elems)) {
     return elems;
   }
-  return elems.reduce(
+  return elems.flat().reduce(
     (p, t) => {
       unionInto(p, t);
       return p;
@@ -12121,7 +12148,12 @@ function display(type) {
       case 256:
         return JSON.stringify(tv.value);
       case 512:
-        return Array.isArray(tv.value) ? `[${tv.value.map((t) => display(t)).join(", ")}]` : `Array<${display(tv.value)}>`;
+        return tupleMap(
+          tv.value,
+          (v) => `[${v.map((t) => display(t)).join(", ")}]`,
+          (v) => `Array<${display(v)}>`,
+          (v) => v.join(" or ")
+        );
       case 1024:
         return tv.value.value ? `Dictionary<${display(tv.value.key)}, ${display(tv.value.value)}>` : `{ ${Array.from(tv.value).map(
           ([key, value2]) => `${display(typeFromObjectLiteralKey(key))} as ${display(
@@ -12145,7 +12177,8 @@ function display(type) {
       }
       case 65536: {
         const v = tv.value;
-        return v.enum != null ? v.value != null ? `${display(v.value)} as ${v.enum.fullName.slice(2)}` : v.enum.fullName.slice(2) : v.value != null ? `enum<${display(v.value)}>` : `enum`;
+        const name = v.enum ? (0, import_chunk_X7QCZR3F.map)(v.enum, (e) => e.fullName.slice(2)).join(" or ") : "";
+        return v.value != null ? `${display(v.value)} as ${name}` : name;
       }
       case 131072:
         return `:${tv.value}`;
@@ -12295,6 +12328,91 @@ function getStateNodeDeclsWithExactFromType(state, object) {
   }
   return decls;
 }
+function tupleForEach(t, tupleFn, arrayFn) {
+  if (t instanceof Set) {
+    for (const v of t) {
+      if ((Array.isArray(v) ? tupleFn(v) : arrayFn(v)) === false) {
+        break;
+      }
+    }
+  } else {
+    if (Array.isArray(t)) {
+      tupleFn(t);
+    } else {
+      arrayFn(t);
+    }
+  }
+}
+function tupleMap(t, tupleFn, arrayFn, reduceFn) {
+  const result = t instanceof Set ? Array.from(t).map((v) => Array.isArray(v) ? tupleFn(v) : arrayFn(v)) : [Array.isArray(t) ? tupleFn(t) : arrayFn(t)];
+  return reduceFn(result.filter((v) => v != null));
+}
+function tupleReduce(v) {
+  return v.length === 1 ? v[0] : new Set(v);
+}
+function reducedArrayType(t) {
+  if (t instanceof Set) {
+    return reducedType(Array.from(t).map((v) => reducedType(v)));
+  }
+  return reducedType(t);
+}
+function checkArrayCovariance(arg, param) {
+  let ok = true;
+  tupleForEach(
+    arg,
+    (av) => {
+      tupleForEach(
+        param,
+        (pv) => {
+          if (av.length !== pv.length)
+            return true;
+          if (!av.every((a, i) => subtypeOf(a, pv[i])))
+            return true;
+          if (!av.every((a, i) => subtypeOf(pv[i], a))) {
+            ok = false;
+          }
+          return ok !== false;
+        },
+        () => {
+          ok = false;
+          return false;
+        }
+      );
+      return ok !== false;
+    },
+    (av) => {
+      tupleForEach(
+        param,
+        () => {
+          return ok !== false;
+        },
+        (pv) => {
+          if (subtypeOf(av, pv) && !subtypeOf(pv, av)) {
+            ok = false;
+          }
+          return ok !== false;
+        }
+      );
+      return ok !== false;
+    }
+  );
+  return ok;
+}
+function safeReferenceArg(arg) {
+  return arg.type === "ArrayExpression" || arg.type === "ObjectExpression" || arg.type === "NewExpression";
+}
+function typeFromEnumValue(arg) {
+  return arg?.value ?? (arg && reducedType(
+    (0, import_chunk_X7QCZR3F.map)(
+      arg.enum,
+      (e) => e.resolvedType ?? {
+        type: EnumTagsConst
+      }
+    )
+  )) ?? {
+    type: EnumTagsConst
+  };
+}
 var LastTypeTag, SingletonTypeTagsConst, UnionDataTypeTagsConst, ValueTypeTagsConst, ObjectLikeTagsConst, EnumTagsConst, TruthyTypes;
 var init_types = (0, import_chunk_ABYVSU2C.__esm)({
   "src/type-flow/types.ts"() {
@@ -12306,6 +12424,7 @@ var init_types = (0, import_chunk_ABYVSU2C.__esm)({
     init_interp();
     init_intersection_type();
     init_union_type();
+    init_sub_type();
     LastTypeTag = 262144;
     SingletonTypeTagsConst = 1 | 2 | 4;
     UnionDataTypeTagsConst = 512 | 1024 | 2048 | 4096 | 8192 | 16384 | 32768 | 65536 | 262144;
@@ -12403,24 +12522,40 @@ function couldBeValue(pair, shallow) {
     case 128:
     case 131072:
       return pair.avalue === pair.bvalue;
-    case 512:
+    case 512: {
       if (shallow)
         return true;
-      if (Array.isArray(pair.avalue)) {
-        const bv = pair.bvalue;
-        if (Array.isArray(bv)) {
-          if (pair.avalue.length !== bv.length) {
-            return false;
-          }
-          return pair.avalue.every((a, i) => couldBe(a, bv[i]));
+      let result = false;
+      tupleForEach(
+        pair.avalue,
+        (av) => {
+          tupleForEach(
+            pair.bvalue,
+            (bv) => {
+              result = av.length === bv.length && bv.every((b, i) => couldBe(av[i], b));
+              return result === false;
+            },
+            (bv) => {
+              result = av.every((a) => couldBe(a, bv));
+              return result === false;
+            }
+          );
+          return result === false;
+        },
+        (av) => {
+          tupleForEach(
+            pair.bvalue,
+            (bv) => {
+              result = bv.every((b) => couldBe(av, b));
+              return result === false;
+            },
+            (bv) => (result = couldBe(av, bv)) === false
+          );
+          return result === false;
         }
-        return pair.avalue.every((a) => couldBe(a, bv));
-      }
-      if (Array.isArray(pair.bvalue)) {
-        const av = pair.avalue;
-        return pair.bvalue.every((b) => couldBe(av, b));
-      }
-      return couldBe(pair.avalue, pair.bvalue);
+      );
+      return result;
+    }
     case 1024: {
       if (shallow)
         return true;
@@ -12455,7 +12590,10 @@ function couldBeValue(pair, shallow) {
       return couldBe(pair.avalue.klass, pair.bvalue.klass) && (shallow || couldBeObj(pair.avalue.obj, pair.bvalue.obj));
     }
     case 65536: {
-      return pair.avalue.enum === pair.bvalue.enum && (!pair.avalue.value || !pair.bvalue.value || couldBe(pair.avalue.value, pair.bvalue.value));
+      return (!pair.avalue.value || !pair.bvalue.value || couldBe(pair.avalue.value, pair.bvalue.value)) && (0, import_chunk_X7QCZR3F.some)(
+        pair.avalue.enum,
+        (sna) => (0, import_chunk_X7QCZR3F.some)(pair.bvalue.enum, (snb) => sna === snb)
+      );
     }
     default:
       unhandledType(pair);
@@ -13160,14 +13298,9 @@ function mergeTypeState(blockStates, index, from, nodeCopyProp) {
         return;
       }
     }
-    let result = cloneType(tov.curType);
-    if (!unionInto(result, fromv.curType))
+    const result = cloneType(tov.curType);
+    if (!unionHelper(result, fromv.curType, widen ? 0 : -Infinity))
       return;
-    if (widen) {
-      const wide = widenType(result);
-      if (wide)
-        result = wide;
-    }
     tov.curType = result;
     changes = true;
   });
@@ -13238,11 +13371,11 @@ function updateAffected(blockState, objectType, baseDecl, assignedPath, affected
               /* Array */
             );
             if (atype) {
-              if (Array.isArray(atype)) {
-                atype.forEach((value2) => unionInto(newType, value2));
-              } else {
-                unionInto(newType, atype);
-              }
+              tupleForEach(
+                atype,
+                (v) => v.forEach((value2) => unionInto(newType, value2)),
+                (v) => unionInto(newType, v)
+              );
             }
           }
           if (type.type & 1024) {
@@ -13370,7 +13503,7 @@ function propagateTypes(state, root, graph, optimizeEquivalencies, copyPropStore
             next = t;
           }
           if (cur.type & 512) {
-            let avalue = getUnionComponent(
+            const avalue = getUnionComponent(
               cur,
               512
               /* Array */
@@ -13378,29 +13511,41 @@ function propagateTypes(state, root, graph, optimizeEquivalencies, copyPropStore
               type: 524287
               /* Any */
             };
-            if (Array.isArray(avalue)) {
-              const index = arrayLiteralKeyFromExpr(me.property);
-              if (index != null && avalue[index] != null) {
-                if (!next) {
-                  assocValue[i].keyStr = index;
+            const index = arrayLiteralKeyFromExpr(me.property);
+            tupleForEach(
+              avalue,
+              (av) => {
+                let possibleValues = av;
+                if (index != null) {
+                  if (av[index] != null) {
+                    if (!next) {
+                      assocValue[i].keyStr = index;
+                    }
+                    possibleValues = av[index];
+                  } else {
+                    possibleValues = {
+                      type: 0
+                      /* Never */
+                    };
+                  }
+                }
+                if (next || i !== l || !newValue) {
+                  const n = next ? cloneType(next) : {
+                    type: 0
+                    /* Never */
+                  };
+                  (0, import_chunk_X7QCZR3F.forEach)(possibleValues, (v) => unionInto(n, v));
+                  next = n;
+                }
+              },
+              (av) => {
+                if (next) {
+                  unionInto(next = cloneType(next), av);
+                } else {
+                  next = av;
                 }
-                avalue = avalue[index];
-              }
-              if (next || i !== l || !newValue) {
-                const n = next ? cloneType(next) : {
-                  type: 0
-                  /* Never */
-                };
-                (0, import_chunk_X7QCZR3F.forEach)(avalue, (v) => unionInto(n, v));
-                next = n;
-              }
-            } else {
-              if (next) {
-                unionInto(next = cloneType(next), avalue);
-              } else {
-                next = avalue;
               }
-            }
+            );
           }
           let isExact2 = false;
           if (cur.type & 1024) {
@@ -13679,7 +13824,7 @@ function propagateTypes(state, root, graph, optimizeEquivalencies, copyPropStore
         return;
       }
       const result = info(
-        istate.state,
+        istate,
         callee,
         calleeObj,
         () => node.arguments.map((arg) => evaluateExpr(state, arg, typeMap).value)
@@ -14765,24 +14910,39 @@ function updateByAssocPath(path7, property, update) {
           512
           /* Array */
         );
-        if (Array.isArray(avalue)) {
-          const key = pathElem.keyStr;
-          const relaxed = relaxType(property);
-          if (typeof key === "number" && key >= 0 && key < avalue.length) {
-            avalue = avalue.slice();
-            avalue[key] = relaxed;
-          } else {
-            avalue = avalue.map((v) => {
-              v = cloneType(v);
-              unionInto(v, relaxed);
-              return v;
-            });
-          }
-        } else {
-          avalue = valueToStore(avalue);
+        const key = pathElem.keyStr;
+        const relaxed = relaxType(property);
+        if (avalue) {
+          avalue = tupleMap(
+            avalue,
+            (v) => {
+              if (typeof key === "number") {
+                if (key < 0 || key >= v.length) {
+                  return null;
+                }
+                v = v.slice();
+                v[key] = relaxed;
+                return v;
+              }
+              return v.map((v2) => {
+                v2 = cloneType(v2);
+                unionInto(v2, relaxed);
+                return v2;
+              });
+            },
+            (v) => valueToStore(v),
+            tupleReduce
+          );
         }
         object = cloneType(object);
-        setUnionComponent(object, 512, avalue);
+        setUnionComponent(
+          object,
+          512,
+          avalue ?? {
+            type: 524287
+            /* Any */
+          }
+        );
       }
       if (object.type & 1024) {
         const dvalue = getUnionComponent(
@@ -17024,6 +17184,7 @@ async function analyze(fnMap, resourcesMap, manifestXML, config, allowParseError
     allClasses: [],
     nestedClasses: {},
     allModules: /* @__PURE__ */ new Set(),
+    allTypedefs: /* @__PURE__ */ new Set(),
     shouldExclude(node) {
       if ("attrs" in node && node.attrs && "attributes" in node.attrs && node.attrs.attributes && node.loc?.source) {
         const excludeAnnotations = fnMap[node.loc.source].excludeAnnotations;
@@ -17716,7 +17877,7 @@ async function optimizeMonkeyCHelper(fnMap, resourcesMap, manifestXML, config) {
               changes |= 1;
               this.removeNodeComments(node, f.ast);
             } else if (ret) {
-              if (node.type === "EnumDeclaration" && ret.type === "TypedefDeclaration" && ret.ts.argument.ts.length > 1) {
+              if (node.type === "EnumDeclaration" && ret.type === "TypedefDeclaration") {
                 changes |= 2;
               } else {
                 changes |= 1;
@@ -17725,6 +17886,9 @@ async function optimizeMonkeyCHelper(fnMap, resourcesMap, manifestXML, config) {
             return ret;
           };
           collectNamespaces(f.ast, state2);
+          if (changes & 2) {
+            state2.allTypedefs?.forEach((t) => delete t.resolvedType);
+          }
           return changes;
         },
         0
@@ -17916,14 +18080,10 @@ function cleanup(state, node, ast, usedNodes) {
           (d) => d.type === "EnumDeclaration" && d.node === node
         );
         if (i >= 0) {
-          const old = decls[i];
-          const rep = {
-            ...old,
-            type: "TypedefDeclaration",
-            node: typedefDecl
-          };
+          const rep = decls[i];
+          rep.type = "TypedefDeclaration";
+          rep.node = typedefDecl;
           delete rep.resolvedType;
-          decls.splice(i, 1, rep);
         }
       }
       return typedefDecl;
@@ -18383,8 +18543,11 @@ function visit_resource_refs(state, doc, e, barrelNames) {
             loc.start.offset -= name.length;
           }
         } else {
-          const base = (0, import_chunk_JDC43A3I.makeScopedName)(`Rez.Styles`);
-          const idLoc = (0, import_chunk_JDC43A3I.adjustLoc)(loc, 0, 0);
+          const colonPos = name.indexOf(":");
+          const barrel = colonPos < 0 ? "" : name.slice(0, colonPos) + ".";
+          name = name.slice(colonPos + 1);
+          const base = (0, import_chunk_JDC43A3I.makeScopedName)(`${barrel}Rez.Styles`);
+          const idLoc = (0, import_chunk_JDC43A3I.adjustLoc)(loc, colonPos + 1, 0);
           idLoc.end = { ...idLoc.start };
           idLoc.end.column += name.length;
           idLoc.end.offset += name.length;
@@ -18478,35 +18641,41 @@ function add_one_resource(state, doc, module2, e, barrelNames) {
   let func;
   const makeVarDecl = (id2, outer) => {
     const loc = id2 && (0, import_chunk_JDC43A3I.adjustLoc)(id2.value.loc);
+    const declarations = [];
+    if (id2) {
+      declarations.push({
+        type: "VariableDeclarator",
+        kind: "var",
+        id: {
+          type: "BinaryExpression",
+          operator: "as",
+          left: (0, import_chunk_JDC43A3I.makeIdentifier)(id2.value.value, loc),
+          right: {
+            type: "TypeSpecList",
+            ts: [
+              {
+                type: "TypeSpecPart",
+                name: (0, import_chunk_JDC43A3I.makeScopedName)(
+                  (state?.sdkVersion ?? 0) >= 7e6 ? "Toybox.Lang.ResourceId" : "Toybox.Lang.Symbol"
+                )
+              }
+            ]
+          }
+        }
+      });
+    }
+    if (init) {
+      declarations.push({
+        type: "VariableDeclarator",
+        kind: "var",
+        id: (0, import_chunk_JDC43A3I.makeIdentifier)("*invalid*"),
+        init
+      });
+    }
     return (0, import_chunk_JDC43A3I.wrap)(
       {
         type: "VariableDeclaration",
-        declarations: [
-          (0, import_chunk_JDC43A3I.wrap)(
-            {
-              type: "VariableDeclarator",
-              kind: "var",
-              id: id2 && !init ? {
-                type: "BinaryExpression",
-                operator: "as",
-                left: (0, import_chunk_JDC43A3I.makeIdentifier)(id2.value.value, loc),
-                right: {
-                  type: "TypeSpecList",
-                  ts: [
-                    {
-                      type: "TypeSpecPart",
-                      name: (0, import_chunk_JDC43A3I.makeScopedName)(
-                        (state?.sdkVersion ?? 0) >= 7e6 ? "Toybox.Lang.ResourceId" : "Toybox.Lang.Symbol"
-                      )
-                    }
-                  ]
-                }
-              } : (0, import_chunk_JDC43A3I.makeIdentifier)(id2 ? id2.value.value : "*invalid*", loc),
-              init
-            },
-            outer
-          )
-        ],
+        declarations: declarations.map((d) => (0, import_chunk_JDC43A3I.wrap)(d, outer)),
         kind: "var"
       },
       outer
@@ -19659,6 +19828,8 @@ function stateFuncs() {
                 parent.type_decls[name].push(decl);
                 if (decl.type === "EnumDeclaration") {
                   currentEnum = decl;
+                } else {
+                  this.allTypedefs?.add(decl);
                 }
                 break;
               }
@@ -30242,7 +30413,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
       const opt_time = await (0, import_chunk_X7QCZR3F.first_modified)(
         Object.values(fnMap).map((v) => v.output)
       );
-      if (source_time < opt_time && 1732126457866 < opt_time) {
+      if (source_time < opt_time && 1732680967178 < opt_time) {
         return {
           hasTests,
           diagnostics: prevDiagnostics,
@@ -30280,7 +30451,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             hasTests: hasTests2,
             diagnostics,
             sdkVersion,
-            optimizerVersion: "1.1.81",
+            optimizerVersion: "1.1.83",
             ...Object.fromEntries(
               configOptionsToCheck.map((option) => [option, config[option]])
             )
@@ -30446,7 +30617,7 @@ var init_optimizer = (0, import_chunk_ABYVSU2C.__esm)({
       "minimizeModules",
       "extensionVersion",
       "typeCheckLevel",
-      "covarianceWarnings",
+      "extraReferenceTypeChecks",
       "iterateOptimizer",
       "extraExcludes"
     ];