pxt-core 13.2.9 → 13.2.10

package/built/pxt.js

@@ -108589,6 +108589,58 @@ var pxt;
             pxt.log(`github proxy error: ${e.message}`);
             pxt.debug(e);
         }
+        // lowercase "owner/repo" of the repositories the local server resolves from disk
+        let localRepos = {};
+        /**
+         * Asks the local development server (pxt serve) which GitHub repositories it
+         * resolves from local directories. Requests for those repositories then go to
+         * the local server, which serves the repository's working tree for any ref,
+         * and are never cached. Does nothing unless the editor runs on localhost; a
+         * server that refuses the request (no local token, or not pxt serve) leaves
+         * no repositories resolved locally.
+         */
+        async function initLocalReposAsync() {
+            localRepos = {};
+            if (pxt.U.isNodeJS || !pxt.BrowserUtils.isLocalHost())
+                return;
+            try {
+                const resp = await pxt.Cloud.localRequestAsync("localrepos");
+                if (resp.statusCode != 200)
+                    return;
+                const repos = resp.json.repos || [];
+                repos.forEach(slug => localRepos[slug.toLowerCase()] = true);
+                if (repos.length)
+                    pxt.log(`github: serving ${repos.join(", ")} from the local server`);
+            }
+            catch (e) {
+                pxt.log(`github: cannot list local repositories: ${e.message}`);
+            }
+        }
+        github.initLocalReposAsync = initLocalReposAsync;
+        /**
+         * Indicates if the repository of a GitHub id is resolved by the local
+         * development server. See initLocalReposAsync.
+         */
+        function isLocalRepo(repo) {
+            const parsed = typeof repo == "string" ? parseRepoId(repo) : repo;
+            return !!parsed && !!localRepos[parsed.slug.toLowerCase()];
+        }
+        github.isLocalRepo = isLocalRepo;
+        function localRepoJsonAsync(path) {
+            return pxt.Cloud.localRequestAsync("gh/" + path)
+                .then(resp => {
+                if (resp.statusCode != 200) {
+                    const err = new Error(resp.text || lf("Cannot load {0} from the local server", path));
+                    err.statusCode = resp.statusCode;
+                    throw err;
+                }
+                return resp.json;
+            });
+        }
+        function localPackageAsync(repo) {
+            return localRepoJsonAsync(join(repo.slug, repo.fileName, "text"))
+                .then(files => ({ files }));
+        }
         function isOrgAsync(owner) {
             return ghRequestAsync({ url: `https://api.github.com/orgs/${owner}`, method: "GET", allowHttpErrors: true })
                 .then(resp => resp.statusCode == 200);
@@ -109057,17 +109109,20 @@ var pxt;
             const parsed = parseRepoId(repopath);
             const proxy = shouldUseProxy(useProxy);
             let head = null;
-            const fetch = !proxy ?
-                ghGetJsonAsync(`https://api.github.com/repos/${parsed.slug}/git/refs/${namespace}/?per_page=100`) :
-                // no CDN caching here, bust browser cace
-                pxt.U.httpGetJsonAsync(pxt.BrowserUtils.cacheBustingUrl(`${pxt.Cloud.apiRoot}gh/${parsed.slug}/refs${noCache ? "?nocache=1" : ""}`))
-                    .then(r => {
-                    let res = Object.keys(r.refs)
-                        .filter(k => pxt.U.startsWith(k, "refs/" + namespace + "/"))
-                        .map(k => ({ ref: k, object: { sha: r.refs[k] } }));
-                    head = r.refs["HEAD"];
-                    return res;
-                });
+            const fetch = isLocalRepo(parsed) ?
+                localRepoJsonAsync(`${parsed.slug}/refs`)
+                    .then(r => Object.keys(r.refs).map(k => ({ ref: k, object: { sha: r.refs[k] } }))) :
+                !proxy ?
+                    ghGetJsonAsync(`https://api.github.com/repos/${parsed.slug}/git/refs/${namespace}/?per_page=100`) :
+                    // no CDN caching here, bust browser cace
+                    pxt.U.httpGetJsonAsync(pxt.BrowserUtils.cacheBustingUrl(`${pxt.Cloud.apiRoot}gh/${parsed.slug}/refs${noCache ? "?nocache=1" : ""}`))
+                        .then(r => {
+                        let res = Object.keys(r.refs)
+                            .filter(k => pxt.U.startsWith(k, "refs/" + namespace + "/"))
+                            .map(k => ({ ref: k, object: { sha: r.refs[k] } }));
+                        head = r.refs["HEAD"];
+                        return res;
+                    });
             let clean = (x) => x.replace(/^refs\/[^\/]+\//, "");
             return fetch.then((resp) => {
                 resp.sort((a, b) => pxt.semver.strcmp(clean(a.ref), clean(b.ref)));
@@ -109104,6 +109159,11 @@ var pxt;
                 .then(resolveRefAsync));
         }
         async function pkgConfigAsync(repopath, tag, config) {
+            const parsed = parseRepoId(repopath);
+            if (isLocalRepo(parsed)) {
+                const pkg = await localPackageAsync(parsed);
+                return pxt.Package.parseAndValidConfig(pkg.files[pxt.CONFIG_NAME]);
+            }
             if (!tag)
                 tag = await github.db.latestVersionAsync(repopath, config);
             return await github.db.loadConfigAsync(repopath, tag);
@@ -109121,7 +109181,7 @@ var pxt;
                 return undefined;
             }
             // always try to upgrade unbound versions
-            if (!p.tag) {
+            if (!p.tag && !isLocalRepo(p)) {
                 try {
                     p.tag = await github.db.latestVersionAsync(p.slug, config);
                 }
@@ -109132,7 +109192,9 @@ var pxt;
                     throw e;
                 }
             }
-            const cached = await github.db.loadPackageAsync(p.fullName, p.tag, fallbackPackageFiles);
+            const cached = isLocalRepo(p)
+                ? await localPackageAsync(p)
+                : 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]);
@@ -109147,6 +109209,11 @@ var pxt;
         github.downloadPackageAsync = downloadPackageAsync;
         async function downloadLatestPackageAsync(repo, useProxy, noCache) {
             const packageConfig = await pxt.packagesConfigAsync();
+            if (isLocalRepo(repo)) {
+                // a locally resolved repository has no versions: depend on it without a ref
+                const config = await pkgConfigAsync(repo.fullName, undefined, packageConfig);
+                return { version: toGithubDependencyPath(repo.fullName), config };
+            }
             const tag = await pxt.github.latestVersionAsync(repo.slug, packageConfig, useProxy, noCache);
             // download package into cache
             const repoWithTag = `${repo.fullName}#${tag}`;
@@ -109391,7 +109458,9 @@ var pxt;
         }
         function isRepoApproved(repo, config) {
             var _a, _b;
-            if (isOrgApproved(repo, config))
+            // aliased repositories exist only in an editor on localhost that listed them from its own pxt serve,
+            // so approving them widens nothing a public editor approves
+            if (isOrgApproved(repo, config) || isLocalRepo(repo))
                 return true;
             const repoFull = (_a = repo === null || repo === void 0 ? void 0 : repo.fullName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
             const repoSlug = (_b = repo === null || repo === void 0 ? void 0 : repo.slug) === null || _b === void 0 ? void 0 : _b.toLowerCase();
@@ -109409,6 +109478,8 @@ var pxt;
             const status = repoStatus(rid, config);
             if (status == GitRepoStatus.Banned)
                 return undefined;
+            if (isLocalRepo(rid))
+                return repoFromProxyMeta(rid, status, await localRepoJsonAsync(rid.slug));
             // always try proxy first
             if (hasProxy()) {
                 try {
@@ -109423,26 +109494,28 @@ var pxt;
             return mkRepo(r, { config, fullName: rid.fullName, fileName: rid.fileName, tag: rid.tag });
         }
         github.repoAsync = repoAsync;
+        function repoFromProxyMeta(rid, status, meta) {
+            if (!meta)
+                return undefined;
+            return {
+                github: true,
+                owner: rid.owner,
+                fullName: rid.fullName,
+                fileName: rid.fileName,
+                slug: rid.slug,
+                name: rid.fileName ? `${meta.name}-${rid.fileName}` : meta.name,
+                displayName: meta.displayName,
+                description: meta.description,
+                defaultBranch: meta.defaultBranch || "master",
+                tag: rid.tag,
+                status
+            };
+        }
         function proxyRepoAsync(rid, status) {
             // always use proxy
             return ghProxyWithCdnJsonAsync(rid.slug)
-                .then(meta => {
-                if (!meta)
-                    return undefined;
-                return {
-                    github: true,
-                    owner: rid.owner,
-                    fullName: rid.fullName,
-                    fileName: rid.fileName,
-                    slug: rid.slug,
-                    name: rid.fileName ? `${meta.name}-${rid.fileName}` : meta.name,
-                    displayName: meta.displayName,
-                    description: meta.description,
-                    defaultBranch: meta.defaultBranch || "master",
-                    tag: rid.tag,
-                    status
-                };
-            }).catch(err => {
+                .then(meta => repoFromProxyMeta(rid, status, meta))
+                .catch(err => {
                 pxt.reportException(err);
                 return undefined;
             });
@@ -109624,6 +109697,9 @@ var pxt;
             const parsed = parseRepoId(repopath);
             if (!parsed)
                 return Promise.resolve(null);
+            // a locally resolved repository serves its working tree and has no versions
+            if (isLocalRepo(parsed))
+                return Promise.resolve(undefined);
             return repoAsync(parsed.slug, config)
                 .then(scr => {
                 if (!scr)
@@ -158696,7 +158772,7 @@ var pxsim;
             this.setState(SimulatorState.Pending);
         }
         focus() {
-            const frame = this.simFrames()[0];
+            const frame = this.mainFrame();
             if (frame)
                 frame.focus();
         }
@@ -158743,7 +158819,7 @@ var pxsim;
             this.themes = themes;
         }
         startRecording(width) {
-            const frame = this.simFrames()[0];
+            const frame = this.mainFrame();
             if (!frame)
                 return undefined;
             this.postMessage({
@@ -158751,7 +158827,7 @@ var pxsim;
                 action: 'start',
                 source: MESSAGE_SOURCE,
                 width
-            });
+            }, undefined, frame.id);
         }
         stopRecording() {
             this.postMessage({ type: 'recorder', source: MESSAGE_SOURCE, action: 'stop' });
@@ -158825,6 +158901,14 @@ var pxsim;
                 frames.unshift(loanedFrame);
             return frames;
         }
+        /**
+         * Returns the main simulator frame: the first frame not running a
+         * simulator extension, or undefined when there is none.
+         * @param skipLoaned excludes the loaned simulator's frame, as `simFrames` does
+         */
+        mainFrame(skipLoaned = false) {
+            return this.simFrames(skipLoaned).find(frame => !frame.dataset[FRAME_DATA_MESSAGE_CHANNEL]);
+        }
         getSimUrl() {
             var _a, _b;
             const simUrl = this.options.simUrl || ((_a = window.pxtConfig) === null || _a === void 0 ? void 0 : _a.simUrl) || ((_b = pxt.webConfig) === null || _b === void 0 ? void 0 : _b.simUrl) || `${location.origin}/sim/simulator.html`;
@@ -158857,8 +158941,8 @@ var pxsim;
                 // include index of the source iframe
                 broadcastmsg.srcFrameIndex = this.simFrames().findIndex((item) => item.contentWindow === source);
                 const sourceFrame = broadcastmsg.srcFrameIndex >= 0 ? this.simFrames()[broadcastmsg.srcFrameIndex] : undefined;
-                // jacdac messages from a board sim other than first should be dropped
-                if (broadcastmsg.srcFrameIndex > 0 && mkcdFrames.find(f => f === sourceFrame) && messageChannel === "jacdac")
+                // jacdac messages from a board sim other than the main frame should be dropped
+                if (sourceFrame !== this.mainFrame() && mkcdFrames.find(f => f === sourceFrame) && messageChannel === "jacdac")
                     return;
                 // if the editor is hosted in a multi-editor setting
                 // don't start extra frames
@@ -158967,13 +159051,14 @@ var pxsim;
             }
             // now that we have iframe starts,
             // dispatch message to other frames
+            const mainFrame = this.mainFrame();
             for (let i = 0; i < frames.length; ++i) {
                 const frame = frames[i];
                 // same frame as source
                 if (source && frame.contentWindow == source)
                     continue;
-                // if jacdac message, don't send to other (board) simulator frames
-                if (i > 0 && !frame.dataset[FRAME_DATA_MESSAGE_CHANNEL] &&
+                // if jacdac message, don't send to (board) simulator frames other than the main frame
+                if (frame !== mainFrame && !frame.dataset[FRAME_DATA_MESSAGE_CHANNEL] &&
                     msg.type === "messagepacket" && msg.channel === "jacdac")
                     continue;
                 // frame not in DOM
@@ -159078,9 +159163,10 @@ var pxsim;
                 this._currentRuntime = undefined;
                 this.container.textContent = "";
             }
-            if (!this.simFrames().length) {
-                this.container.appendChild(this.createFrame());
-                this.applyAspectRatio(aspectRatio);
+            if (!this.mainFrame()) {
+                const wrapper = this.createFrame();
+                this.container.insertBefore(wrapper, this.container.firstElementChild);
+                this.applyAspectRatioToFrame(wrapper.firstElementChild, aspectRatio);
                 this.setStarting();
             }
         }
@@ -159122,10 +159208,11 @@ var pxsim;
         // returns a simulator iframe that can be hosted anywhere in the page
         // while a loaned simulator is active, all other iframes are suspended
         loanSimulator() {
+            var _a;
             if (this.loanedSimulator)
                 return this.loanedSimulator;
             // reuse first simulator or create new one
-            this.loanedSimulator = this.container.firstElementChild || this.createFrame();
+            this.loanedSimulator = ((_a = this.mainFrame(true)) === null || _a === void 0 ? void 0 : _a.parentElement) || this.createFrame();
             if (this.loanedSimulator.parentNode)
                 this.container.removeChild(this.loanedSimulator);
             return this.loanedSimulator;
@@ -159190,8 +159277,8 @@ var pxsim;
         }
         cleanupFrames() {
             // drop unused extras frames after 5 seconds
-            const frames = this.simFrames(true);
-            frames.shift(); // drop first frame
+            const mainFrame = this.mainFrame(true);
+            const frames = this.simFrames(true).filter(frame => frame !== mainFrame);
             frames.filter(frame => !frame.dataset[PERMANENT])
                 .forEach(frame => {
                 if (this.state == SimulatorState.Stopped
@@ -159209,7 +159296,10 @@ var pxsim;
                 return;
             const frames = this.simFrames();
             frames.forEach(frame => {
-                this.options.removeElement(frame.parentElement, completeHandler);
+                if (frame.dataset[PERMANENT] && this.options.hideElement)
+                    this.options.hideElement(frame.parentElement, completeHandler);
+                else
+                    this.options.removeElement(frame.parentElement, completeHandler);
             });
             // Execute the complete handler if there are no frames in sim view
             if (frames.length == 0 && completeHandler) {
@@ -159277,10 +159367,10 @@ var pxsim;
             this.singleSimulator = false;
             this.breakpointsSet = false;
             // first frame
-            let frame = this.simFrames()[0];
+            let frame = this.mainFrame();
             if (!frame) {
                 let wrapper = this.createFrame();
-                this.container.appendChild(wrapper);
+                this.container.insertBefore(wrapper, this.container.firstElementChild);
                 frame = wrapper.firstElementChild;
             }
             this.startFrame(frame);
@@ -164910,6 +165000,7 @@ const chalk = require('chalk');
 var U = pxt.Util;
 var Cloud = pxt.Cloud;
 const server = require("./server");
+const localrepos = require("./localrepos");
 const build = require("./buildengine");
 const commandParser = require("./commandparser");
 const hid = require("./hid");
@@ -167641,6 +167732,9 @@ function serveAsync(parsed) {
         saveConfig();
     }
     let localToken = exports.globalConfig.localToken;
+    // --local-repo directories resolve against the directory serve was started from,
+    // which differs from the target root when serve moves into a target found below
+    const invocationDir = process.cwd();
     if (!fs.existsSync("pxtarget.json")) {
         //Specifically when the target is being used as a library
         let targetDepLoc = nodeutil.targetDir;
@@ -167659,6 +167753,8 @@ function serveAsync(parsed) {
             }
         }
     }
+    const targetDir = process.cwd();
+    const localRepos = localrepos.loadLocalRepos(targetDir, parsed.flags["localRepo"] || [], invocationDir);
     return (justServe ? Promise.resolve() : buildAndWatchTargetAsync(includeSourceMaps, rebundle))
         .then(() => server.serveAsync({
         autoStart: !exports.globalConfig.noAutoStart,
@@ -167672,6 +167768,7 @@ function serveAsync(parsed) {
         noauth: parsed.flags["noauth"] || false,
         backport: parsed.flags["backport"] || 0,
         https: parsed.flags["https"] || false,
+        localRepos,
     }));
 }
 exports.serveAsync = serveAsync;
@@ -171655,7 +171752,13 @@ ${pxt.crowdin.KEY_VARIABLE} - crowdin key
                 argument: "backport",
                 type: "number",
             },
-            https: { description: "use https protocol instead of http" }
+            https: { description: "use https protocol instead of http" },
+            localRepo: {
+                description: "serve a GitHub repository from a local directory, as owner/repo=dir; repeatable, and applied over the entries of pxtlocal.json",
+                aliases: ["local-repo"],
+                argument: "repo",
+                repeatable: true
+            }
         }
     }, serveAsync);
     p.defineCommand({

package/built/pxtlib.d.ts

@@ -1496,6 +1496,20 @@ declare namespace pxt.github {
         loadTutorialMarkdown(repopath: string, tag?: string): Promise<CachedPackage>;
         cacheReposAsync(response: GHTutorialResponse): Promise<void>;
     }
+    /**
+     * Asks the local development server (pxt serve) which GitHub repositories it
+     * resolves from local directories. Requests for those repositories then go to
+     * the local server, which serves the repository's working tree for any ref,
+     * and are never cached. Does nothing unless the editor runs on localhost; a
+     * server that refuses the request (no local token, or not pxt serve) leaves
+     * no repositories resolved locally.
+     */
+    function initLocalReposAsync(): Promise<void>;
+    /**
+     * Indicates if the repository of a GitHub id is resolved by the local
+     * development server. See initLocalReposAsync.
+     */
+    function isLocalRepo(repo: string | ParsedRepo): boolean;
     function isOrgAsync(owner: string): Promise<boolean>;
     class MemoryGithubDb implements IGithubDb {
         private latestVersions;

package/built/pxtlib.js

@@ -10868,6 +10868,58 @@ var pxt;
             pxt.log(`github proxy error: ${e.message}`);
             pxt.debug(e);
         }
+        // lowercase "owner/repo" of the repositories the local server resolves from disk
+        let localRepos = {};
+        /**
+         * Asks the local development server (pxt serve) which GitHub repositories it
+         * resolves from local directories. Requests for those repositories then go to
+         * the local server, which serves the repository's working tree for any ref,
+         * and are never cached. Does nothing unless the editor runs on localhost; a
+         * server that refuses the request (no local token, or not pxt serve) leaves
+         * no repositories resolved locally.
+         */
+        async function initLocalReposAsync() {
+            localRepos = {};
+            if (pxt.U.isNodeJS || !pxt.BrowserUtils.isLocalHost())
+                return;
+            try {
+                const resp = await pxt.Cloud.localRequestAsync("localrepos");
+                if (resp.statusCode != 200)
+                    return;
+                const repos = resp.json.repos || [];
+                repos.forEach(slug => localRepos[slug.toLowerCase()] = true);
+                if (repos.length)
+                    pxt.log(`github: serving ${repos.join(", ")} from the local server`);
+            }
+            catch (e) {
+                pxt.log(`github: cannot list local repositories: ${e.message}`);
+            }
+        }
+        github.initLocalReposAsync = initLocalReposAsync;
+        /**
+         * Indicates if the repository of a GitHub id is resolved by the local
+         * development server. See initLocalReposAsync.
+         */
+        function isLocalRepo(repo) {
+            const parsed = typeof repo == "string" ? parseRepoId(repo) : repo;
+            return !!parsed && !!localRepos[parsed.slug.toLowerCase()];
+        }
+        github.isLocalRepo = isLocalRepo;
+        function localRepoJsonAsync(path) {
+            return pxt.Cloud.localRequestAsync("gh/" + path)
+                .then(resp => {
+                if (resp.statusCode != 200) {
+                    const err = new Error(resp.text || lf("Cannot load {0} from the local server", path));
+                    err.statusCode = resp.statusCode;
+                    throw err;
+                }
+                return resp.json;
+            });
+        }
+        function localPackageAsync(repo) {
+            return localRepoJsonAsync(join(repo.slug, repo.fileName, "text"))
+                .then(files => ({ files }));
+        }
         function isOrgAsync(owner) {
             return ghRequestAsync({ url: `https://api.github.com/orgs/${owner}`, method: "GET", allowHttpErrors: true })
                 .then(resp => resp.statusCode == 200);
@@ -11336,17 +11388,20 @@ var pxt;
             const parsed = parseRepoId(repopath);
             const proxy = shouldUseProxy(useProxy);
             let head = null;
-            const fetch = !proxy ?
-                ghGetJsonAsync(`https://api.github.com/repos/${parsed.slug}/git/refs/${namespace}/?per_page=100`) :
-                // no CDN caching here, bust browser cace
-                pxt.U.httpGetJsonAsync(pxt.BrowserUtils.cacheBustingUrl(`${pxt.Cloud.apiRoot}gh/${parsed.slug}/refs${noCache ? "?nocache=1" : ""}`))
-                    .then(r => {
-                    let res = Object.keys(r.refs)
-                        .filter(k => pxt.U.startsWith(k, "refs/" + namespace + "/"))
-                        .map(k => ({ ref: k, object: { sha: r.refs[k] } }));
-                    head = r.refs["HEAD"];
-                    return res;
-                });
+            const fetch = isLocalRepo(parsed) ?
+                localRepoJsonAsync(`${parsed.slug}/refs`)
+                    .then(r => Object.keys(r.refs).map(k => ({ ref: k, object: { sha: r.refs[k] } }))) :
+                !proxy ?
+                    ghGetJsonAsync(`https://api.github.com/repos/${parsed.slug}/git/refs/${namespace}/?per_page=100`) :
+                    // no CDN caching here, bust browser cace
+                    pxt.U.httpGetJsonAsync(pxt.BrowserUtils.cacheBustingUrl(`${pxt.Cloud.apiRoot}gh/${parsed.slug}/refs${noCache ? "?nocache=1" : ""}`))
+                        .then(r => {
+                        let res = Object.keys(r.refs)
+                            .filter(k => pxt.U.startsWith(k, "refs/" + namespace + "/"))
+                            .map(k => ({ ref: k, object: { sha: r.refs[k] } }));
+                        head = r.refs["HEAD"];
+                        return res;
+                    });
             let clean = (x) => x.replace(/^refs\/[^\/]+\//, "");
             return fetch.then((resp) => {
                 resp.sort((a, b) => pxt.semver.strcmp(clean(a.ref), clean(b.ref)));
@@ -11383,6 +11438,11 @@ var pxt;
                 .then(resolveRefAsync));
         }
         async function pkgConfigAsync(repopath, tag, config) {
+            const parsed = parseRepoId(repopath);
+            if (isLocalRepo(parsed)) {
+                const pkg = await localPackageAsync(parsed);
+                return pxt.Package.parseAndValidConfig(pkg.files[pxt.CONFIG_NAME]);
+            }
             if (!tag)
                 tag = await github.db.latestVersionAsync(repopath, config);
             return await github.db.loadConfigAsync(repopath, tag);
@@ -11400,7 +11460,7 @@ var pxt;
                 return undefined;
             }
             // always try to upgrade unbound versions
-            if (!p.tag) {
+            if (!p.tag && !isLocalRepo(p)) {
                 try {
                     p.tag = await github.db.latestVersionAsync(p.slug, config);
                 }
@@ -11411,7 +11471,9 @@ var pxt;
                     throw e;
                 }
             }
-            const cached = await github.db.loadPackageAsync(p.fullName, p.tag, fallbackPackageFiles);
+            const cached = isLocalRepo(p)
+                ? await localPackageAsync(p)
+                : 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]);
@@ -11426,6 +11488,11 @@ var pxt;
         github.downloadPackageAsync = downloadPackageAsync;
         async function downloadLatestPackageAsync(repo, useProxy, noCache) {
             const packageConfig = await pxt.packagesConfigAsync();
+            if (isLocalRepo(repo)) {
+                // a locally resolved repository has no versions: depend on it without a ref
+                const config = await pkgConfigAsync(repo.fullName, undefined, packageConfig);
+                return { version: toGithubDependencyPath(repo.fullName), config };
+            }
             const tag = await pxt.github.latestVersionAsync(repo.slug, packageConfig, useProxy, noCache);
             // download package into cache
             const repoWithTag = `${repo.fullName}#${tag}`;
@@ -11670,7 +11737,9 @@ var pxt;
         }
         function isRepoApproved(repo, config) {
             var _a, _b;
-            if (isOrgApproved(repo, config))
+            // aliased repositories exist only in an editor on localhost that listed them from its own pxt serve,
+            // so approving them widens nothing a public editor approves
+            if (isOrgApproved(repo, config) || isLocalRepo(repo))
                 return true;
             const repoFull = (_a = repo === null || repo === void 0 ? void 0 : repo.fullName) === null || _a === void 0 ? void 0 : _a.toLowerCase();
             const repoSlug = (_b = repo === null || repo === void 0 ? void 0 : repo.slug) === null || _b === void 0 ? void 0 : _b.toLowerCase();
@@ -11688,6 +11757,8 @@ var pxt;
             const status = repoStatus(rid, config);
             if (status == GitRepoStatus.Banned)
                 return undefined;
+            if (isLocalRepo(rid))
+                return repoFromProxyMeta(rid, status, await localRepoJsonAsync(rid.slug));
             // always try proxy first
             if (hasProxy()) {
                 try {
@@ -11702,26 +11773,28 @@ var pxt;
             return mkRepo(r, { config, fullName: rid.fullName, fileName: rid.fileName, tag: rid.tag });
         }
         github.repoAsync = repoAsync;
+        function repoFromProxyMeta(rid, status, meta) {
+            if (!meta)
+                return undefined;
+            return {
+                github: true,
+                owner: rid.owner,
+                fullName: rid.fullName,
+                fileName: rid.fileName,
+                slug: rid.slug,
+                name: rid.fileName ? `${meta.name}-${rid.fileName}` : meta.name,
+                displayName: meta.displayName,
+                description: meta.description,
+                defaultBranch: meta.defaultBranch || "master",
+                tag: rid.tag,
+                status
+            };
+        }
         function proxyRepoAsync(rid, status) {
             // always use proxy
             return ghProxyWithCdnJsonAsync(rid.slug)
-                .then(meta => {
-                if (!meta)
-                    return undefined;
-                return {
-                    github: true,
-                    owner: rid.owner,
-                    fullName: rid.fullName,
-                    fileName: rid.fileName,
-                    slug: rid.slug,
-                    name: rid.fileName ? `${meta.name}-${rid.fileName}` : meta.name,
-                    displayName: meta.displayName,
-                    description: meta.description,
-                    defaultBranch: meta.defaultBranch || "master",
-                    tag: rid.tag,
-                    status
-                };
-            }).catch(err => {
+                .then(meta => repoFromProxyMeta(rid, status, meta))
+                .catch(err => {
                 pxt.reportException(err);
                 return undefined;
             });
@@ -11903,6 +11976,9 @@ var pxt;
             const parsed = parseRepoId(repopath);
             if (!parsed)
                 return Promise.resolve(null);
+            // a locally resolved repository serves its working tree and has no versions
+            if (isLocalRepo(parsed))
+                return Promise.resolve(undefined);
             return repoAsync(parsed.slug, config)
                 .then(scr => {
                 if (!scr)

package/built/pxtsim.d.ts

@@ -1358,6 +1358,13 @@ declare namespace pxsim {
         restart?: () => void;
         revealElement?: (el: HTMLElement) => void;
         removeElement?: (el: HTMLElement, onComplete?: () => void) => void;
+        /**
+         * Hides the wrapper of a permanent simulator frame when the simulator is
+         * hidden, leaving the element in the container, then calls `onComplete`.
+         * `unhideElement` must reveal it. When unset, `hide()` passes permanent
+         * frames to `removeElement` like any other frame.
+         */
+        hideElement?: (el: HTMLElement, onComplete?: () => void) => void;
         unhideElement?: (el: HTMLElement) => void;
         onDebuggerWarning?: (wrn: DebuggerWarningMessage) => void;
         onDebuggerBreakpoint?: (brk: DebuggerBreakpointMessage) => void;
@@ -1476,6 +1483,12 @@ declare namespace pxsim {
         private setState;
         private freeze;
         private simFrames;
+        /**
+         * Returns the main simulator frame: the first frame not running a
+         * simulator extension, or undefined when there is none.
+         * @param skipLoaned excludes the loaned simulator's frame, as `simFrames` does
+         */
+        private mainFrame;
         private getSimUrl;
         setSingleSimulator(): void;
         postMessage(msg: pxsim.SimulatorMessage, source?: Window, frameID?: string): void;