@markw65/monkeyc-optimizer 1.0.12 → 1.0.15

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__ = ({
 
@@ -1289,7 +1289,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 const debug = __webpack_require__(1227)('extract-zip')
 // eslint-disable-next-line node/no-unsupported-features/node-builtins
 const { createWriteStream, promises: fs } = __webpack_require__(6231)
-const getStream = __webpack_require__(7491)
+const getStream = __webpack_require__(31)
 const path = __webpack_require__(1423)
 const { promisify } = __webpack_require__(6464)
 const stream = __webpack_require__(8311)
@@ -1461,134 +1461,6 @@ module.exports = async function (zipPath, opts) {
 }
 
 
-/***/ }),
-
-/***/ 2297:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-const {PassThrough: PassThroughStream} = __webpack_require__(8311);
-
-module.exports = options => {
-	options = {...options};
-
-	const {array} = options;
-	let {encoding} = options;
-	const isBuffer = encoding === 'buffer';
-	let objectMode = false;
-
-	if (array) {
-		objectMode = !(encoding || isBuffer);
-	} else {
-		encoding = encoding || 'utf8';
-	}
-
-	if (isBuffer) {
-		encoding = null;
-	}
-
-	const stream = new PassThroughStream({objectMode});
-
-	if (encoding) {
-		stream.setEncoding(encoding);
-	}
-
-	let length = 0;
-	const chunks = [];
-
-	stream.on('data', chunk => {
-		chunks.push(chunk);
-
-		if (objectMode) {
-			length = chunks.length;
-		} else {
-			length += chunk.length;
-		}
-	});
-
-	stream.getBufferedValue = () => {
-		if (array) {
-			return chunks;
-		}
-
-		return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
-	};
-
-	stream.getBufferedLength = () => length;
-
-	return stream;
-};
-
-
-/***/ }),
-
-/***/ 7491:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
-
-"use strict";
-
-const {constants: BufferConstants} = __webpack_require__(871);
-const pump = __webpack_require__(4286);
-const bufferStream = __webpack_require__(2297);
-
-class MaxBufferError extends Error {
-	constructor() {
-		super('maxBuffer exceeded');
-		this.name = 'MaxBufferError';
-	}
-}
-
-async function getStream(inputStream, options) {
-	if (!inputStream) {
-		return Promise.reject(new Error('Expected a stream'));
-	}
-
-	options = {
-		maxBuffer: Infinity,
-		...options
-	};
-
-	const {maxBuffer} = options;
-
-	let stream;
-	await new Promise((resolve, reject) => {
-		const rejectPromise = error => {
-			// Don't retrieve an oversized buffer.
-			if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
-				error.bufferedData = stream.getBufferedValue();
-			}
-
-			reject(error);
-		};
-
-		stream = pump(inputStream, bufferStream(options), error => {
-			if (error) {
-				rejectPromise(error);
-				return;
-			}
-
-			resolve();
-		});
-
-		stream.on('data', () => {
-			if (stream.getBufferedLength() > maxBuffer) {
-				rejectPromise(new MaxBufferError());
-			}
-		});
-	});
-
-	return stream.getBufferedValue();
-}
-
-module.exports = getStream;
-// TODO: Remove this for the next major release
-module.exports["default"] = getStream;
-module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
-module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
-module.exports.MaxBufferError = MaxBufferError;
-
-
 /***/ }),
 
 /***/ 8913:
@@ -1892,6 +1764,134 @@ function createFromFd(fd, options) {
 }
 
 
+/***/ }),
+
+/***/ 5105:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const {PassThrough: PassThroughStream} = __webpack_require__(8311);
+
+module.exports = options => {
+	options = {...options};
+
+	const {array} = options;
+	let {encoding} = options;
+	const isBuffer = encoding === 'buffer';
+	let objectMode = false;
+
+	if (array) {
+		objectMode = !(encoding || isBuffer);
+	} else {
+		encoding = encoding || 'utf8';
+	}
+
+	if (isBuffer) {
+		encoding = null;
+	}
+
+	const stream = new PassThroughStream({objectMode});
+
+	if (encoding) {
+		stream.setEncoding(encoding);
+	}
+
+	let length = 0;
+	const chunks = [];
+
+	stream.on('data', chunk => {
+		chunks.push(chunk);
+
+		if (objectMode) {
+			length = chunks.length;
+		} else {
+			length += chunk.length;
+		}
+	});
+
+	stream.getBufferedValue = () => {
+		if (array) {
+			return chunks;
+		}
+
+		return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
+	};
+
+	stream.getBufferedLength = () => length;
+
+	return stream;
+};
+
+
+/***/ }),
+
+/***/ 31:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const {constants: BufferConstants} = __webpack_require__(871);
+const pump = __webpack_require__(4286);
+const bufferStream = __webpack_require__(5105);
+
+class MaxBufferError extends Error {
+	constructor() {
+		super('maxBuffer exceeded');
+		this.name = 'MaxBufferError';
+	}
+}
+
+async function getStream(inputStream, options) {
+	if (!inputStream) {
+		return Promise.reject(new Error('Expected a stream'));
+	}
+
+	options = {
+		maxBuffer: Infinity,
+		...options
+	};
+
+	const {maxBuffer} = options;
+
+	let stream;
+	await new Promise((resolve, reject) => {
+		const rejectPromise = error => {
+			// Don't retrieve an oversized buffer.
+			if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
+				error.bufferedData = stream.getBufferedValue();
+			}
+
+			reject(error);
+		};
+
+		stream = pump(inputStream, bufferStream(options), error => {
+			if (error) {
+				rejectPromise(error);
+				return;
+			}
+
+			resolve();
+		});
+
+		stream.on('data', () => {
+			if (stream.getBufferedLength() > maxBuffer) {
+				rejectPromise(new MaxBufferError());
+			}
+		});
+	});
+
+	return stream.getBufferedValue();
+}
+
+module.exports = getStream;
+// TODO: Remove this for the next major release
+module.exports["default"] = getStream;
+module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
+module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
+module.exports.MaxBufferError = MaxBufferError;
+
+
 /***/ }),
 
 /***/ 7824:
@@ -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 (![
@@ -10067,7 +10077,8 @@ async function default_jungle() {
         }
         rezAndLang(deviceId, `resources-${deviceId}`, deviceFamily);
     });
-    return process_assignments(assignments, {});
+    const state = await process_assignments(assignments, {});
+    return { state, devices };
 }
 function process_assignments(assignments, current) {
     return assignments.reduce((state, a) => {
@@ -10081,7 +10092,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 +10166,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);
 }
@@ -10167,9 +10180,9 @@ async function process_jungles(sources) {
         sources = [sources];
     }
     const results = await Promise.all(sources.map(parse_one));
-    const state = await default_jungle();
+    const { state, devices } = await default_jungle();
     results.forEach((r) => process_assignments(r, state));
-    return state;
+    return { state, devices };
 }
 function resolve_node_list(state, list) {
     if (!Array.isArray(list)) {
@@ -10210,24 +10223,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;
     }
@@ -10266,7 +10304,7 @@ function resolve_filename(literal, default_source = null) {
     const root = external_path_.dirname(literal.source || default_source);
     return external_path_.resolve(root, literal.value);
 }
-async function resolve_literals(qualifier, default_source) {
+async function resolve_literals(qualifier, default_source, deviceInfo) {
     const resolve_file_list = async (literals) => literals &&
         (await Promise.all(literals.map(async (v) => {
             if (!isJNode(v)) {
@@ -10293,9 +10331,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];
         }
@@ -10308,7 +10347,13 @@ async function resolve_literals(qualifier, default_source) {
     await resolve_one_file_list(qualifier, "barrelPath");
     const lang = qualifier["lang"];
     if (lang) {
-        await Promise.all(Object.keys(lang).map((key) => resolve_one_file_list(lang, key)));
+        await Promise.all(Object.keys(lang).map((key) => {
+            if (!(0,external_api_cjs_namespaceObject.hasProperty)(deviceInfo.languages, key)) {
+                delete lang[key];
+                return null;
+            }
+            return resolve_one_file_list(lang, key);
+        }));
         if (Object.keys(lang).length === 0)
             delete qualifier["lang"];
     }
@@ -10453,14 +10498,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 +10602,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 +10670,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 +10685,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);
     });
 }
 /**
@@ -10661,7 +10711,7 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
             jungles.push(barrels_jungle);
         }
     }
-    const state = await process_jungles(jungles);
+    const { state, devices } = await process_jungles(jungles);
     // apparently square_watch is an alias for rectangle_watch
     state["square_watch"] = state["rectangle_watch"];
     const manifest_node = resolve_node(state, resolve_node_by_path(state, ["project", "manifest"]));
@@ -10676,19 +10726,26 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
     const barrels = manifestBarrels(xml);
     const annotations = manifestAnnotations(xml);
     const products = manifestProducts(xml);
-    if (products.length === 0)
-        products.push(...defaultProducts);
+    if (products.length === 0) {
+        if (defaultProducts) {
+            products.push(...defaultProducts);
+        }
+        else if (xml["iq:manifest"]["iq:barrel"]) {
+            products.push(...Object.keys(devices).sort());
+        }
+    }
     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;
         promise = promise
-            .then(() => resolve_literals(rawQualifier, manifest))
+            .then(() => resolve_literals(rawQualifier, manifest, devices[product]))
             .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)) {
@@ -10709,7 +10766,7 @@ async function get_jungle_and_barrels(jungleFiles, defaultProducts, options) {
 }
 async function get_jungle(jungles, options) {
     options = options || {};
-    const result = await get_jungle_and_barrels(jungles, [], options);
+    const result = await get_jungle_and_barrels(jungles, null, options);
     identify_optimizer_groups(result.targets, options);
     return result;
 }
@@ -10723,7 +10780,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 +10788,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 +10798,27 @@ 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 = {};
-            if (!(0,external_api_cjs_namespaceObject.hasProperty)(parent.decls, name))
-                parent.decls[name] = [];
+            const decls = parent.decls;
+            if (!(0,external_api_cjs_namespaceObject.hasProperty)(decls, name))
+                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);
+                    if (node.type == "ImportModule" && m.type_decls) {
+                        if (!parent.type_decls)
+                            parent.type_decls = {};
+                        const tdecls = parent.type_decls;
+                        Object.entries(m.type_decls).forEach(([name, decls]) => {
+                            if (!(0,external_api_cjs_namespaceObject.hasProperty)(tdecls, name))
+                                tdecls[name] = [];
+                            decls.forEach((decl) => (0,external_util_cjs_namespaceObject.pushUnique)(tdecls[name], decl));
+                        });
+                    }
                 }
             });
         }
@@ -10762,11 +10827,39 @@ function processImports(allImports, lookup) {
 function collectClassInfo(state) {
     state.allClasses.forEach((elm) => {
         if (elm.node.superClass) {
-            const [, classes] = state.lookup(elm.node.superClass, null, elm.stack);
+            const [name, classes] = state.lookup(elm.node.superClass, null, elm.stack);
             const superClass = classes &&
                 classes.filter((c) => (0,external_api_cjs_namespaceObject.isStateNode)(c) && c.type === "ClassDeclaration");
             // set it "true" if there is a superClass, but we can't find it.
             elm.superClass = superClass && superClass.length ? superClass : true;
+            if (name && elm.superClass !== true) {
+                /*
+                 * The runtime behavior of monkeyc is strange. Lookups
+                 * of the name of the superclass, either bare, or via self.<name>
+                 * always find the superclass, even if there's a member variable
+                 * or method of the same name. So its ok to just overwrite
+                 * elm.decls[name] here.
+                 *
+                 * ie
+                 *
+                 * class A { function foo() as Number { return 1; } }
+                 * class B { function foo() as String { return "B"; } }
+                 * class C extends A {
+                 *   var A as B = new B();
+                 *   function initialize() {
+                 *     A.initialize(); // class A's initialize
+                 *     A.foo(); // returns 1
+                 *     self.A.foo(); // still returns 1
+                 *   }
+                 * }
+                 *
+                 * The typechecker seems to get confused in some circumstances
+                 * though (ie it doesn't always use the same rules)
+                 */
+                if (!elm.decls)
+                    elm.decls = {};
+                elm.decls[name] = elm.superClass;
+            }
         }
     });
     const markOverrides = (cls, scls) => {
@@ -10824,7 +10917,7 @@ async function analyze(fnMap) {
     let excludeAnnotations;
     let hasTests = false;
     const allImports = [];
-    const state = {
+    const preState = {
         allFunctions: [],
         allClasses: [],
         shouldExclude(node) {
@@ -10846,9 +10939,9 @@ async function analyze(fnMap) {
                     return drop;
                 }, false);
             }
-            return null;
+            return false;
         },
-        post(node) {
+        post(node, state) {
             switch (node.type) {
                 case "FunctionDeclaration":
                 case "ClassDeclaration": {
@@ -10867,10 +10960,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 +10975,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 +11029,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 +11069,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 +11196,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 +11218,7 @@ function evaluateFunction(func, args) {
                         throw new Error("Didn't optimize");
                     }
                 }
-            }));
+            });
         return ret;
     }
     catch (e) {
@@ -11127,7 +11226,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 +11260,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).
@@ -11188,22 +11293,21 @@ async function optimizeMonkeyC(fnMap) {
      * anywhere in its superClass chain.
      */
     const checkInherited = (elm, name) => elm.superClass === true ||
-        elm.superClass.some((sc) => ((0,external_api_cjs_namespaceObject.hasProperty)(sc.decls, name) &&
-            sc.decls[name].some((f) => (0,external_api_cjs_namespaceObject.isStateNode)(f) &&
-                f.type == "FunctionDeclaration" &&
-                maybeCalled(f.node))) ||
-            (sc.superClass && checkInherited(sc, name)));
-    state.localsStack = [{}];
-    state.exposed = {};
-    state.calledFunctions = {};
+        (elm.superClass != null &&
+            elm.superClass.some((sc) => ((0,external_api_cjs_namespaceObject.hasProperty)(sc.decls, name) &&
+                sc.decls[name].some((f) => (0,external_api_cjs_namespaceObject.isStateNode)(f) &&
+                    f.type == "FunctionDeclaration" &&
+                    maybeCalled(f.node))) ||
+                (sc.superClass && checkInherited(sc, name))));
     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 +11319,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 +11339,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 +11364,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 +11388,8 @@ async function optimizeMonkeyC(fnMap) {
                                             break;
                                         }
                                     }
-                                    else if (elm.node.type === "FunctionDeclaration") {
+                                    else if (elm.node &&
+                                        elm.node.type === "FunctionDeclaration") {
                                         ok = true;
                                     }
                                 }
@@ -11331,7 +11428,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 +11459,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 +11494,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 +11505,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 +11543,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)) {
@@ -11466,71 +11567,77 @@ async function optimizeMonkeyC(fnMap) {
     Object.values(fnMap).forEach((f) => {
         (0,external_api_cjs_namespaceObject.collectNamespaces)(f.ast, state);
     });
-    Object.values(fnMap).forEach((f) => {
-        (0,external_api_cjs_namespaceObject.traverseAst)(f.ast, null, (node) => {
-            switch (node.type) {
-                case "EnumStringBody":
-                    if (node.members.every((m) => {
-                        const name = "name" in m ? m.name : m.id.name;
-                        return ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) &&
-                            !(0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name));
-                    })) {
-                        node.enumType = [
-                            ...new Set(node.members.map((m) => {
-                                if (!("init" in m))
-                                    return "Number";
-                                const [node, type] = getNodeValue(m.init);
-                                if (!node) {
-                                    throw new Error("Failed to get type for eliminated enum");
-                                }
-                                return type;
-                            })),
-                        ].join(" or ");
-                        node.members.splice(0);
-                    }
-                    break;
-                case "EnumDeclaration":
-                    if (!node.body.members.length) {
-                        if (!node.id)
-                            return false;
-                        if (!node.body["enumType"]) {
-                            throw new Error("Missing enumType on optimized enum");
-                        }
-                        replace(node, {
-                            type: "TypedefDeclaration",
-                            id: node.id,
-                            ts: {
-                                type: "UnaryExpression",
-                                argument: { type: "TypeSpecList", ts: [node.body.enumType] },
-                                prefix: true,
-                                operator: " as",
-                            },
-                        });
-                    }
-                    break;
-                case "VariableDeclaration": {
-                    node.declarations = node.declarations.filter((d) => {
-                        const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(d.id);
-                        return (!(0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) ||
-                            (0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name));
-                    });
-                    if (!node.declarations.length) {
-                        return false;
-                    }
-                    break;
+    const cleanup = (node) => {
+        switch (node.type) {
+            case "EnumStringBody":
+                if (node.members.every((m) => {
+                    const name = "name" in m ? m.name : m.id.name;
+                    return ((0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) &&
+                        !(0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name));
+                })) {
+                    node.enumType = [
+                        ...new Set(node.members.map((m) => {
+                            if (!("init" in m))
+                                return "Number";
+                            const [node, type] = getNodeValue(m.init);
+                            if (!node) {
+                                throw new Error("Failed to get type for eliminated enum");
+                            }
+                            return type;
+                        })),
+                    ].join(" or ");
+                    node.members.splice(0);
                 }
-                case "ClassElement":
-                    if (!node.item) {
-                        return false;
-                    }
-                    break;
-                case "FunctionDeclaration":
-                    if (!maybeCalled(node)) {
+                break;
+            case "EnumDeclaration":
+                if (!node.body.members.length) {
+                    if (!node.id)
                         return false;
+                    if (!node.body["enumType"]) {
+                        throw new Error("Missing enumType on optimized enum");
                     }
-                    break;
+                    replace(node, {
+                        type: "TypedefDeclaration",
+                        id: node.id,
+                        ts: {
+                            type: "UnaryExpression",
+                            argument: { type: "TypeSpecList", ts: [node.body.enumType] },
+                            prefix: true,
+                            operator: " as",
+                        },
+                    });
+                }
+                break;
+            case "VariableDeclaration": {
+                node.declarations = node.declarations.filter((d) => {
+                    const name = (0,external_api_cjs_namespaceObject.variableDeclarationName)(d.id);
+                    return (!(0,external_api_cjs_namespaceObject.hasProperty)(state.index, name) || (0,external_api_cjs_namespaceObject.hasProperty)(state.exposed, name));
+                });
+                if (!node.declarations.length) {
+                    return false;
+                }
+                break;
             }
-            return null;
+            case "ClassElement":
+                if (!node.item) {
+                    return false;
+                }
+                break;
+            case "FunctionDeclaration":
+                if (!maybeCalled(node)) {
+                    return false;
+                }
+                break;
+        }
+        return null;
+    };
+    Object.values(fnMap).forEach((f) => {
+        (0,external_api_cjs_namespaceObject.traverseAst)(f.ast, undefined, (node) => {
+            const ret = cleanup(node);
+            if (ret === false) {
+                state.removeNodeComments(node, f.ast);
+            }
+            return ret;
         });
     });
 }
@@ -11565,6 +11672,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 +11731,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 +11764,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 +11772,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 +11783,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 +11802,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 +11836,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 +11873,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 +11885,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 +11899,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 +11908,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 +11942,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 +11954,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 +11988,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 +12023,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 +12031,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 +12044,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 +12064,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 && 1653954367574 < opt_time) {
             return hasTests;
         }
     }
@@ -11946,14 +12073,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 +12090,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 +12121,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) {