@markw65/monkeyc-optimizer 1.1.32 → 1.1.34

package/build/api.cjs

@@ -18,44 +18,44 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var api_exports = {};
 __export(api_exports, {
-  checkCompilerVersion: () => import_chunk_NUE3G2QE.checkCompilerVersion,
-  collectNamespaces: () => import_chunk_NUE3G2QE.collectNamespaces,
-  createDocumentationMap: () => import_chunk_NUE3G2QE.createDocumentationMap,
-  diagnostic: () => import_chunk_NUE3G2QE.diagnostic,
-  diagnosticHelper: () => import_chunk_NUE3G2QE.diagnosticHelper,
-  findNamesInScope: () => import_chunk_NUE3G2QE.findNamesInScope,
-  findUsingForNode: () => import_chunk_NUE3G2QE.findUsingForNode,
-  formatAst: () => import_chunk_NUE3G2QE.formatAst,
-  formatAstLongLines: () => import_chunk_NUE3G2QE.formatAstLongLines,
-  getApiFunctionInfo: () => import_chunk_NUE3G2QE.getApiFunctionInfo,
-  getApiMapping: () => import_chunk_NUE3G2QE.getApiMapping,
-  getSuperClasses: () => import_chunk_NUE3G2QE.getSuperClasses,
+  checkCompilerVersion: () => import_chunk_QBCVUVLD.checkCompilerVersion,
+  collectNamespaces: () => import_chunk_QBCVUVLD.collectNamespaces,
+  createDocumentationMap: () => import_chunk_QBCVUVLD.createDocumentationMap,
+  diagnostic: () => import_chunk_QBCVUVLD.diagnostic,
+  diagnosticHelper: () => import_chunk_QBCVUVLD.diagnosticHelper,
+  findNamesInScope: () => import_chunk_QBCVUVLD.findNamesInScope,
+  findUsingForNode: () => import_chunk_QBCVUVLD.findUsingForNode,
+  formatAst: () => import_chunk_QBCVUVLD.formatAst,
+  formatAstLongLines: () => import_chunk_QBCVUVLD.formatAstLongLines,
+  getApiFunctionInfo: () => import_chunk_QBCVUVLD.getApiFunctionInfo,
+  getApiMapping: () => import_chunk_QBCVUVLD.getApiMapping,
+  getSuperClasses: () => import_chunk_QBCVUVLD.getSuperClasses,
   hasProperty: () => import_chunk_MBTLUWXR.hasProperty,
-  isClassVariable: () => import_chunk_NUE3G2QE.isClassVariable,
-  isLocal: () => import_chunk_NUE3G2QE.isLocal,
-  isLookupCandidate: () => import_chunk_NUE3G2QE.isLookupCandidate,
-  isStateNode: () => import_chunk_NUE3G2QE.isStateNode,
-  lookupByFullName: () => import_chunk_NUE3G2QE.lookupByFullName,
-  lookupNext: () => import_chunk_NUE3G2QE.lookupNext,
-  lookupResultContains: () => import_chunk_NUE3G2QE.lookupResultContains,
-  lookupWithType: () => import_chunk_NUE3G2QE.lookupWithType,
-  makeToyboxLink: () => import_chunk_NUE3G2QE.makeToyboxLink,
-  mapVarDeclsByType: () => import_chunk_NUE3G2QE.mapVarDeclsByType,
-  markInvokeClassMethod: () => import_chunk_NUE3G2QE.markInvokeClassMethod,
-  parseSdkVersion: () => import_chunk_NUE3G2QE.parseSdkVersion,
-  sameLookupResult: () => import_chunk_NUE3G2QE.sameLookupResult,
+  isClassVariable: () => import_chunk_QBCVUVLD.isClassVariable,
+  isLocal: () => import_chunk_QBCVUVLD.isLocal,
+  isLookupCandidate: () => import_chunk_QBCVUVLD.isLookupCandidate,
+  isStateNode: () => import_chunk_QBCVUVLD.isStateNode,
+  lookupByFullName: () => import_chunk_QBCVUVLD.lookupByFullName,
+  lookupNext: () => import_chunk_QBCVUVLD.lookupNext,
+  lookupResultContains: () => import_chunk_QBCVUVLD.lookupResultContains,
+  lookupWithType: () => import_chunk_QBCVUVLD.lookupWithType,
+  makeToyboxLink: () => import_chunk_QBCVUVLD.makeToyboxLink,
+  mapVarDeclsByType: () => import_chunk_QBCVUVLD.mapVarDeclsByType,
+  markInvokeClassMethod: () => import_chunk_QBCVUVLD.markInvokeClassMethod,
+  parseSdkVersion: () => import_chunk_QBCVUVLD.parseSdkVersion,
+  sameLookupResult: () => import_chunk_QBCVUVLD.sameLookupResult,
   traverseAst: () => import_chunk_MBTLUWXR.traverseAst,
-  variableDeclarationName: () => import_chunk_NUE3G2QE.variableDeclarationName,
-  visitReferences: () => import_chunk_NUE3G2QE.visitReferences,
-  visit_resources: () => import_chunk_NUE3G2QE.visit_resources,
-  visitorNode: () => import_chunk_NUE3G2QE.visitorNode
+  variableDeclarationName: () => import_chunk_QBCVUVLD.variableDeclarationName,
+  visitReferences: () => import_chunk_QBCVUVLD.visitReferences,
+  visit_resources: () => import_chunk_QBCVUVLD.visit_resources,
+  visitorNode: () => import_chunk_QBCVUVLD.visitorNode
 });
 module.exports = __toCommonJS(api_exports);
-var import_chunk_NUE3G2QE = require("./chunk-NUE3G2QE.cjs");
+var import_chunk_QBCVUVLD = require("./chunk-QBCVUVLD.cjs");
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_NUE3G2QE.init_api)();
+(0, import_chunk_QBCVUVLD.init_api)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   checkCompilerVersion,

package/build/{chunk-NUE3G2QE.cjs → chunk-QBCVUVLD.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_NUE3G2QE_exports = {};
-__export(chunk_NUE3G2QE_exports, {
+var chunk_QBCVUVLD_exports = {};
+__export(chunk_QBCVUVLD_exports, {
   EnumTagsConst: () => EnumTagsConst,
   LastTypeTag: () => LastTypeTag,
   ObjectLikeTagsConst: () => ObjectLikeTagsConst,
@@ -122,7 +122,7 @@ __export(chunk_NUE3G2QE_exports, {
   visitorNode: () => visitorNode,
   xml_util_exports: () => xml_util_exports
 });
-module.exports = __toCommonJS(chunk_NUE3G2QE_exports);
+module.exports = __toCommonJS(chunk_QBCVUVLD_exports);
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
@@ -11724,19 +11724,70 @@ function getLhsConstraint(istate, node) {
       throw new Error("Checking types without a typeMap");
     }
     const object = istate.typeMap.get(node.object);
-    if (object && !node.computed) {
-      const [, trueDecls2] = findObjectDeclsByProperty(
-        istate.state,
-        object,
-        node
-      );
-      if (trueDecls2) {
-        lookupDefs = lookupNext(
+    if (object) {
+      if (node.computed) {
+        if (object.value) {
+          let result = null;
+          if (object.type & 512) {
+            const arr = getUnionComponent(
+              object,
+              512
+              /* Array */
+            );
+            if (arr) {
+              result = arr;
+            }
+          }
+          if (object.type & 1024) {
+            const dict = getUnionComponent(
+              object,
+              1024
+              /* Dictionary */
+            );
+            if (dict) {
+              if (result) {
+                result = cloneType(result);
+                unionInto(result, dict.value);
+              } else {
+                result = dict.value;
+              }
+            }
+          }
+          if (object.type & 32768) {
+            const obj = getUnionComponent(
+              object,
+              32768
+              /* Object */
+            );
+            if (obj && isByteArrayData(obj)) {
+              const t = {
+                type: 8 | 128
+                /* Char */
+              };
+              if (result) {
+                unionInto(t, result);
+              }
+              result = t;
+            }
+          }
+          if (result) {
+            return result;
+          }
+        }
+      } else {
+        const [, trueDecls2] = findObjectDeclsByProperty(
           istate.state,
-          [{ parent: null, results: trueDecls2 }],
-          "decls",
-          node.property
+          object,
+          node
         );
+        if (trueDecls2) {
+          lookupDefs = lookupNext(
+            istate.state,
+            [{ parent: null, results: trueDecls2 }],
+            "decls",
+            node.property
+          );
+        }
       }
     }
   }
@@ -11842,7 +11893,10 @@ function evaluateNode(istate, node) {
           });
           return;
         }
-        if (istate.checkTypes && !couldBe(left.value, right.value)) {
+        if (istate.checkTypes && !couldBe(left.value, right.value) && !subtypeOf({
+          type: 1 | 32768
+          /* Object */
+        }, right.value)) {
           diagnostic(
             istate.state,
             node,
@@ -12077,26 +12131,39 @@ function evaluateNode(istate, node) {
       if (!isLookupCandidate(node)) {
         const property = popIstate(istate, node.property);
         const object = popIstate(istate, node.object);
-        if (hasValue(object.value) && object.value.type === 512 && property.value.type & (8 | 16)) {
-          push({
-            value: object.value.value,
-            embeddedEffects: object.embeddedEffects || property.embeddedEffects,
-            node
-          });
-          break;
-        }
-        if (hasValue(object.value) && object.value.type === 1024 && property.value.type & object.value.value.key.type) {
-          const value2 = {
-            type: 1
-            /* Null */
-          };
-          unionInto(value2, object.value.value.value);
-          push({
-            value: value2,
-            embeddedEffects: object.embeddedEffects || property.embeddedEffects,
-            node
-          });
-          break;
+        if (hasValue(object.value)) {
+          if (object.value.type === 512 && property.value.type & (8 | 16)) {
+            push({
+              value: object.value.value,
+              embeddedEffects: object.embeddedEffects || property.embeddedEffects,
+              node
+            });
+            break;
+          }
+          if (object.value.type === 1024 && property.value.type & object.value.value.key.type) {
+            const value2 = {
+              type: 1
+              /* Null */
+            };
+            unionInto(value2, object.value.value.value);
+            push({
+              value: value2,
+              embeddedEffects: object.embeddedEffects || property.embeddedEffects,
+              node
+            });
+            break;
+          }
+          if (property.value.type & (8 | 16) && isByteArray(object.value)) {
+            push({
+              value: {
+                type: 8
+                /* Number */
+              },
+              embeddedEffects: object.embeddedEffects || property.embeddedEffects,
+              node
+            });
+            break;
+          }
         }
         push({
           value: {
@@ -12400,6 +12467,15 @@ function mustBeIdentical(a, b) {
   }
   return false;
 }
+function isByteArray(object) {
+  return hasValue(object) && object.type === 32768 && isByteArrayData(object.value);
+}
+function isByteArrayData(objectData) {
+  return objectData.klass.value && (0, import_chunk_PVBIKZYZ.every)(
+    objectData.klass.value,
+    (klass) => klass.fullName === "$.Toybox.Lang.ByteArray"
+  );
+}
 var init_interp = (0, import_chunk_ABYVSU2C.__esm)({
   "src/type-flow/interp.ts"() {
     "use strict";
@@ -12407,6 +12483,7 @@ var init_interp = (0, import_chunk_ABYVSU2C.__esm)({
     (0, import_chunk_MBTLUWXR.init_ast)();
     init_data_flow();
     init_optimizer_types();
+    (0, import_chunk_PVBIKZYZ.init_util)();
     init_could_be();
     init_interp_binary();
     init_interp_call();
@@ -14172,7 +14249,14 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
           next = findNextObjectType(istate, trueDecls, me);
         }
       } else {
-        if (cur.type & (4096 | 16384 | 32768)) {
+        let byteArray = false;
+        if (cur.type & 32768 && cur.value) {
+          const odata = getObjectValue(cur);
+          if (odata && isByteArrayData(odata)) {
+            byteArray = true;
+          }
+        }
+        if (cur.type & (4096 | 16384 | (byteArray ? 0 : 32768))) {
           next = {
             type: 524287
             /* Any */
@@ -14181,6 +14265,16 @@ function propagateTypes(state, func, graph, optimizeEquivalencies, copyPropStore
             updateAny = true;
           }
         } else {
+          if (byteArray) {
+            const t = {
+              type: 8
+              /* Number */
+            };
+            if (next) {
+              unionInto(t, next);
+            }
+            next = t;
+          }
           if (cur.type & 512) {
             const avalue = getUnionComponent(
               cur,
@@ -22562,6 +22656,7 @@ function optimizeArrayInit(func, block, index, context, interpState) {
     interpState = cloneState2(null);
   }
   const putvStarts = [];
+  const dupsToFix = [];
   let i;
   let initInst = null;
   let initType = null;
@@ -22594,6 +22689,12 @@ function optimizeArrayInit(func, block, index, context, interpState) {
         usedLocals |= 1n << BigInt(bc.arg);
       }
       const delta = interpState.stack.length - depth;
+      if (delta < 0) {
+        break;
+      }
+      if (bc.op === 46 && bc.arg >= delta - 1) {
+        dupsToFix[k] = putvStarts.length;
+      }
       if (delta === 3) {
         const t = interpState.stack[interpState.stack.length - 1].type;
         if (bc.op === 18) {
@@ -22607,9 +22708,6 @@ function optimizeArrayInit(func, block, index, context, interpState) {
         }
         thisInit = null;
       }
-      if (delta < 0 || bc.op === 46 && bc.arg >= delta - 1) {
-        break;
-      }
     }
     if (found === i)
       break;
@@ -22677,6 +22775,11 @@ function optimizeArrayInit(func, block, index, context, interpState) {
         /* aputv */
       );
     };
+    dupsToFix.forEach((x, n) => {
+      const bc = block.bytecodes[n];
+      (0, import_node_assert9.default)(bc.op === 46 && bc.arg >= 2);
+      bc.arg -= 2;
+    });
     convertAputv(i - 1);
     for (let i2 = putvStarts.length; i2--; ) {
       const offset = putvStarts[i2];
@@ -22796,6 +22899,11 @@ ${blockToString(block, context)}`
   if (local >= 0) {
     block.bytecodes.splice(i, 0, bytecode(2, void 0));
   }
+  dupsToFix.forEach((x, n) => {
+    const bc = block.bytecodes[n];
+    (0, import_node_assert9.default)(bc.op === 46 && bc.arg >= 2);
+    bc.arg += (putvStarts.length - x - 1) * 2;
+  });
   for (let i2 = putvStarts.length; i2-- > 1; ) {
     block.bytecodes.splice(putvStarts[i2], 2);
   }
@@ -23738,7 +23846,7 @@ function simpleOpts(func, context) {
   return Array.from(func.blocks.values()).reduce((changes, block) => {
     for (let i = block.bytecodes.length; i--; ) {
       const cur = block.bytecodes[i];
-      if (cur.op === 0 || context.config.removeArgc && cur.op === 53) {
+      if (cur.op === 0 || cur.op === 1 && cur.arg === 0 || context.config.removeArgc && cur.op === 53) {
         block.bytecodes.splice(i, 1);
         changes = true;
         if (logging3) {
@@ -23756,6 +23864,18 @@ function simpleOpts(func, context) {
             logging3 && (0, import_chunk_PVBIKZYZ.log)(`${func.name}: deleting no-op shift (${shift})`);
             continue;
           }
+          if (shift === 1n && prev.op === 37) {
+            const dup = prev;
+            dup.op = 46;
+            dup.arg = 0;
+            dup.size = 2;
+            const add = cur;
+            add.op = 3;
+            delete add.arg;
+            add.size = 1;
+            logging3 && (0, import_chunk_PVBIKZYZ.log)(`${func.name}: converting "ipush 1; shlv" to "dup 0; addv"`);
+            continue;
+          }
           if (shift < (prev.op === 49 ? 64n : 31n)) {
             const mul = 1n << shift;
             if (prev.op === 37) {
@@ -25354,11 +25474,15 @@ var init_symbols = (0, import_chunk_ABYVSU2C.__esm)({
           const { startPc, name, parent } = functionEntry.attr;
           if (!startPc || !name)
             return;
+          const fullPc = Number(startPc.value.value);
+          if (fullPc >>> 28 !== 1) {
+            return;
+          }
+          const pc = fullPc & 16777215;
           const argc = functionEntry.children?.filter(
             (node) => node.type === "element" && node.name === "param"
           ).length || null;
           const fullName = (parent ? debugXml.processRefs(parent.value.value) + "." : "") + debugXml.processRefs(name.value.value);
-          const pc = Number(startPc.value.value) & 16777215;
           this.methods.set(pc, {
             name: fullName,
             id: null,
@@ -29893,7 +30017,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
       const opt_time = await (0, import_chunk_PVBIKZYZ.first_modified)(
         Object.values(fnMap).map((v) => v.output)
       );
-      if (source_time < opt_time && 1690215897566 < opt_time) {
+      if (source_time < opt_time && 1692125151130 < opt_time) {
         return {
           hasTests,
           diagnostics: prevDiagnostics,
@@ -29931,7 +30055,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             hasTests: hasTests2,
             diagnostics,
             sdkVersion,
-            optimizerVersion: "1.1.32",
+            optimizerVersion: "1.1.34",
             ...Object.fromEntries(
               configOptionsToCheck.map((option) => [option, config[option]])
             )
@@ -30372,14 +30496,17 @@ async function optimizeProgram(filepath, devKey, output, config) {
   if (!output) {
     output = removeExt(filepath, ".prg") + ".opt.prg";
   }
-  const xmlBytes = await fs7.readFile(filepath + ".debug.xml").catch(() => "");
-  const debugXml = xml_util_exports.parseXml(xmlBytes.toString());
-  const key = devKey ? await getDevKey(devKey) : void 0;
-  const view = new DataView((await fs7.readFile(filepath)).buffer);
-  const { signature, buffer } = await optimizeProgramBuffer(
+  const [debugXml, apiDebugXml, key, view] = await Promise.all([
+    fs7.readFile(filepath + ".debug.xml").catch(() => "").then((xmlBytes) => xml_util_exports.parseXml(xmlBytes.toString())),
+    getSdkPath().then((sdk) => fs7.readFile(`${sdk}bin/api.debug.xml`)).catch(() => "").then((xmlBytes) => xml_util_exports.parseXml(xmlBytes.toString())),
+    devKey ? getDevKey(devKey) : void 0,
+    fs7.readFile(filepath).then((prgData) => new DataView(prgData.buffer))
+  ]);
+  const { signature, buffer } = optimizeProgramBuffer(
     filepath,
     view,
     debugXml,
+    apiDebugXml,
     key,
     config
   );
@@ -30400,7 +30527,7 @@ async function optimizeProgram(filepath, devKey, output, config) {
   await Promise.all(promises);
   return { signature, output };
 }
-function optimizeProgramBuffer(filepath, view, debugXml, key, config) {
+function optimizeProgramBuffer(filepath, view, debugXml, apiDebugXml, key, config) {
   const { sections } = readPrgWithOffsets(view);
   (0, import_chunk_PVBIKZYZ.logger)("readprg", 5, sections);
   const symbolTable = new SymbolTable();
@@ -30411,6 +30538,9 @@ function optimizeProgramBuffer(filepath, view, debugXml, key, config) {
     ].view);
   }
   symbolTable.parseXml(debugXml);
+  if (apiDebugXml) {
+    symbolTable.parseXml(apiDebugXml);
+  }
   const header = parseHeader(sections[
     -805253120
     /* HEADER */
@@ -30661,6 +30791,7 @@ function optimizePrgAndDebug(prgName, prgBuffer, prgOffset, prgLength, xmlName,
     prgName,
     new DataView(prgBuffer, prgOffset, prgLength),
     debugXml,
+    null,
     key,
     config
   );

package/build/optimizer.cjs

@@ -18,29 +18,29 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var optimizer_exports = {};
 __export(optimizer_exports, {
-  StateNodeAttributes: () => import_chunk_NUE3G2QE.StateNodeAttributes,
-  buildOptimizedProject: () => import_chunk_NUE3G2QE.buildOptimizedProject,
+  StateNodeAttributes: () => import_chunk_QBCVUVLD.StateNodeAttributes,
+  buildOptimizedProject: () => import_chunk_QBCVUVLD.buildOptimizedProject,
   copyRecursiveAsNeeded: () => import_chunk_PVBIKZYZ.copyRecursiveAsNeeded,
-  defaultConfig: () => import_chunk_NUE3G2QE.defaultConfig,
-  display: () => import_chunk_NUE3G2QE.display,
-  generateApiMirTests: () => import_chunk_NUE3G2QE.generateApiMirTests,
-  generateOneConfig: () => import_chunk_NUE3G2QE.generateOneConfig,
-  generateOptimizedProject: () => import_chunk_NUE3G2QE.generateOptimizedProject,
-  getConfig: () => import_chunk_NUE3G2QE.getConfig,
-  getProjectAnalysis: () => import_chunk_NUE3G2QE.getProjectAnalysis,
-  get_jungle: () => import_chunk_NUE3G2QE.get_jungle,
-  isErrorWithLocation: () => import_chunk_NUE3G2QE.isErrorWithLocation,
-  launchSimulator: () => import_chunk_NUE3G2QE.launchSimulator,
-  manifestProducts: () => import_chunk_NUE3G2QE.manifestProducts,
-  mctree: () => import_chunk_NUE3G2QE.mctree,
-  simulateProgram: () => import_chunk_NUE3G2QE.simulateProgram
+  defaultConfig: () => import_chunk_QBCVUVLD.defaultConfig,
+  display: () => import_chunk_QBCVUVLD.display,
+  generateApiMirTests: () => import_chunk_QBCVUVLD.generateApiMirTests,
+  generateOneConfig: () => import_chunk_QBCVUVLD.generateOneConfig,
+  generateOptimizedProject: () => import_chunk_QBCVUVLD.generateOptimizedProject,
+  getConfig: () => import_chunk_QBCVUVLD.getConfig,
+  getProjectAnalysis: () => import_chunk_QBCVUVLD.getProjectAnalysis,
+  get_jungle: () => import_chunk_QBCVUVLD.get_jungle,
+  isErrorWithLocation: () => import_chunk_QBCVUVLD.isErrorWithLocation,
+  launchSimulator: () => import_chunk_QBCVUVLD.launchSimulator,
+  manifestProducts: () => import_chunk_QBCVUVLD.manifestProducts,
+  mctree: () => import_chunk_QBCVUVLD.mctree,
+  simulateProgram: () => import_chunk_QBCVUVLD.simulateProgram
 });
 module.exports = __toCommonJS(optimizer_exports);
-var import_chunk_NUE3G2QE = require("./chunk-NUE3G2QE.cjs");
+var import_chunk_QBCVUVLD = require("./chunk-QBCVUVLD.cjs");
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_NUE3G2QE.init_optimizer)();
+(0, import_chunk_QBCVUVLD.init_optimizer)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   StateNodeAttributes,

package/build/sdk-util.cjs

@@ -18,25 +18,25 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var sdk_util_exports = {};
 __export(sdk_util_exports, {
-  SectionKinds: () => import_chunk_NUE3G2QE.SectionKinds,
-  appSupport: () => import_chunk_NUE3G2QE.appSupport,
-  connectiq: () => import_chunk_NUE3G2QE.connectiq,
-  getDeviceInfo: () => import_chunk_NUE3G2QE.getDeviceInfo,
-  getFunctionDocumentation: () => import_chunk_NUE3G2QE.getFunctionDocumentation,
-  getLanguages: () => import_chunk_NUE3G2QE.getLanguages,
-  getSdkPath: () => import_chunk_NUE3G2QE.getSdkPath,
-  isWin: () => import_chunk_NUE3G2QE.isWin,
-  optimizeProgram: () => import_chunk_NUE3G2QE.optimizeProgram,
-  readPrg: () => import_chunk_NUE3G2QE.readPrg,
-  readPrgWithOffsets: () => import_chunk_NUE3G2QE.readPrgWithOffsets,
-  xmlUtil: () => import_chunk_NUE3G2QE.xml_util_exports
+  SectionKinds: () => import_chunk_QBCVUVLD.SectionKinds,
+  appSupport: () => import_chunk_QBCVUVLD.appSupport,
+  connectiq: () => import_chunk_QBCVUVLD.connectiq,
+  getDeviceInfo: () => import_chunk_QBCVUVLD.getDeviceInfo,
+  getFunctionDocumentation: () => import_chunk_QBCVUVLD.getFunctionDocumentation,
+  getLanguages: () => import_chunk_QBCVUVLD.getLanguages,
+  getSdkPath: () => import_chunk_QBCVUVLD.getSdkPath,
+  isWin: () => import_chunk_QBCVUVLD.isWin,
+  optimizeProgram: () => import_chunk_QBCVUVLD.optimizeProgram,
+  readPrg: () => import_chunk_QBCVUVLD.readPrg,
+  readPrgWithOffsets: () => import_chunk_QBCVUVLD.readPrgWithOffsets,
+  xmlUtil: () => import_chunk_QBCVUVLD.xml_util_exports
 });
 module.exports = __toCommonJS(sdk_util_exports);
-var import_chunk_NUE3G2QE = require("./chunk-NUE3G2QE.cjs");
+var import_chunk_QBCVUVLD = require("./chunk-QBCVUVLD.cjs");
 var import_chunk_PVBIKZYZ = require("./chunk-PVBIKZYZ.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_NUE3G2QE.init_sdk_util)();
+(0, import_chunk_QBCVUVLD.init_sdk_util)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SectionKinds,

package/build/src/api.d.ts

@@ -26,7 +26,7 @@ export declare function findNamesInScope(declStack: StateNode[][], pattern: stri
     readonly parent: StateNode;
     readonly depth: number;
 }])[];
-export declare function mapVarDeclsByType(state: ProgramStateAnalysis, decls: StateNodeDecl[], node: mctree.Node, typeMap: TypeMap | null | undefined): (mctree.Identifier | mctree.EnumStringMember | mctree.AsIdentifier | FunctionStateNode | ClassStateNode | ModuleStateNode | ProgramStateNode | VariableStateNode | import("./optimizer-types").BlockStateNode | TypedefStateNode | EnumStateNode)[];
+export declare function mapVarDeclsByType(state: ProgramStateAnalysis, decls: StateNodeDecl[], node: mctree.Node, typeMap: TypeMap | null | undefined): (mctree.Identifier | mctree.EnumStringMember | mctree.AsIdentifier | FunctionStateNode | ModuleStateNode | ClassStateNode | TypedefStateNode | ProgramStateNode | EnumStateNode | import("./optimizer-types").BlockStateNode | VariableStateNode)[];
 export declare function formatAstLongLines(node: mctree.Node): string;
 export declare function createDocumentationMap(functionDocumentation: {
     name: string;

package/build/src/projects.d.ts

@@ -14,6 +14,7 @@ export type RemoteProject = string | {
     jungleContent?: string[];
     garminOptLevel?: number;
     test?: boolean | string[];
+    branch?: string;
 };
 export declare const githubProjects: RemoteProject[];
 export declare function fetchGitProjects(projects: RemoteProject[], testOnly: boolean, skipRemote: boolean): Promise<(string | {

package/build/src/readprg.d.ts

@@ -1,9 +1,7 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import * as crypto from "node:crypto";
 import { BuildConfig } from "./optimizer-types";
 import { SectionInfo } from "./readprg/bytecode";
-import { xmlUtil } from "./sdk-util";
 export declare function readPrg(path: string): Promise<{
     [k: string]: number;
 }>;
@@ -16,10 +14,6 @@ export declare function readPrgWithOffsets(view: DataView): {
     sections: Record<number, SectionInfo>;
 };
 export declare function optimizeProgram(filepath: string, devKey?: string | undefined, output?: string, config?: BuildConfig): Promise<unknown>;
-export declare function optimizeProgramBuffer(filepath: string, view: DataView, debugXml: xmlUtil.Document, key: crypto.KeyObject | undefined, config: BuildConfig | undefined): {
-    signature: Buffer | undefined;
-    buffer: Buffer;
-};
 export declare function optimizePrgAndDebug(prgName: string, prgBuffer: ArrayBuffer, prgOffset: number, prgLength: number, xmlName: string, xmlBuffer: ArrayBuffer, xmlOffset: number, xmlLength: number, key: crypto.KeyObject, config: BuildConfig | undefined): Promise<{
     sigBuffer: ArrayBufferLike | undefined;
     sigOffset: number | undefined;

package/build/src/src/api.d.ts

@@ -0,0 +1,51 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { hasProperty, traverseAst } from "./ast";
+import { JungleResourceMap } from "./jungles";
+import { ClassStateNode, Diagnostic, DiagnosticType, EnumStateNode, FunctionInfo, FunctionStateNode, LookupDefinition, LookupResult, ModuleStateNode, ProgramState, ProgramStateAnalysis, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl, TypedefStateNode, VariableStateNode } from "./optimizer-types";
+import { visit_resources } from "./resources";
+import { xmlUtil } from "./sdk-util";
+import { TypeMap } from "./type-flow/interp";
+export { visitorNode, visitReferences } from "./visitor";
+export { traverseAst, hasProperty, visit_resources };
+export declare function parseSdkVersion(version: string | undefined): number;
+export declare function checkCompilerVersion(version: string, sdkVer: number): boolean | undefined;
+export declare function getApiMapping(state?: ProgramState, resourcesMap?: Record<string, JungleResourceMap>, manifestXML?: xmlUtil.Document): Promise<ProgramStateNode>;
+export declare function isStateNode(node: {
+    type: string;
+}): node is StateNode;
+export declare function variableDeclarationName(node: mctree.TypedIdentifier | mctree.InstanceofIdentifier): string;
+type DeclKind = "decls" | "type_decls";
+export declare function sameLookupResult(a: LookupDefinition[], b: LookupDefinition[]): boolean;
+export declare function lookupResultContains(a: LookupDefinition[], b: LookupDefinition[]): boolean;
+export declare function isLookupCandidate(node: mctree.MemberExpression): false | mctree.Identifier;
+export declare function lookupNext(state: ProgramStateLive, results: LookupDefinition[], decls: DeclKind, property: mctree.Identifier): LookupDefinition[] | null;
+export declare function lookupWithType(state: ProgramStateAnalysis, node: mctree.Node, typeMap: TypeMap | undefined | null, nonLocal?: boolean, stack?: ProgramStateStack | null): LookupResult;
+export declare function collectNamespaces(ast: mctree.Program, stateIn?: ProgramState): ProgramStateNode;
+export declare function formatAst(node: mctree.Node, monkeyCSource?: string | null, options?: Record<string, unknown> | null): string;
+export declare function findNamesInScope(declStack: StateNode[][], pattern: string | RegExp): (readonly [StateNodeDecl, {
+    readonly parent: StateNode;
+    readonly depth: number;
+}])[];
+export declare function mapVarDeclsByType(state: ProgramStateAnalysis, decls: StateNodeDecl[], node: mctree.Node, typeMap: TypeMap | null | undefined): (mctree.Identifier | mctree.EnumStringMember | mctree.AsIdentifier | FunctionStateNode | ClassStateNode | ModuleStateNode | ProgramStateNode | VariableStateNode | import("./optimizer-types").BlockStateNode | TypedefStateNode | EnumStateNode)[];
+export declare function formatAstLongLines(node: mctree.Node): string;
+export declare function createDocumentationMap(functionDocumentation: {
+    name: string;
+    parent: string;
+    doc: string;
+}[]): Promise<Map<string, string>>;
+export declare function makeToyboxLink(result: StateNodeDecl): string | null;
+export declare function lookupByFullName(state: ProgramStateAnalysis, fullName: string): StateNodeDecl[];
+export declare function findUsingForNode(state: ProgramStateLive, stack: ProgramStateStack, i: number, node: mctree.Identifier): ModuleStateNode | {
+    name: string;
+    decls: {
+        parent: StateNode;
+        results: StateNodeDecl[];
+    };
+}[] | null;
+export declare function getApiFunctionInfo(state: ProgramState, func: FunctionStateNode): FunctionInfo | false;
+export declare function markInvokeClassMethod(state: ProgramStateAnalysis, func: FunctionStateNode): void;
+export declare function isLocal(v: VariableStateNode): boolean;
+export declare function isClassVariable(v: VariableStateNode): boolean;
+export declare function diagnostic(state: ProgramState, node: mctree.Node, message: string | null, type?: DiagnosticType, extra?: Diagnostic["extra"]): void;
+export declare function diagnosticHelper(diagnostics: Record<string, Diagnostic[]>, node: mctree.Node, message: string | null, type: DiagnosticType | undefined, extra: Diagnostic["extra"] | undefined, uniqueLocs: boolean): void;
+export declare function getSuperClasses(klass: ClassStateNode): Set<StateNode> | null;