@markw65/monkeyc-optimizer 1.0.12 → 1.0.13

package/build/optimizer.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {copyRecursiveAsNeeded,launchSimulator,simulateProgram,get_jungle,mctree,defaultConfig,buildOptimizedProject,generateOptimizedProject,getProjectAnalysis,generateApiMirTests});
+0 && (module.exports = {copyRecursiveAsNeeded,get_jungle,launchSimulator,manifestProducts,mctree,simulateProgram,defaultConfig,isErrorWithLocation,buildOptimizedProject,generateOptimizedProject,getProjectAnalysis,generateApiMirTests});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -9829,18 +9829,22 @@ __webpack_require__.d(__webpack_exports__, {
   "generateOptimizedProject": () => (/* binding */ generateOptimizedProject),
   "getProjectAnalysis": () => (/* binding */ getProjectAnalysis),
   "get_jungle": () => (/* reexport */ get_jungle),
+  "isErrorWithLocation": () => (/* binding */ isErrorWithLocation),
   "launchSimulator": () => (/* reexport */ launchSimulator),
+  "manifestProducts": () => (/* reexport */ manifestProducts),
   "mctree": () => (/* reexport */ prettier_plugin_monkeyc_namespaceObject.mctree),
   "simulateProgram": () => (/* reexport */ simulateProgram)
 });
 
+;// CONCATENATED MODULE: external "@markw65/prettier-plugin-monkeyc"
+const prettier_plugin_monkeyc_namespaceObject = require("@markw65/prettier-plugin-monkeyc");
+var prettier_plugin_monkeyc_default = /*#__PURE__*/__webpack_require__.n(prettier_plugin_monkeyc_namespaceObject);
 ;// CONCATENATED MODULE: external "crypto"
 const external_crypto_namespaceObject = require("crypto");
 ;// CONCATENATED MODULE: external "fs/promises"
 const promises_namespaceObject = require("fs/promises");
 // EXTERNAL MODULE: external "path"
 var external_path_ = __webpack_require__(1423);
-var external_path_default = /*#__PURE__*/__webpack_require__.n(external_path_);
 ;// CONCATENATED MODULE: external "./api.cjs"
 const external_api_cjs_namespaceObject = require("./api.cjs");
 ;// CONCATENATED MODULE: external "./sdk-util.cjs"
@@ -9911,7 +9915,6 @@ async function build_project(product, options, lineCallback) {
 
 // EXTERNAL MODULE: ./node_modules/extract-zip/index.js
 var extract_zip = __webpack_require__(2106);
-var extract_zip_default = /*#__PURE__*/__webpack_require__.n(extract_zip);
 // EXTERNAL MODULE: ./node_modules/xml2js/lib/xml2js.js
 var xml2js = __webpack_require__(5055);
 ;// CONCATENATED MODULE: ./build/jungle.js
@@ -9932,7 +9935,7 @@ async function writeManifest(filename, xml) {
 function manifestProducts(manifest) {
     const app = manifest["iq:manifest"]["iq:application"] ||
         manifest["iq:manifest"]["iq:barrel"];
-    return ((app[0]["iq:products"] || [{}])[0]["iq:product"] || [])
+    return (app?.[0]["iq:products"]?.[0]["iq:product"] || [])
         .map((p) => p.$.id)
         .sort()
         .filter((p, i, a) => !i || p !== a[i - 1]);
@@ -9953,7 +9956,10 @@ function manifestBarrels(manifest) {
     return [];
 }
 function manifestDropBarrels(manifest) {
-    delete manifest["iq:manifest"]["iq:application"][0]["iq:barrels"];
+    const app = manifest["iq:manifest"]["iq:application"];
+    if (!app)
+        return;
+    delete app[0]["iq:barrels"];
 }
 function manifestBarrelName(manifestName, manifest) {
     const barrel = manifest["iq:manifest"]["iq:barrel"];
@@ -9964,7 +9970,7 @@ function manifestBarrelName(manifestName, manifest) {
 function manifestAnnotations(manifest) {
     const barrel = manifest["iq:manifest"]["iq:barrel"];
     if (!barrel)
-        return null;
+        return undefined;
     const annotations = barrel[0]["iq:annotations"];
     return annotations && annotations[0]["iq:annotation"];
 }
@@ -9994,9 +10000,13 @@ async function checkManifest(manifest, products) {
     if (JSON.stringify(allowedProducts) !=
         JSON.stringify(manifestProducts(manifest))) {
         ok = false;
-        elm["iq:products"][0]["iq:product"] = allowedProducts.map((id) => {
-            return { $: { id } };
-        });
+        elm["iq:products"] = [
+            {
+                "iq:product": allowedProducts.map((id) => {
+                    return { $: { id } };
+                }),
+            },
+        ];
     }
     Object.keys(elm).forEach((key) => {
         if (![
@@ -10081,7 +10091,7 @@ function process_assignments(assignments, current) {
                 r.dotnames = [];
             }
             return r;
-        }, { node: state, dot: null, dotnames: [] });
+        }, { node: state, dot: undefined, dotnames: [] });
         // an assignment to a node overwrites its old value
         Object.keys(node).forEach((k) => delete node[k]);
         const process_list = (values) => {
@@ -10155,7 +10165,9 @@ function evaluate_locals(assignments) {
 }
 async function parse_one(file) {
     const [fileName, grammarSource] = Array.isArray(file) ? file : [file, file];
-    const source = await promises_namespaceObject.readFile(fileName);
+    const source = await promises_namespaceObject.readFile(fileName).catch(() => {
+        throw new Error(`Couldn't read jungle file '${fileName}`);
+    });
     const assignments = peg$parse(source.toString(), { grammarSource });
     return evaluate_locals(assignments);
 }
@@ -10210,24 +10222,49 @@ function check_non_leaf_dot(dot, path = null, i = 0) {
 // return the resolved node at path
 function resolve_node_by_path(state, path) {
     return path.reduce((s, n, i) => {
+        if (!s || Array.isArray(s)) {
+            return s;
+        }
         if (!s[n] && s["."]) {
             const sdot = s["."];
-            let resolved = resolve_node_list(state, sdot)[0][n];
-            if (resolved == null && sdot.every((e) => e.type == "Literal")) {
-                // foo = string
-                // bar = $(foo.resourcePath)
-                // is supposed to work as if you'd left out the (obviously
-                // incorrect) ".resourcePath"
+            let resolved = resolve_node_list(state, sdot);
+            if (!resolved.length)
+                return undefined;
+            const r = resolved[0][n];
+            if (!r && sdot.every((e) => e.type == "Literal")) {
+                /*
+                 * We had something like:
+                 *
+                 *   foo = whatever
+                 *   bar = $(foo.resourcePath)
+                 *
+                 * and its supposed to work as if you'd left out the (obviously
+                 * incorrect) ".resourcePath"
+                 */
                 return s;
             }
+            /*
+             * This is a pretty unusual edge case.
+             *
+             * If we do something like:
+             *
+             *   fenix6 = $(base)
+             *   fenix5.sourcePath = $(fenix6.sourcePath)
+             *
+             * and fenix5 gets resolved before fenix6 (which it will,
+             * currently, because products are resolved in lexicographical
+             * order), we'll end up here when we try to resolve
+             * fenix6.sourcePath.
+             */
             check_non_leaf_dot(sdot, path, i);
+            return r;
         }
         return s[n];
     }, state);
 }
 // fully resolve the given node, and all its children
 function resolve_node(state, node) {
-    if (node == null || Array.isArray(node)) {
+    if (node === undefined || Array.isArray(node)) {
         // an already optimized leaf node
         return node;
     }
@@ -10293,9 +10330,10 @@ async function resolve_literals(qualifier, default_source) {
             }
         }))).filter((name) => name != null);
     const resolve_one_file_list = async (base, name) => {
-        if (!base[name])
+        const bname = base[name];
+        if (!bname)
             return;
-        const result = await resolve_file_list(base[name]);
+        const result = await resolve_file_list(bname);
         if (!result || !result.length) {
             delete base[name];
         }
@@ -10453,14 +10491,15 @@ function identify_optimizer_groups(targets, options) {
         if (excludeAnnotations && ignoredExcludeAnnotations) {
             excludeAnnotations = getStrsWithIgnore(excludeAnnotations, ignoredExcludeAnnotations);
         }
-        Object.entries(annotations).forEach(([key, value]) => {
-            if (ignoredAnnotations) {
-                annotations[key] = getStrsWithIgnore(value, ignoredAnnotations);
-            }
-        });
+        annotations &&
+            Object.entries(annotations).forEach(([key, value]) => {
+                if (ignoredAnnotations) {
+                    annotations[key] = getStrsWithIgnore(value, ignoredAnnotations);
+                }
+            });
         if (ignoredSourcePaths) {
             sourcePath = sourcePath
-                .map((path) => Object.keys(ignoredSourcePaths[path]))
+                ?.map((path) => Object.keys(ignoredSourcePaths[path]))
                 .flat()
                 .sort()
                 .filter((v, i, a) => i === 0 || v !== a[i - 1]);
@@ -10556,9 +10595,11 @@ function resolve_barrel(barrel, barrelDir, products, options) {
             .then((localStat) => !localStat.isDirectory() ||
             promises_namespaceObject.stat(barrel)
                 .then((barrelStat) => localStat.mtimeMs < barrelStat.mtimeMs), () => true)
-            .then((needsUpdate) => needsUpdate &&
-            promises_namespaceObject.rm(localPath, { recursive: true, force: true })
-                .then(() => extract_zip_default()(barrel, { dir: localPath }))));
+            .then((needsUpdate) => {
+            needsUpdate &&
+                promises_namespaceObject.rm(localPath, { recursive: true, force: true })
+                    .then(() => extract_zip(barrel, { dir: localPath }));
+        }));
     }
     return promise
         .then(() => get_jungle_and_barrels(rawBarrel, products, options))
@@ -10622,9 +10663,10 @@ function resolve_barrels(product, qualifier, barrels, products, options) {
             const name = manifestBarrelName(resolvedBarrel.manifest, resolvedBarrel.xml);
             if (!(0,external_api_cjs_namespaceObject.hasProperty)(barrelMap, name))
                 return;
-            if (barrelMap[name]) {
+            const bmapName = barrelMap[name];
+            if (bmapName) {
                 const bname = (r) => r.jungles.join(";");
-                throw new Error(`Barrel ${name} already resolved to ${bname(barrelMap[name])}; can't also resolve to ${bname(resolvedBarrel)}`);
+                throw new Error(`Barrel ${name} already resolved to ${bname(bmapName)}; can't also resolve to ${bname(resolvedBarrel)}`);
             }
             barrelMap[name] = resolvedBarrel;
         });
@@ -10636,10 +10678,11 @@ function resolve_barrels(product, qualifier, barrels, products, options) {
                 .map(([name]) => name)
                 .join(",")}`);
         }
+        const finalMap = barrelMap;
         if (!cache.barrelMap)
             cache.barrelMap = {};
-        cache.barrelMap[barrelMapKey] = barrelMap;
-        setBarrelMap(barrelMap);
+        cache.barrelMap[barrelMapKey] = finalMap;
+        setBarrelMap(finalMap);
     });
 }
 /**
@@ -10679,7 +10722,7 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
     if (products.length === 0)
         products.push(...defaultProducts);
     let promise = Promise.resolve();
-    const add_one = (product, shape = null) => {
+    const add_one = (product, shape = undefined) => {
         const rawQualifier = resolve_node(state, state[product]);
         if (!rawQualifier || Array.isArray(rawQualifier))
             return;
@@ -10688,7 +10731,8 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
             .then((qualifier) => {
             targets.push({ product, qualifier, shape });
             return resolve_barrels(product, qualifier, barrels, products, options);
-        });
+        })
+            .then(() => { });
     };
     products.forEach((product) => {
         if ((0,external_api_cjs_namespaceObject.hasProperty)(state, product)) {
@@ -10723,7 +10767,7 @@ const external_child_process_namespaceObject = require("child_process");
 
 function launchSimulator() {
     return (0,external_sdk_util_cjs_namespaceObject.getSdkPath)().then((sdk) => {
-        const child = (0,external_child_process_namespaceObject.execFile)(external_path_default().resolve(sdk, "bin", external_sdk_util_cjs_namespaceObject.isWin ? "simulator" : "connectiq"));
+        const child = (0,external_child_process_namespaceObject.execFile)(external_path_.resolve(sdk, "bin", external_sdk_util_cjs_namespaceObject.isWin ? "simulator" : "connectiq"));
         child.unref();
     });
 }
@@ -10731,12 +10775,9 @@ function simulateProgram(prg, device, test) {
     const args = [prg, device];
     if (test)
         args.push("-t");
-    return (0,external_sdk_util_cjs_namespaceObject.getSdkPath)().then((sdk) => (0,external_util_cjs_namespaceObject.spawnByLine)(external_path_default().resolve(sdk, "bin", "monkeydo"), args, (line) => console.log(line)).then(() => { }));
+    return (0,external_sdk_util_cjs_namespaceObject.getSdkPath)().then((sdk) => (0,external_util_cjs_namespaceObject.spawnByLine)(external_path_.resolve(sdk, "bin", "monkeydo"), args, (line) => console.log(line)).then(() => { }));
 }
 
-;// CONCATENATED MODULE: external "@markw65/prettier-plugin-monkeyc"
-const prettier_plugin_monkeyc_namespaceObject = require("@markw65/prettier-plugin-monkeyc");
-var prettier_plugin_monkeyc_default = /*#__PURE__*/__webpack_require__.n(prettier_plugin_monkeyc_namespaceObject);
 ;// CONCATENATED MODULE: ./src/mc-rewrite.ts
 
 
@@ -10744,16 +10785,17 @@ var prettier_plugin_monkeyc_default = /*#__PURE__*/__webpack_require__.n(prettie
 
 function processImports(allImports, lookup) {
     allImports.forEach(({ node, stack }) => {
-        const [name, module] = lookup(node.id, "as" in node && node.as && node.as.name, stack);
+        const [name, module] = lookup(node.id, ("as" in node && node.as && node.as.name) || null, stack);
         if (name && module) {
             const [parent] = stack.slice(-1);
             if (!parent.decls)
                 parent.decls = {};
+            const decls = parent.decls;
             if (!(0,external_api_cjs_namespaceObject.hasProperty)(parent.decls, name))
                 parent.decls[name] = [];
             module.forEach((m) => {
                 if ((0,external_api_cjs_namespaceObject.isStateNode)(m) && m.type == "ModuleDeclaration") {
-                    (0,external_util_cjs_namespaceObject.pushUnique)(parent.decls[name], m);
+                    (0,external_util_cjs_namespaceObject.pushUnique)(decls[name], m);
                 }
             });
         }
@@ -10824,7 +10866,7 @@ async function analyze(fnMap) {
     let excludeAnnotations;
     let hasTests = false;
     const allImports = [];
-    const state = {
+    const preState = {
         allFunctions: [],
         allClasses: [],
         shouldExclude(node) {
@@ -10848,7 +10890,7 @@ async function analyze(fnMap) {
             }
             return null;
         },
-        post(node) {
+        post(node, state) {
             switch (node.type) {
                 case "FunctionDeclaration":
                 case "ClassDeclaration": {
@@ -10867,10 +10909,13 @@ async function analyze(fnMap) {
                 case "ImportModule":
                     allImports.push({ node, stack: state.stack.slice() });
                     return null;
+                default:
+                    return null;
             }
         },
     };
-    await (0,external_api_cjs_namespaceObject.getApiMapping)(state);
+    await (0,external_api_cjs_namespaceObject.getApiMapping)(preState);
+    const state = preState;
     // Mark all functions from api.mir as "special" by
     // setting their bodies to null. In api.mir, they're
     // all empty, which makes it look like they're
@@ -10879,7 +10924,7 @@ async function analyze(fnMap) {
         if (node.type == "FunctionDeclaration") {
             node.node.body = null;
         }
-        if ("decls" in node) {
+        if ((0,external_api_cjs_namespaceObject.isStateNode)(node) && node.decls) {
             Object.values(node.decls).forEach((v) => v.forEach(markApi));
         }
     };
@@ -10933,6 +10978,8 @@ function getLiteralFromDecls(decls) {
     return null;
 }
 function getLiteralNode(node) {
+    if (node == null)
+        return null;
     if (node.type == "Literal")
         return node;
     if (node.type == "BinaryExpression" && node.operator == "as") {
@@ -10971,11 +11018,11 @@ function getNodeValue(node) {
     }
     let type = node.value === null ? "Null" : typeof node.value;
     if (type === "number") {
-        const match = prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.exec(node.raw);
+        const match = node.raw && prettier_plugin_monkeyc_namespaceObject.LiteralIntegerRe.exec(node.raw);
         if (match) {
             type = match[2] == "l" ? "Long" : "Number";
         }
-        else if (node.raw.endsWith("d")) {
+        else if (node.raw && node.raw.endsWith("d")) {
             type = "Double";
         }
         else {
@@ -11098,11 +11145,12 @@ function evaluateFunction(func, args) {
                 default:
                     throw new Error("Bad node type");
             }
-        }, args &&
-            ((node) => {
+        }, !args
+            ? undefined
+            : (node) => {
                 switch (node.type) {
                     case "ReturnStatement":
-                        ret = node.argument;
+                        ret = node.argument || null;
                         return null;
                     case "BlockStatement":
                     case "Literal":
@@ -11119,7 +11167,7 @@ function evaluateFunction(func, args) {
                         throw new Error("Didn't optimize");
                     }
                 }
-            }));
+            });
         return ret;
     }
     catch (e) {
@@ -11127,7 +11175,12 @@ function evaluateFunction(func, args) {
     }
 }
 async function optimizeMonkeyC(fnMap) {
-    const state = await analyze(fnMap);
+    const state = {
+        ...(await analyze(fnMap)),
+        localsStack: [{}],
+        exposed: {},
+        calledFunctions: {},
+    };
     const replace = (node, obj) => {
         for (const k of Object.keys(node)) {
             delete node[k];
@@ -11156,6 +11209,7 @@ async function optimizeMonkeyC(fnMap) {
         replace(node, obj);
         return true;
     };
+    const topLocals = () => state.localsStack[state.localsStack.length - 1];
     /*
      * Might this function be called from somewhere, including
      * callbacks from the api (eg getSettingsView, etc).
@@ -11193,17 +11247,15 @@ async function optimizeMonkeyC(fnMap) {
                 f.type == "FunctionDeclaration" &&
                 maybeCalled(f.node))) ||
             (sc.superClass && checkInherited(sc, name)));
-    state.localsStack = [{}];
-    state.exposed = {};
-    state.calledFunctions = {};
     state.pre = (node) => {
         switch (node.type) {
             case "ConditionalExpression":
             case "IfStatement":
             case "DoWhileStatement":
             case "WhileStatement":
-                state.traverse(node.test);
-                const [value, type] = getNodeValue(node.test);
+                const test = (state.traverse(node.test) ||
+                    node.test);
+                const [value, type] = getNodeValue(test);
                 if (value) {
                     let result = null;
                     if (type === "Null") {
@@ -11215,25 +11267,16 @@ async function optimizeMonkeyC(fnMap) {
                         result = !!value.value;
                     }
                     if (result !== null) {
+                        node.test = { type: "Literal", value: result };
                         if (node.type === "IfStatement" ||
                             node.type === "ConditionalExpression") {
-                            if (result === false) {
-                                node.consequent = null;
-                            }
-                            else {
-                                node.alternate = null;
-                            }
-                            node.test = null;
+                            return [result ? "consequent" : "alternate"];
                         }
                         else if (node.type === "WhileStatement") {
-                            if (result === false) {
-                                node.body = null;
-                            }
+                            return result === false ? [] : ["body"];
                         }
                         else if (node.type === "DoWhileStatement") {
-                            if (result === false) {
-                                node.test = null;
-                            }
+                            return ["body"];
                         }
                         else {
                             throw new Error("Unexpected Node type");
@@ -11244,14 +11287,14 @@ async function optimizeMonkeyC(fnMap) {
             case "EnumDeclaration":
                 return false;
             case "ForStatement": {
-                const map = state.localsStack.slice(-1).pop().map;
+                const map = topLocals().map;
                 if (map) {
                     state.localsStack.push({ node, map: { ...map } });
                 }
                 break;
             }
             case "VariableDeclarator": {
-                const locals = state.localsStack.slice(-1).pop();
+                const locals = topLocals();
                 const { map } = locals;
                 if (map) {
                     const declName = (0,external_api_cjs_namespaceObject.variableDeclarationName)(node.id);
@@ -11269,9 +11312,10 @@ async function optimizeMonkeyC(fnMap) {
                             // find all the names declared in this scope, to avoid
                             // more conflicts
                             locals.inners = {};
+                            const inners = locals.inners;
                             (0,external_api_cjs_namespaceObject.traverseAst)(locals.node, (node) => {
                                 if (node.type === "VariableDeclarator") {
-                                    locals.inners[(0,external_api_cjs_namespaceObject.variableDeclarationName)(node.id)] = true;
+                                    inners[(0,external_api_cjs_namespaceObject.variableDeclarationName)(node.id)] = true;
                                 }
                             });
                         }
@@ -11292,7 +11336,8 @@ async function optimizeMonkeyC(fnMap) {
                                             break;
                                         }
                                     }
-                                    else if (elm.node.type === "FunctionDeclaration") {
+                                    else if (elm.node &&
+                                        elm.node.type === "FunctionDeclaration") {
                                         ok = true;
                                     }
                                 }
@@ -11331,7 +11376,7 @@ async function optimizeMonkeyC(fnMap) {
                 }
                 break;
             case "Identifier": {
-                const map = state.localsStack.slice(-1).pop().map;
+                const map = topLocals().map;
                 if (map) {
                     if ((0,external_api_cjs_namespaceObject.hasProperty)(map, node.name)) {
                         const name = map[node.name];
@@ -11362,7 +11407,7 @@ async function optimizeMonkeyC(fnMap) {
                 }
                 break;
             case "BlockStatement": {
-                const map = state.localsStack.slice(-1).pop().map;
+                const map = topLocals().map;
                 if (map) {
                     state.localsStack.push({
                         node,
@@ -11397,7 +11442,7 @@ async function optimizeMonkeyC(fnMap) {
         return null;
     };
     state.post = (node) => {
-        if (state.localsStack.slice(-1).pop().node === node) {
+        if (topLocals().node === node) {
             state.localsStack.pop();
         }
         const opt = optimizeNode(node);
@@ -11408,20 +11453,23 @@ async function optimizeMonkeyC(fnMap) {
         switch (node.type) {
             case "ConditionalExpression":
             case "IfStatement":
-                if (node.test === null) {
-                    const rep = node.consequent || node.alternate;
+                if (node.test.type === "Literal" &&
+                    typeof node.test.value === "boolean") {
+                    const rep = node.test.value ? node.consequent : node.alternate;
                     if (!rep)
                         return false;
                     replace(node, rep);
                 }
                 break;
             case "WhileStatement":
-                if (!node.body)
+                if (node.test.type === "Literal" && node.test.value === false) {
                     return false;
+                }
                 break;
             case "DoWhileStatement":
-                if (!node.test)
+                if (node.test.type === "Literal" && node.test.value === false) {
                     return node.body;
+                }
                 break;
             case "CallExpression": {
                 const [name, callees] = state.lookup(node.callee);
@@ -11443,7 +11491,8 @@ async function optimizeMonkeyC(fnMap) {
                 }
                 if (callees.length == 1) {
                     const callee = (0,external_api_cjs_namespaceObject.isStateNode)(callees[0]) && callees[0].node;
-                    if (callee.type == "FunctionDeclaration" &&
+                    if (callee &&
+                        callee.type == "FunctionDeclaration" &&
                         callee.optimizable &&
                         !callee.hasOverride &&
                         node.arguments.every((n) => getNodeValue(n)[0] !== null)) {
@@ -11467,7 +11516,7 @@ async function optimizeMonkeyC(fnMap) {
         (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
     });
     Object.values(fnMap).forEach((f) => {
-        (0,external_api_cjs_namespaceObject.traverseAst)(f.ast, null, (node) => {
+        (0,external_api_cjs_namespaceObject.traverseAst)(f.ast, undefined, (node) => {
             switch (node.type) {
                 case "EnumStringBody":
                     if (node.members.every((m) => {
@@ -11565,6 +11614,9 @@ const defaultConfig = {
     outputPath: "bin/optimized",
     workspace: "./",
 };
+function isErrorWithLocation(e) {
+    return (0,external_api_cjs_namespaceObject.hasProperty)(e, "location");
+}
 /**
  * @param {BuildConfig} options
  * @returns {Promise<BuildConfig>}
@@ -11621,14 +11673,14 @@ async function buildOptimizedProject(product, options) {
     if (product) {
         product = config.products[0];
         if (config.simulatorBuild === false) {
-            bin = external_path_default().join(bin, product);
+            bin = external_path_.join(bin, product);
         }
     }
     else {
-        bin = external_path_default().join(bin, "exported");
+        bin = external_path_.join(bin, "exported");
         name = `${program}.iq`;
     }
-    config.program = external_path_default().join(bin, name);
+    config.program = external_path_.join(bin, name);
     if (!hasTests)
         delete config.testBuild;
     return build_project(product, config).then((result) => ({
@@ -11654,7 +11706,7 @@ async function buildOptimizedProject(product, options) {
  * @param {Target[]} targets
  */
 async function createLocalBarrels(targets, options) {
-    if (targets.every((target) => !target.group.optimizerConfig.barrelMap ||
+    if (targets.every((target) => !target.group?.optimizerConfig.barrelMap ||
         Object.values(target.group.optimizerConfig.barrelMap).every((resolvedBarrel) => !resolvedBarrel.qualifier.resourcePath))) {
         // there are no barrels, or every barrel has no resources.
         // we can drop any barrels altogether (we'll need to drop them
@@ -11662,8 +11714,10 @@ async function createLocalBarrels(targets, options) {
         return null;
     }
     // where to create the local barrel projects.
-    const barrelDir = external_path_default().resolve(options.workspace, options.outputPath, "opt-barrels");
+    const barrelDir = external_path_.resolve(options.workspace, options.outputPath, "opt-barrels");
     return targets.reduce((promise, target) => {
+        if (!target.group)
+            return promise;
         const barrelMap = target.group.optimizerConfig.barrelMap;
         if (!barrelMap || target.group.optimizerConfig.optBarrels) {
             return promise;
@@ -11671,13 +11725,13 @@ async function createLocalBarrels(targets, options) {
         const optBarrels = (target.group.optimizerConfig.optBarrels = {});
         return Object.entries(barrelMap).reduce((promise, [barrel, resolvedBarrel]) => {
             const { manifest, jungles } = resolvedBarrel;
-            const rawBarrelDir = external_path_default().dirname(jungles[0]);
-            const rawJungles = jungles.map((jungle) => external_path_default().relative(rawBarrelDir, jungle));
+            const rawBarrelDir = external_path_.dirname(jungles[0]);
+            const rawJungles = jungles.map((jungle) => external_path_.relative(rawBarrelDir, jungle));
             const sha1 = external_crypto_namespaceObject.createHash("sha1")
                 .update(rawBarrelDir, "binary")
                 .digest("base64")
                 .replace(/[\/=+]/g, "");
-            const optBarrelDir = external_path_default().resolve(barrelDir, `${barrel}-${sha1}`);
+            const optBarrelDir = external_path_.resolve(barrelDir, `${barrel}-${sha1}`);
             if (!(0,external_api_cjs_namespaceObject.hasProperty)(optBarrels, barrel)) {
                 optBarrels[barrel] = {
                     rawBarrelDir,
@@ -11690,22 +11744,28 @@ async function createLocalBarrels(targets, options) {
             if (optBarrels[barrel].manifest !== manifest ||
                 optBarrels[barrel].optBarrelDir !== optBarrelDir ||
                 optBarrels[barrel].rawBarrelDir != rawBarrelDir) {
-                throw new Error(`For device ${target.product}, barrel ${barrel} was mapped to both ${external_path_default().relative(optBarrels[barrel].rawBarrelDir, optBarrels[barrel].manifest)} in ${optBarrels[barrel].rawBarrelDir} and ${external_path_default().relative(rawBarrelDir, manifest)} in ${rawBarrelDir}.`);
+                throw new Error(`For device ${target.product}, barrel ${barrel} was mapped to both ${external_path_.relative(optBarrels[barrel].rawBarrelDir, optBarrels[barrel].manifest)} in ${optBarrels[barrel].rawBarrelDir} and ${external_path_.relative(rawBarrelDir, manifest)} in ${rawBarrelDir}.`);
             }
             optBarrels[barrel].jungleFiles.push(...rawJungles);
             return promise;
         }, promise);
     }, Promise.resolve());
 }
-/**
- *
- * @param {BuildConfig} options
- * @returns
- */
 async function generateOptimizedProject(options) {
     const config = await getConfig(options);
     const workspace = config.workspace;
     const { manifest, targets, xml, jungles } = await get_jungle(config.jungleFiles, config);
+    if (!xml["iq:manifest"]["iq:application"]) {
+        const error = new Error(xml["iq:manifest"]["iq:barrel"]
+            ? "Optimize the project that uses this barrel, not the barrel itself"
+            : "Manifest is missing an `iq:application` tag");
+        error.location = {
+            start: { line: 1, column: 1 },
+            end: { line: 1, column: 1 },
+            source: manifest,
+        };
+        throw error;
+    }
     const dependencyFiles = [manifest, ...jungles];
     await createLocalBarrels(targets, options);
     const buildConfigs = {};
@@ -11718,12 +11778,15 @@ async function generateOptimizedProject(options) {
         }
         return {
             jungleFiles: config.jungleFiles,
-            program: external_path_default().basename(external_path_default().dirname(manifest)),
+            program: external_path_.basename(external_path_.dirname(manifest)),
         };
     }
     let dropBarrels = false;
     const configKey = (p) => p.group.key + (config.releaseBuild ? "-release" : "-debug");
     targets.forEach((p) => {
+        if (!p.group) {
+            throw new Error(`Missing group in build target ${p.product}`);
+        }
         const key = configKey(p);
         if (!(0,external_api_cjs_namespaceObject.hasProperty)(buildConfigs, key)) {
             p.group.dir = key;
@@ -11752,9 +11815,9 @@ async function generateOptimizedProject(options) {
         }
     });
     // console.log(JSON.stringify(targets));
-    const jungle_dir = external_path_default().resolve(workspace, config.outputPath);
+    const jungle_dir = external_path_.resolve(workspace, config.outputPath);
     await promises_namespaceObject.mkdir(jungle_dir, { recursive: true });
-    const relative_path = (s) => external_path_default().relative(jungle_dir, s);
+    const relative_path = (s) => external_path_.relative(jungle_dir, s);
     let relative_manifest = relative_path(manifest);
     const manifestOk = (!config.checkManifest ||
         (await checkManifest(xml, targets.map((t) => t.product)))) &&
@@ -11764,7 +11827,7 @@ async function generateOptimizedProject(options) {
         .sort()
         .map((key) => {
         const buildConfig = buildConfigs[key];
-        const outputPath = external_path_default().join(config.outputPath, key);
+        const outputPath = external_path_.join(config.outputPath, key);
         return buildConfig
             ? generateOneConfig(buildConfig, dependencyFiles, {
                 ...config,
@@ -11778,7 +11841,7 @@ async function generateOptimizedProject(options) {
                 throw e;
             })
                 .then((t) => t && (hasTests = true))
-            : promises_namespaceObject.rm(external_path_default().resolve(workspace, outputPath), {
+            : promises_namespaceObject.rm(external_path_.resolve(workspace, outputPath), {
                 recursive: true,
                 force: true,
             });
@@ -11787,29 +11850,33 @@ async function generateOptimizedProject(options) {
         if (dropBarrels) {
             manifestDropBarrels(xml);
         }
-        const manifestFile = external_path_default().join(jungle_dir, "manifest.xml");
+        const manifestFile = external_path_.join(jungle_dir, "manifest.xml");
         promises.push(writeManifest(manifestFile, xml));
         relative_manifest = "manifest.xml";
     }
     const parts = [`project.manifest=${relative_manifest}`];
     const process_field = (prefix, base, name, mapper = null) => {
-        if (!base[name])
+        const obj = base[name];
+        if (!obj)
             return;
         const map_one = (s) => (mapper ? mapper(s) : s);
         const map = (s) => Array.isArray(s) ? `[${s.map(map_one).join(";")}]` : map_one(s);
-        parts.push(`${prefix}${name} = ${base[name].map(map).join(";")}`);
+        parts.push(`${prefix}${name} = ${obj.map(map).join(";")}`);
     };
-    targets.forEach((jungle) => {
-        if (!buildConfigs[configKey(jungle)])
+    targets.forEach((target) => {
+        if (!buildConfigs[configKey(target)])
             return;
-        const { product, qualifier, group } = jungle;
+        const { product, qualifier, group } = target;
+        if (!group) {
+            throw new Error(`Missing group in target ${target.product}`);
+        }
         const prefix = `${product}.`;
-        process_field(prefix, qualifier, "sourcePath", (s) => external_path_default().join(group.dir, "source", relative_path_no_dotdot(external_path_default().relative(workspace, s)))
+        process_field(prefix, qualifier, "sourcePath", (s) => external_path_.join(group.dir, "source", relative_path_no_dotdot(external_path_.relative(workspace, s)))
             .replace(/([\\\/]\*\*)[\\\/]\*/g, "$1"));
         if (group.optimizerConfig.optBarrels) {
             parts.push(`${prefix}barrelPath = ${Object.values(group.optimizerConfig.optBarrels)
                 .map((value) => `[${value.jungleFiles
-                .map((j) => relative_path(external_path_default().join(value.optBarrelDir, j)))
+                .map((j) => relative_path(external_path_.join(value.optBarrelDir, j)))
                 .join(";")}]`)
                 .join(";")}`);
         }
@@ -11817,8 +11884,8 @@ async function generateOptimizedProject(options) {
             parts.push(`${prefix}sourcePath = ${[`$(${prefix}sourcePath)`]
                 .concat(Object.entries(group.optimizerConfig.barrelMap)
                 .map(([barrel, resolvedBarrel]) => {
-                const root = external_path_default().dirname(resolvedBarrel.jungles[0]);
-                return (resolvedBarrel.qualifier.sourcePath || []).map((s) => external_path_default().join(group.dir, "barrels", barrel, external_path_default().relative(root, s))
+                const root = external_path_.dirname(resolvedBarrel.jungles[0]);
+                return (resolvedBarrel.qualifier.sourcePath || []).map((s) => external_path_.join(group.dir, "barrels", barrel, external_path_.relative(root, s))
                     .replace(/([\\\/]\*\*)[\\\/]\*/g, "$1"));
             })
                 .flat()
@@ -11829,29 +11896,31 @@ async function generateOptimizedProject(options) {
         // annotations were handled via source transformations.
         process_field(prefix, qualifier, "resourcePath", relative_path);
         process_field(prefix, qualifier, "excludeAnnotations");
-        if (qualifier.lang) {
-            Object.keys(qualifier.lang).forEach((key) => {
-                process_field(`${prefix}lang.`, qualifier.lang, key, relative_path);
+        const qlang = qualifier.lang;
+        if (qlang) {
+            Object.keys(qlang).forEach((key) => {
+                process_field(`${prefix}lang.`, qlang, key, relative_path);
             });
         }
     });
-    const jungleFiles = external_path_default().join(jungle_dir, `${config.releaseBuild ? "release" : "debug"}.jungle`);
+    const jungleFiles = external_path_.join(jungle_dir, `${config.releaseBuild ? "release" : "debug"}.jungle`);
     promises.push(promises_namespaceObject.writeFile(jungleFiles, parts.join("\n")));
     await Promise.all(promises);
     return {
         jungleFiles,
-        program: external_path_default().basename(external_path_default().dirname(manifest)),
+        xml,
+        program: external_path_.basename(external_path_.dirname(manifest)),
         hasTests,
     };
 }
 async function fileInfoFromConfig(workspace, output, buildConfig, extraExcludes) {
-    const paths = (await Promise.all(buildConfig.sourcePath.map((pattern) => (0,external_util_cjs_namespaceObject.globa)(pattern, { cwd: workspace, mark: true })))).flat();
+    const paths = (await Promise.all(buildConfig.sourcePath?.map((pattern) => (0,external_util_cjs_namespaceObject.globa)(pattern, { cwd: workspace, mark: true })) || [])).flat();
     const files = (await Promise.all(paths.map((path) => path.endsWith("/")
         ? (0,external_util_cjs_namespaceObject.globa)(`${path}**/*.mc`, { cwd: workspace, mark: true })
         : path)))
         .flat()
         .filter((file) => file.endsWith(".mc") &&
-        !external_path_default().relative(workspace, file).startsWith("bin") &&
+        !external_path_.relative(workspace, file).startsWith("bin") &&
         (!buildConfig.sourceExcludes ||
             !buildConfig.sourceExcludes.includes(file)));
     const excludeAnnotations = Object.assign(buildConfig.excludeAnnotations
@@ -11861,7 +11930,7 @@ async function fileInfoFromConfig(workspace, output, buildConfig, extraExcludes)
         fnMap: Object.fromEntries(files.map((file) => [
             file,
             {
-                output: external_path_default().join(output, relative_path_no_dotdot(external_path_default().relative(workspace, file))),
+                output: external_path_.join(output, relative_path_no_dotdot(external_path_.relative(workspace, file))),
                 excludeAnnotations,
             },
         ])),
@@ -11896,7 +11965,7 @@ const configOptionsToCheck = [
  */
 async function generateOneConfig(buildConfig, dependencyFiles, config) {
     const { workspace } = config;
-    const output = external_path_default().join(workspace, config.outputPath);
+    const output = external_path_.join(workspace, config.outputPath);
     const buildModeExcludes = {
         // note: exclude debug in release builds, and release in debug builds
         [config.releaseBuild ? "debug" : "release"]: true,
@@ -11904,12 +11973,12 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
     if (!config.testBuild) {
         buildModeExcludes.test = true;
     }
-    const { fnMap } = await fileInfoFromConfig(workspace, external_path_default().join(output, "source"), buildConfig, buildModeExcludes);
+    const { fnMap } = await fileInfoFromConfig(workspace, external_path_.join(output, "source"), buildConfig, buildModeExcludes);
     if (buildConfig.barrelMap) {
         const barrelFnMaps = await Promise.all(Object.entries(buildConfig.barrelMap)
             .map(([barrel, resolvedBarrel]) => {
             dependencyFiles = dependencyFiles.concat(resolvedBarrel.jungles, resolvedBarrel.manifest);
-            return fileInfoFromConfig(external_path_default().dirname(resolvedBarrel.jungles[0]), external_path_default().join(output, "barrels", barrel), resolvedBarrel.qualifier, {
+            return fileInfoFromConfig(external_path_.dirname(resolvedBarrel.jungles[0]), external_path_.join(output, "barrels", barrel), resolvedBarrel.qualifier, {
                 ...buildModeExcludes,
                 ...excludesFromAnnotations(barrel, buildConfig.annotations, resolvedBarrel),
             }).then(({ fnMap }) => fnMap);
@@ -11917,10 +11986,10 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
             .flat());
         barrelFnMaps.forEach((barrelFnMap) => Object.assign(fnMap, barrelFnMap));
     }
-    const actualOptimizedFiles = (await (0,external_util_cjs_namespaceObject.globa)(external_path_default().join(output, "**", "*.mc"), { mark: true }))
+    const actualOptimizedFiles = (await (0,external_util_cjs_namespaceObject.globa)(external_path_.join(output, "**", "*.mc"), { mark: true }))
         .filter((file) => !file.endsWith("/"))
         .sort();
-    const { hasTests, ...prevOptions } = JSON.parse(await promises_namespaceObject.readFile(external_path_default().join(output, "build-info.json"), "utf-8")
+    const { hasTests, ...prevOptions } = JSON.parse(await promises_namespaceObject.readFile(external_path_.join(output, "build-info.json"), "utf-8")
         .catch(() => "{}"));
     // check that the set of files thats actually there is the same as the
     // set of files we're going to generate (in case eg a jungle file change
@@ -11937,7 +12006,7 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
         // the oldest optimized file, we don't need to regenerate
         const source_time = await (0,external_util_cjs_namespaceObject.last_modified)(Object.keys(fnMap).concat(dependencyFiles));
         const opt_time = await (0,external_util_cjs_namespaceObject.first_modified)(Object.values(fnMap).map((v) => v.output));
-        if (source_time < opt_time && 1653327101857 < opt_time) {
+        if (source_time < opt_time && 1653671578547 < opt_time) {
             return hasTests;
         }
     }
@@ -11946,14 +12015,14 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
     await optimizeMonkeyC(fnMap);
     return Promise.all(Object.values(fnMap).map(async (info) => {
         const name = info.output;
-        const dir = external_path_default().dirname(name);
+        const dir = external_path_.dirname(name);
         await promises_namespaceObject.mkdir(dir, { recursive: true });
         const opt_source = (0,external_api_cjs_namespaceObject.formatAst)(info.ast, info.monkeyCSource);
         await promises_namespaceObject.writeFile(name, opt_source);
         return info.hasTests;
     })).then((results) => {
         const hasTests = results.some((v) => v);
-        return promises_namespaceObject.writeFile(external_path_default().join(output, "build-info.json"), JSON.stringify({
+        return promises_namespaceObject.writeFile(external_path_.join(output, "build-info.json"), JSON.stringify({
             hasTests,
             ...Object.fromEntries(configOptionsToCheck.map((option) => [option, config[option]])),
         }))
@@ -11963,6 +12032,7 @@ async function generateOneConfig(buildConfig, dependencyFiles, config) {
 async function getProjectAnalysis(targets, analysis, options) {
     const sourcePath = targets
         .map(({ qualifier: { sourcePath } }) => sourcePath)
+        .filter((sp) => sp != null)
         .flat()
         .sort()
         .filter((s, i, arr) => !i || s !== arr[i - 1]);
@@ -11993,21 +12063,28 @@ async function generateApiMirTests(options) {
     const config = { ...defaultConfig, ...(options || {}) };
     const tests = [];
     const api = await (0,external_api_cjs_namespaceObject.getApiMapping)();
+    if (!api) {
+        throw new Error("Failed to read api.mir");
+    }
     const findConstants = (node) => {
-        Object.entries(node.decls).forEach(([key, decl]) => {
-            if (decl.length > 1)
-                throw `Bad decl length:${node.fullName}.${key}`;
-            if (decl.length != 1)
-                return;
-            const d = decl[0];
-            if (d.type === "EnumStringMember" ||
-                (d.type === "VariableDeclarator" && d.kind === "const")) {
-                tests.push([`${node.fullName}.${key}`, (0,external_api_cjs_namespaceObject.formatAst)(d.init)]);
-            }
-            else if ((0,external_api_cjs_namespaceObject.isStateNode)(d)) {
-                findConstants(d);
-            }
-        });
+        node.decls &&
+            Object.entries(node.decls).forEach(([key, decl]) => {
+                if (decl.length > 1)
+                    throw `Bad decl length:${node.fullName}.${key}`;
+                if (decl.length != 1)
+                    return;
+                const d = decl[0];
+                if (d.type === "EnumStringMember" ||
+                    (d.type === "VariableDeclarator" && d.kind === "const")) {
+                    if (!d.init) {
+                        throw new Error(`Missing init for ${node.fullName}.${key}`);
+                    }
+                    tests.push([`${node.fullName}.${key}`, (0,external_api_cjs_namespaceObject.formatAst)(d.init)]);
+                }
+                else if ((0,external_api_cjs_namespaceObject.isStateNode)(d)) {
+                    findConstants(d);
+                }
+            });
     };
     findConstants(api);
     function hasTests(name) {