pxt-core 12.3.20 → 12.3.21

package/built/cli.js

@@ -215,8 +215,8 @@ class FileGithubDb {
     loadConfigAsync(repopath, tag) {
         return this.loadAsync(repopath, tag, "pxt", (r, t) => this.db.loadConfigAsync(r, t));
     }
-    loadPackageAsync(repopath, tag) {
-        return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t));
+    loadPackageAsync(repopath, tag, fallbackPackageFiles) {
+        return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t, fallbackPackageFiles));
     }
     loadTutorialMarkdown(repopath, tag) {
         return this.loadAsync(repopath, tag, "tutorial", (r, t) => this.db.loadTutorialMarkdown(r, t));

package/built/pxt.js

@@ -101957,6 +101957,8 @@ var pxt;
     pxt.TUTORIAL_CODE_STOP = "_onCodeStop.ts";
     pxt.TUTORIAL_INFO_FILE = "tutorial-info-cache.json";
     pxt.TUTORIAL_CUSTOM_TS = "tutorial.custom.ts";
+    pxt.PACKAGED_EXTENSIONS = "_packaged-extensions.json";
+    pxt.PACKAGED_EXT_INFO = "_packaged-ext-info.json";
     pxt.BREAKPOINT_TABLET = 991; // TODO (shakao) revisit when tutorial stuff is more settled
     pxt.PALETTES_FILE = "_palettes.json";
     pxt.HISTORY_FILE = "_history";
@@ -102003,6 +102005,30 @@ var pxt;
         };
         // Like MATH_FUNCTIONS, but used only for rounding operations
         blocks.ROUNDING_FUNCTIONS = ["round", "ceil", "floor", "trunc"];
+        function parameterDefaultLocalizationKey(qName, actualName) {
+            return qName ? `${qName}|param|${actualName}|defl` : undefined;
+        }
+        blocks.parameterDefaultLocalizationKey = parameterDefaultLocalizationKey;
+        function parameterDefaultToLocalizationString(defaultValue, type) {
+            if (!defaultValue)
+                return undefined;
+            if (type === "string" && defaultValue.charAt(0) !== "\"")
+                return defaultValue;
+            if (defaultValue.charAt(0) !== "\"")
+                return undefined;
+            try {
+                const value = JSON.parse(defaultValue);
+                return typeof value === "string" ? value : undefined;
+            }
+            catch (e) {
+                return undefined;
+            }
+        }
+        blocks.parameterDefaultToLocalizationString = parameterDefaultToLocalizationString;
+        function localizationStringToParameterDefault(value) {
+            return JSON.stringify(value);
+        }
+        blocks.localizationStringToParameterDefault = localizationStringToParameterDefault;
         // Information for blocks that compile to function calls but are defined by vanilla Blockly
         // and not dynamically by BlocklyLoader
         blocks.builtinFunctionInfo = {
@@ -105784,6 +105810,19 @@ int main() {
             });
         }
         hexloader.recordGetAsync = recordGetAsync;
+        function stringifyHexInfoForCache(hexInfo) {
+            if (!(hexInfo === null || hexInfo === void 0 ? void 0 : hexInfo.hex))
+                return undefined;
+            const cachedMeta = Object.assign(Object.assign({}, hexInfo), { hex: compressHex(hexInfo.hex) });
+            return JSON.stringify(cachedMeta);
+        }
+        hexloader.stringifyHexInfoForCache = stringifyHexInfoForCache;
+        function storeHexInfoCacheEntryAsync(host, sha, cachedHexInfo) {
+            if (!sha || !cachedHexInfo)
+                return Promise.resolve();
+            return storeWithLimitAsync(host, "hex-keys", "hex-" + sha, cachedHexInfo);
+        }
+        hexloader.storeHexInfoCacheEntryAsync = storeHexInfoCacheEntryAsync;
         function getHexInfoAsync(host, extInfo, cloudModule) {
             if (!extInfo.sha)
                 return Promise.resolve(null);
@@ -105812,10 +105851,7 @@ int main() {
                 else {
                     return downloadHexInfoAsync(extInfo)
                         .then(meta => {
-                        let origHex = meta.hex;
-                        meta.hex = compressHex(meta.hex);
-                        let store = JSON.stringify(meta);
-                        meta.hex = origHex;
+                        let store = stringifyHexInfoForCache(meta);
                         return storeWithLimitAsync(host, "hex-keys", key, store)
                             .then(() => meta);
                     }).catch(e => {
@@ -108407,6 +108443,18 @@ var pxt;
         }
         github.shouldUseProxyForRepo = shouldUseProxyForRepo;
         const isPrivateRepoCache = {};
+        function copyCachedPackage(cachedPackage) {
+            return {
+                files: Object.assign({}, cachedPackage.files)
+            };
+        }
+        function cachedPackageFromFallback(fallbackPackageFiles) {
+            if (!fallbackPackageFiles)
+                return undefined;
+            return {
+                files: Object.assign({}, fallbackPackageFiles)
+            };
+        }
         function ghRequestAsync(options) {
             var _a;
             options.method = (_a = options.method) !== null && _a !== void 0 ? _a : "GET";
@@ -108518,7 +108566,7 @@ var pxt;
                 }
                 return resolved;
             }
-            async loadPackageAsync(repopath, tag) {
+            async loadPackageAsync(repopath, tag, fallbackPackageFiles) {
                 if (!tag) {
                     pxt.debug(`load pkg: default to master branch`);
                     tag = "master";
@@ -108526,45 +108574,46 @@ var pxt;
                 // try using github proxy first
                 if (hasProxy()) {
                     try {
-                        return await this.proxyWithCdnLoadPackageAsync(repopath, tag).then(v => pxt.U.clone(v));
+                        return await this.proxyWithCdnLoadPackageAsync(repopath, tag).then(copyCachedPackage);
                     }
                     catch (e) {
                         ghProxyHandleException(e);
                     }
                 }
                 // try using github apis
-                return await this.githubLoadPackageAsync(repopath, tag);
+                return await this.githubLoadPackageAsync(repopath, tag, fallbackPackageFiles);
             }
-            githubLoadPackageAsync(repopath, tag) {
-                return tagToShaAsync(repopath, tag)
-                    .then(sha => {
+            async githubLoadPackageAsync(repopath, tag, fallbackPackageFiles) {
+                try {
+                    const sha = await tagToShaAsync(repopath, tag);
                     // cache lookup
                     const key = `${repopath}/${sha}`;
                     let res = this.packages[key];
                     if (res) {
                         pxt.debug(`github cache ${repopath}/${tag}/text`);
-                        return Promise.resolve(pxt.U.clone(res));
+                        return copyCachedPackage(res);
                     }
                     // load and cache
                     pxt.log(`Downloading ${repopath}/${tag} -> ${sha}`);
-                    return downloadTextAsync(repopath, sha, pxt.CONFIG_NAME)
-                        .then(pkg => {
-                        const current = {
-                            files: {}
-                        };
-                        current.files[pxt.CONFIG_NAME] = pkg;
-                        const cfg = JSON.parse(pkg);
-                        return pxt.U.promiseMapAll(pxt.allPkgFiles(cfg).slice(1), fn => downloadTextAsync(repopath, sha, fn)
-                            .then(text => {
-                            current.files[fn] = text;
-                        }))
-                            .then(() => {
-                            // cache!
-                            this.packages[key] = current;
-                            return pxt.U.clone(current);
-                        });
+                    const pkg = await downloadTextAsync(repopath, sha, pxt.CONFIG_NAME);
+                    const current = {
+                        files: {}
+                    };
+                    current.files[pxt.CONFIG_NAME] = pkg;
+                    const cfg = JSON.parse(pkg);
+                    await pxt.U.promiseMapAll(pxt.allPkgFiles(cfg).slice(1), async (fn) => {
+                        current.files[fn] = await downloadTextAsync(repopath, sha, fn);
                     });
-                });
+                    // cache!
+                    this.packages[key] = current;
+                    return copyCachedPackage(current);
+                }
+                catch (e) {
+                    const fallbackPackage = cachedPackageFromFallback(fallbackPackageFiles);
+                    if (fallbackPackage)
+                        return fallbackPackage;
+                    throw e;
+                }
             }
             async loadTutorialMarkdown(repopath, tag) {
                 repopath = normalizeTutorialPath(repopath);
@@ -108920,7 +108969,7 @@ var pxt;
             return await github.db.loadConfigAsync(repopath, tag);
         }
         github.pkgConfigAsync = pkgConfigAsync;
-        async function downloadPackageAsync(repoWithTag, config) {
+        async function downloadPackageAsync(repoWithTag, config, fallbackPackageFiles) {
             const p = parseRepoId(repoWithTag);
             if (!p) {
                 pxt.log('Unknown GitHub syntax');
@@ -108933,9 +108982,17 @@ var pxt;
             }
             // always try to upgrade unbound versions
             if (!p.tag) {
-                p.tag = await github.db.latestVersionAsync(p.slug, config);
+                try {
+                    p.tag = await github.db.latestVersionAsync(p.slug, config);
+                }
+                catch (e) {
+                    const fallbackPackage = cachedPackageFromFallback(fallbackPackageFiles);
+                    if (fallbackPackage)
+                        return fallbackPackage;
+                    throw e;
+                }
             }
-            const cached = await github.db.loadPackageAsync(p.fullName, p.tag);
+            const cached = await github.db.loadPackageAsync(p.fullName, p.tag, fallbackPackageFiles);
             const dv = upgradedDisablesVariants(config, repoWithTag);
             if (dv) {
                 const cfg = pxt.Package.parseAndValidConfig(cached.files[pxt.CONFIG_NAME]);
@@ -108960,7 +109017,11 @@ var pxt;
             return { version, config };
         }
         github.downloadLatestPackageAsync = downloadLatestPackageAsync;
-        async function cacheProjectDependenciesAsync(cfg) {
+        async function cacheProjectDependenciesAsync(cfg, fallbackPackageFilesById) {
+            await cacheProjectDependenciesCoreAsync(cfg, {}, fallbackPackageFilesById);
+        }
+        github.cacheProjectDependenciesAsync = cacheProjectDependenciesAsync;
+        async function cacheProjectDependenciesCoreAsync(cfg, checked, fallbackPackageFilesById) {
             var _a;
             const ghExtensions = (_a = Object.keys(cfg.dependencies)) === null || _a === void 0 ? void 0 : _a.filter(dep => isGithubId(cfg.dependencies[dep]));
             if (ghExtensions.length) {
@@ -108968,14 +109029,19 @@ var pxt;
                 // Make sure external packages load before installing header.
                 await Promise.all(ghExtensions.map(async (ext) => {
                     const extSrc = cfg.dependencies[ext];
-                    const ghPkg = await downloadPackageAsync(extSrc, pkgConfig);
+                    if (checked[extSrc])
+                        return;
+                    checked[extSrc] = true;
+                    const ghPkg = await downloadPackageAsync(extSrc, pkgConfig, fallbackPackageFilesById === null || fallbackPackageFilesById === void 0 ? void 0 : fallbackPackageFilesById[extSrc]);
                     if (!ghPkg) {
                         throw new Error(lf("Cannot load extension {0} from {1}", ext, extSrc));
                     }
+                    const ghPkgCfg = pxt.Package.parseAndValidConfig(ghPkg.files[pxt.CONFIG_NAME]);
+                    if (ghPkgCfg)
+                        await cacheProjectDependenciesCoreAsync(ghPkgCfg, checked, fallbackPackageFilesById);
                 }));
             }
         }
-        github.cacheProjectDependenciesAsync = cacheProjectDependenciesAsync;
         let GitRepoStatus;
         (function (GitRepoStatus) {
             GitRepoStatus[GitRepoStatus["Unknown"] = 0] = "Unknown";
@@ -115025,7 +115091,10 @@ var pxt;
                 this.config.binaryonly ||
                 !opts.target.isNative;
             if (!noFileEmbed) {
-                const files = await this.filesToBePublishedAsync(true);
+                const files = await this.filesToBePublishedAsync(true, !pxt.appTarget.compile.useUF2);
+                const packagedExtInfo = this.packagedExtensionHexInfo(opts);
+                if (Object.keys(packagedExtInfo).length)
+                    files[pxt.PACKAGED_EXT_INFO] = JSON.stringify(packagedExtInfo);
                 const headerString = JSON.stringify({
                     name: this.config.name,
                     comment: this.config.description,
@@ -115097,25 +115166,75 @@ var pxt;
             cfg.files = cfg.files.filter(fn => fn !== pxt.HISTORY_FILE);
             return cfg;
         }
-        filesToBePublishedAsync(allowPrivate = false) {
+        async filesToBePublishedAsync(allowPrivate = false, packExternalExtensions = false) {
             const files = {};
-            return this.loadAsync()
-                .then(() => {
-                if (!allowPrivate && !this.config.public)
-                    pxt.U.userError('Only packages with "public":true can be published');
-                const cfg = this.prepareConfigToBePublished();
-                files[pxt.CONFIG_NAME] = pxt.Package.stringifyConfig(cfg);
-                for (let f of this.getFiles()) {
-                    // already stored
-                    if (f === pxt.CONFIG_NAME || f === pxt.HISTORY_FILE)
+            await this.loadAsync();
+            if (!allowPrivate && !this.config.public)
+                pxt.U.userError('Only packages with "public":true can be published');
+            const cfg = this.prepareConfigToBePublished();
+            files[pxt.CONFIG_NAME] = pxt.Package.stringifyConfig(cfg);
+            for (let f of this.getFiles()) {
+                // already stored
+                if (f === pxt.CONFIG_NAME || f === pxt.HISTORY_FILE)
+                    continue;
+                let str = this.readFile(f);
+                if (str == null)
+                    pxt.U.userError("referenced file missing: " + f);
+                files[f] = str;
+            }
+            if (packExternalExtensions) {
+                const packagedExtensions = this.packagedExternalExtensions();
+                if (Object.keys(packagedExtensions).length)
+                    files[pxt.PACKAGED_EXTENSIONS] = JSON.stringify(packagedExtensions);
+            }
+            return pxt.U.sortObjectFields(files);
+        }
+        packagedExternalExtensions() {
+            const packaged = {};
+            const seen = {};
+            const packDeps = (pkg) => {
+                for (const dep of pkg.resolvedDependencies()) {
+                    if (!dep)
                         continue;
-                    let str = this.readFile(f);
-                    if (str == null)
-                        pxt.U.userError("referenced file missing: " + f);
-                    files[f] = str;
+                    const seenKey = `${dep.id}:${dep.version()}`;
+                    if (seen[seenKey])
+                        continue;
+                    seen[seenKey] = true;
+                    if (dep.verProtocol() === "github" || dep.verProtocol() === "pub") {
+                        const depFiles = {};
+                        for (const fn of dep.getFiles()) {
+                            if (fn === pxt.CONFIG_NAME || fn === pxt.HISTORY_FILE)
+                                continue;
+                            const content = dep.readFile(fn);
+                            if (content != null)
+                                depFiles[fn] = content;
+                        }
+                        depFiles[pxt.CONFIG_NAME] = pxt.Package.stringifyConfig(dep.config);
+                        packaged[dep._verspec] = depFiles;
+                        if (dep.version() !== dep._verspec)
+                            packaged[dep.version()] = depFiles;
+                        if (dep.verProtocol() === "pub")
+                            packaged[dep.verArgument()] = depFiles;
+                    }
+                    packDeps(dep);
                 }
-                return pxt.U.sortObjectFields(files);
-            });
+            };
+            packDeps(this);
+            return packaged;
+        }
+        packagedExtensionHexInfo(opts) {
+            var _a;
+            const packaged = {};
+            const targets = [opts, ...(opts.otherMultiVariants || [])];
+            for (const target of targets) {
+                const extInfo = target.extinfo;
+                if (!(extInfo === null || extInfo === void 0 ? void 0 : extInfo.sha) || !((_a = extInfo.hexinfo) === null || _a === void 0 ? void 0 : _a.hex))
+                    continue;
+                const serialized = pxt.hexloader.stringifyHexInfoForCache(extInfo.hexinfo);
+                if (serialized)
+                    packaged[extInfo.sha] = serialized;
+            }
+            return packaged;
         }
         saveToJsonAsync() {
             return this.filesToBePublishedAsync(true)
@@ -116072,6 +116191,10 @@ var ts;
                     fn.attributes.jsDoc = fn.attributes._untranslatedJsDoc;
                 if (fn.attributes._untranslatedBlock)
                     fn.attributes.jsDoc = fn.attributes._untranslatedBlock;
+                if (fn.attributes._untranslatedParamDefl) {
+                    fn.attributes.paramDefl = pxtc.U.clone(fn.attributes._untranslatedParamDefl);
+                    syncParameterDefaults(fn);
+                }
                 const lookupLoc = (locSuff, attrKey) => {
                     var _a, _b;
                     return loc[fn.qName + locSuff] || ((_a = fn.attributes.locs) === null || _a === void 0 ? void 0 : _a[attrKey])
@@ -116107,15 +116230,30 @@ var ts;
                     }
                     const paramsWithLabels = comp.thisParameter ? [comp.thisParameter, ...comp.parameters] : comp.parameters;
                     for (const param of paramsWithLabels) {
-                        if (!param.labelLocalizationKey)
-                            continue;
-                        const locSuff = param.labelLocalizationKey.slice(fn.qName.length);
-                        const paramLabel = lookupLoc(locSuff, langLower + locSuff);
-                        if (paramLabel) {
-                            setBlockTranslationCacheKey(param.labelLocalizationKey, paramLabel);
+                        if (param.labelLocalizationKey) {
+                            const locSuff = param.labelLocalizationKey.slice(fn.qName.length);
+                            const paramLabel = lookupLoc(locSuff, langLower + locSuff);
+                            if (paramLabel) {
+                                setBlockTranslationCacheKey(param.labelLocalizationKey, paramLabel);
+                            }
+                            else {
+                                clearBlockTranslationCacheKey(param.labelLocalizationKey);
+                            }
                         }
-                        else {
-                            clearBlockTranslationCacheKey(param.labelLocalizationKey);
+                        const defaultString = pxt.blocks.parameterDefaultToLocalizationString(param.defaultValue, param.type);
+                        const defaultLocalizationKey = pxt.blocks.parameterDefaultLocalizationKey(fn.qName, param.actualName);
+                        if (defaultLocalizationKey && defaultString !== undefined) {
+                            const locSuff = defaultLocalizationKey.slice(fn.qName.length);
+                            const paramDefault = lookupLoc(locSuff, langLower + locSuff);
+                            if (paramDefault !== undefined) {
+                                if (!fn.attributes._untranslatedParamDefl) {
+                                    fn.attributes._untranslatedParamDefl = pxtc.U.clone(fn.attributes.paramDefl || {});
+                                }
+                                if (!fn.attributes.paramDefl)
+                                    fn.attributes.paramDefl = {};
+                                fn.attributes.paramDefl[param.actualName] = pxt.blocks.localizationStringToParameterDefault(paramDefault);
+                                syncParameterDefaults(fn);
+                            }
                         }
                     }
                 }
@@ -116182,6 +116320,13 @@ var ts;
             return cleanLocalizations(apis);
         }
         pxtc.localizeApisAsync = localizeApisAsync;
+        function syncParameterDefaults(fn) {
+            if (!fn.parameters)
+                return;
+            for (const param of fn.parameters) {
+                param.default = fn.attributes.paramDefl && fn.attributes.paramDefl[param.name];
+            }
+        }
         function cleanLocalizations(apis) {
             pxtc.Util.values(apis.byQName)
                 .filter(fb => fb.attributes.block && /^{[^:]+:[^}]+}/.test(fb.attributes.block))
@@ -124727,8 +124872,8 @@ var pxt;
         loadConfigAsync(repopath, tag) {
             return this.loadAsync(repopath, tag, "pxt", (r, t) => this.db.loadConfigAsync(r, t));
         }
-        loadPackageAsync(repopath, tag) {
-            return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t));
+        loadPackageAsync(repopath, tag, fallbackPackageFiles) {
+            return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t, fallbackPackageFiles));
         }
         loadTutorialMarkdown(repopath, tag) {
             return this.loadAsync(repopath, tag, "tutorial", (r, t) => this.db.loadTutorialMarkdown(r, t));
@@ -142580,6 +142725,11 @@ var ts;
                         if (param.labelLocalizationKey && param.label) {
                             locStrings[param.labelLocalizationKey] = param.label;
                         }
+                        const defaultString = pxt.blocks.parameterDefaultToLocalizationString(param.defaultValue, param.type);
+                        const defaultLocalizationKey = pxt.blocks.parameterDefaultLocalizationKey(si.qName, param.actualName);
+                        if (defaultLocalizationKey && defaultString !== undefined) {
+                            locStrings[defaultLocalizationKey] = defaultString;
+                        }
                     }
                     if ((_a = comp.handlerArgs) === null || _a === void 0 ? void 0 : _a.length) {
                         for (const arg of comp.handlerArgs) {
@@ -164195,8 +164345,8 @@ class FileGithubDb {
     loadConfigAsync(repopath, tag) {
         return this.loadAsync(repopath, tag, "pxt", (r, t) => this.db.loadConfigAsync(r, t));
     }
-    loadPackageAsync(repopath, tag) {
-        return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t));
+    loadPackageAsync(repopath, tag, fallbackPackageFiles) {
+        return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t, fallbackPackageFiles));
     }
     loadTutorialMarkdown(repopath, tag) {
         return this.loadAsync(repopath, tag, "tutorial", (r, t) => this.db.loadTutorialMarkdown(r, t));

package/built/pxtcompiler.js

@@ -38,8 +38,8 @@ var pxt;
         loadConfigAsync(repopath, tag) {
             return this.loadAsync(repopath, tag, "pxt", (r, t) => this.db.loadConfigAsync(r, t));
         }
-        loadPackageAsync(repopath, tag) {
-            return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t));
+        loadPackageAsync(repopath, tag, fallbackPackageFiles) {
+            return this.loadAsync(repopath, tag, "pkg", (r, t) => this.db.loadPackageAsync(r, t, fallbackPackageFiles));
         }
         loadTutorialMarkdown(repopath, tag) {
             return this.loadAsync(repopath, tag, "tutorial", (r, t) => this.db.loadTutorialMarkdown(r, t));
@@ -17891,6 +17891,11 @@ var ts;
                         if (param.labelLocalizationKey && param.label) {
                             locStrings[param.labelLocalizationKey] = param.label;
                         }
+                        const defaultString = pxt.blocks.parameterDefaultToLocalizationString(param.defaultValue, param.type);
+                        const defaultLocalizationKey = pxt.blocks.parameterDefaultLocalizationKey(si.qName, param.actualName);
+                        if (defaultLocalizationKey && defaultString !== undefined) {
+                            locStrings[defaultLocalizationKey] = defaultString;
+                        }
                     }
                     if ((_a = comp.handlerArgs) === null || _a === void 0 ? void 0 : _a.length) {
                         for (const arg of comp.handlerArgs) {

package/built/pxtlib.d.ts

@@ -733,6 +733,8 @@ declare namespace pxt {
     const TUTORIAL_CODE_STOP = "_onCodeStop.ts";
     const TUTORIAL_INFO_FILE = "tutorial-info-cache.json";
     const TUTORIAL_CUSTOM_TS = "tutorial.custom.ts";
+    const PACKAGED_EXTENSIONS = "_packaged-extensions.json";
+    const PACKAGED_EXT_INFO = "_packaged-ext-info.json";
     const BREAKPOINT_TABLET = 991;
     const PALETTES_FILE = "_palettes.json";
     const HISTORY_FILE = "_history";
@@ -786,6 +788,9 @@ declare namespace pxt.blocks {
         inBlockDef: boolean;
         localizationKey: string;
     }
+    function parameterDefaultLocalizationKey(qName: string, actualName: string): string;
+    function parameterDefaultToLocalizationString(defaultValue: string, type?: string): string;
+    function localizationStringToParameterDefault(value: string): string;
     const builtinFunctionInfo: pxt.Map<{
         params: string[];
         blockId: string;
@@ -1159,6 +1164,8 @@ declare namespace pxt.hexloader {
     let hideLoading: () => void;
     function storeWithLimitAsync(host: Host, idxkey: string, newkey: string, newval: string, maxLen?: number): Promise<void>;
     function recordGetAsync(host: Host, idxkey: string, newkey: string): Promise<void>;
+    function stringifyHexInfoForCache(hexInfo: pxtc.HexInfo): string;
+    function storeHexInfoCacheEntryAsync(host: Host, sha: string, cachedHexInfo: string): Promise<void>;
     function getHexInfoAsync(host: Host, extInfo: pxtc.ExtensionInfo, cloudModule?: any): Promise<pxtc.HexInfo>;
 }
 declare namespace pxt.crowdin {
@@ -1467,7 +1474,7 @@ declare namespace pxt.github {
     interface IGithubDb {
         latestVersionAsync(repopath: string, config: PackagesConfig): Promise<string>;
         loadConfigAsync(repopath: string, tag: string): Promise<pxt.PackageConfig>;
-        loadPackageAsync(repopath: string, tag: string): Promise<CachedPackage>;
+        loadPackageAsync(repopath: string, tag: string, fallbackPackageFiles?: pxt.Map<string>): Promise<CachedPackage>;
         loadTutorialMarkdown(repopath: string, tag?: string): Promise<CachedPackage>;
         cacheReposAsync(response: GHTutorialResponse): Promise<void>;
     }
@@ -1480,7 +1487,7 @@ declare namespace pxt.github {
         private cacheConfig;
         loadConfigAsync(repopath: string, tag: string): Promise<pxt.PackageConfig>;
         latestVersionAsync(repopath: string, config: PackagesConfig): Promise<string>;
-        loadPackageAsync(repopath: string, tag: string): Promise<CachedPackage>;
+        loadPackageAsync(repopath: string, tag: string, fallbackPackageFiles?: pxt.Map<string>): Promise<CachedPackage>;
         private githubLoadPackageAsync;
         loadTutorialMarkdown(repopath: string, tag?: string): Promise<GHTutorialRepoInfo>;
         cacheReposAsync(resp: GHTutorialResponse): Promise<void>;
@@ -1525,12 +1532,12 @@ declare namespace pxt.github {
     function listRefsAsync(repopath: string, namespace?: string, useProxy?: boolean, noCache?: boolean): Promise<string[]>;
     function listRefsExtAsync(repopath: string, namespace?: string, useProxy?: boolean, noCache?: boolean): Promise<RefsResult>;
     function pkgConfigAsync(repopath: string, tag: string, config: pxt.PackagesConfig): Promise<PackageConfig>;
-    function downloadPackageAsync(repoWithTag: string, config: pxt.PackagesConfig): Promise<CachedPackage>;
+    function downloadPackageAsync(repoWithTag: string, config: pxt.PackagesConfig, fallbackPackageFiles?: pxt.Map<string>): Promise<CachedPackage>;
     function downloadLatestPackageAsync(repo: ParsedRepo, useProxy?: boolean, noCache?: boolean): Promise<{
         version: string;
         config: pxt.PackageConfig;
     }>;
-    function cacheProjectDependenciesAsync(cfg: pxt.PackageConfig): Promise<void>;
+    function cacheProjectDependenciesAsync(cfg: pxt.PackageConfig, fallbackPackageFilesById?: pxt.Map<pxt.Map<string>>): Promise<void>;
     interface User {
         login: string;
         id: number;
@@ -2159,7 +2166,9 @@ declare namespace pxt {
         resolveBannedCategories(): string[];
         getCompileOptionsAsync(target?: pxtc.CompileTarget): Promise<pxtc.CompileOptions>;
         private prepareConfigToBePublished;
-        filesToBePublishedAsync(allowPrivate?: boolean): Promise<Map<string>>;
+        filesToBePublishedAsync(allowPrivate?: boolean, packExternalExtensions?: boolean): Promise<Map<string>>;
+        private packagedExternalExtensions;
+        private packagedExtensionHexInfo;
         saveToJsonAsync(): Promise<pxt.cpp.HexFile>;
         compressToFileAsync(): Promise<Uint8Array>;
         computePartDefinitions(parts: string[]): pxt.Map<pxsim.PartDefinition>;