pxt-core 8.4.1 → 8.4.3

package/built/pxt.js

@@ -97902,6 +97902,9 @@ var pxt;
                 this.setUserProfileAsync(this.state$.profile);
                 this.setUserPreferencesAsync(this.state$.preferences);
             }
+            async authTokenAsync() {
+                return await pxt.storage.shared.getAsync(AUTH_CONTAINER, CSRF_TOKEN_KEY);
+            }
             /**
              * Starts the process of authenticating the user against the given identity
              * provider. Upon success the backend will write an http-only session cookie
@@ -98386,6 +98389,11 @@ var pxt;
             return (_d = (_b = (_a = user === null || user === void 0 ? void 0 : user.idp) === null || _a === void 0 ? void 0 : _a.displayName) !== null && _b !== void 0 ? _b : (_c = user === null || user === void 0 ? void 0 : user.idp) === null || _c === void 0 ? void 0 : _c.username) !== null && _d !== void 0 ? _d : EMPTY_USERNAME;
         }
         auth.userName = userName;
+        function firstName(user) {
+            const userName = pxt.auth.userName(user);
+            return (userName === null || userName === void 0 ? void 0 : userName.split(" ").shift()) || userName;
+        }
+        auth.firstName = firstName;
         function userInitials(user) {
             const username = pxt.auth.userName(user);
             return ts.pxtc.Util.initials(username);
@@ -105222,6 +105230,7 @@ var pxt;
                     .then(resp => handleResponseAsync(resp));
             }
             function handleResponseAsync(resp) {
+                var _a, _b, _c;
                 const code = resp.statusCode;
                 const errorData = pxt.Util.jsonTryParse(resp.text) || {};
                 pxt.debug(`upload result: ${code}`);
@@ -105229,16 +105238,22 @@ var pxt;
                     pxt.log(`create new translation file: ${filename}`);
                     return uploadAsync("add-file", {});
                 }
-                else if (code == 404 && errorData.error && errorData.error.code == 17) {
+                else if (code == 404 && ((_a = errorData.error) === null || _a === void 0 ? void 0 : _a.code) == 17) {
                     return createDirectoryAsync(branch, prj, key, filename.replace(/\/[^\/]+$/, ""), incr)
                         .then(() => startAsync());
                 }
-                else if (!errorData.success && errorData.error && errorData.error.code == 53) {
+                else if (!errorData.success && ((_b = errorData.error) === null || _b === void 0 ? void 0 : _b.code) == 53) {
                     // file is being updated
                     pxt.log(`${filename} being updated, waiting 5s and retry...`);
                     return pxt.U.delay(5000) // wait 5s and try again
                         .then(() => uploadTranslationAsync(branch, prj, key, filename, data));
                 }
+                else if (code == 429 && ((_c = errorData.error) === null || _c === void 0 ? void 0 : _c.code) == 55) {
+                    // Too many concurrent requests
+                    pxt.log(`Maximum concurrent requests reached, waiting 10s and retry...`);
+                    return pxt.U.delay(10 * 1000) // wait 10s and try again
+                        .then(() => uploadTranslationAsync(branch, prj, key, filename, data));
+                }
                 else if (code == 200 || errorData.success) {
                     // something crowdin reports 500 with success=true
                     return Promise.resolve();
@@ -106421,6 +106436,7 @@ var pxt;
                     const url = new URL(`https://${endpointName}.streaming.media.azure.net/${videoID}/manifest(format=mpd-time-csf).mpd`);
                     if (startTime) {
                         url.hash = `t=${startTime}`;
+                        url.searchParams.append("startTime", startTime);
                     }
                     if (endTime) {
                         url.searchParams.append("endTime", endTime);
@@ -110312,6 +110328,8 @@ var pxt;
         sprite_1.IMAGE_PREFIX = "image";
         sprite_1.ANIMATION_NAMESPACE = "myAnimations";
         sprite_1.ANIMATION_PREFIX = "anim";
+        sprite_1.SONG_NAMESPACE = "mySongs";
+        sprite_1.SONG_PREFIX = "song";
         /**
          * 16-color sprite
          */
@@ -111367,6 +111385,1044 @@ var pxt;
         })(shared = storage.shared || (storage.shared = {}));
     })(storage = pxt.storage || (pxt.storage = {}));
 })(pxt || (pxt = {}));
+var pxt;
+(function (pxt) {
+    var assets;
+    (function (assets) {
+        var music;
+        (function (music) {
+            const BUFFER_SIZE = 12;
+            function renderInstrument(instrument, noteFrequency, gateLength, volume) {
+                var _a, _b, _c, _d, _e;
+                const totalDuration = gateLength + instrument.ampEnvelope.release;
+                const ampLFOInterval = ((_a = instrument.ampLFO) === null || _a === void 0 ? void 0 : _a.amplitude) ? Math.max(500 / instrument.ampLFO.frequency, 50) : 50;
+                const pitchLFOInterval = ((_b = instrument.pitchLFO) === null || _b === void 0 ? void 0 : _b.amplitude) ? Math.max(500 / instrument.pitchLFO.frequency, 50) : 50;
+                let timePoints = [0];
+                let nextAETime = instrument.ampEnvelope.attack;
+                let nextPETime = ((_c = instrument.pitchEnvelope) === null || _c === void 0 ? void 0 : _c.amplitude) ? instrument.pitchEnvelope.attack : totalDuration;
+                let nextPLTime = ((_d = instrument.pitchLFO) === null || _d === void 0 ? void 0 : _d.amplitude) ? pitchLFOInterval : totalDuration;
+                let nextALTime = ((_e = instrument.ampLFO) === null || _e === void 0 ? void 0 : _e.amplitude) ? ampLFOInterval : totalDuration;
+                let time = 0;
+                while (time < totalDuration) {
+                    if (nextAETime <= nextPETime && nextAETime <= nextPLTime && nextAETime <= nextALTime) {
+                        time = nextAETime;
+                        timePoints.push(nextAETime);
+                        if (time < instrument.ampEnvelope.attack + instrument.ampEnvelope.decay && instrument.ampEnvelope.attack + instrument.ampEnvelope.decay < gateLength) {
+                            nextAETime = instrument.ampEnvelope.attack + instrument.ampEnvelope.decay;
+                        }
+                        else if (time < gateLength) {
+                            nextAETime = gateLength;
+                        }
+                        else {
+                            nextAETime = totalDuration;
+                        }
+                    }
+                    else if (nextPETime <= nextPLTime && nextPETime <= nextALTime && nextPETime < totalDuration) {
+                        time = nextPETime;
+                        timePoints.push(nextPETime);
+                        if (time < instrument.pitchEnvelope.attack + instrument.pitchEnvelope.decay && instrument.pitchEnvelope.attack + instrument.pitchEnvelope.decay < gateLength) {
+                            nextPETime = instrument.pitchEnvelope.attack + instrument.pitchEnvelope.decay;
+                        }
+                        else if (time < gateLength) {
+                            nextPETime = gateLength;
+                        }
+                        else if (time < gateLength + instrument.pitchEnvelope.release) {
+                            nextPETime = Math.min(totalDuration, gateLength + instrument.pitchEnvelope.release);
+                        }
+                        else {
+                            nextPETime = totalDuration;
+                        }
+                    }
+                    else if (nextPLTime <= nextALTime && nextPLTime < totalDuration) {
+                        time = nextPLTime;
+                        timePoints.push(nextPLTime);
+                        nextPLTime += pitchLFOInterval;
+                    }
+                    else if (nextALTime < totalDuration) {
+                        time = nextALTime;
+                        timePoints.push(nextALTime);
+                        nextALTime += ampLFOInterval;
+                    }
+                    if (time >= totalDuration) {
+                        break;
+                    }
+                    if (nextAETime <= time) {
+                        if (time < instrument.ampEnvelope.attack + instrument.ampEnvelope.decay && instrument.ampEnvelope.attack + instrument.ampEnvelope.decay < gateLength) {
+                            nextAETime = instrument.ampEnvelope.attack + instrument.ampEnvelope.decay;
+                        }
+                        else if (time < gateLength) {
+                            nextAETime = gateLength;
+                        }
+                        else {
+                            nextAETime = totalDuration;
+                        }
+                    }
+                    if (nextPETime <= time) {
+                        if (time < instrument.pitchEnvelope.attack + instrument.pitchEnvelope.decay && instrument.pitchEnvelope.attack + instrument.pitchEnvelope.decay < gateLength) {
+                            nextPETime = instrument.pitchEnvelope.attack + instrument.pitchEnvelope.decay;
+                        }
+                        else if (time < gateLength) {
+                            nextPETime = gateLength;
+                        }
+                        else if (time < gateLength + instrument.pitchEnvelope.release) {
+                            nextPETime = Math.min(totalDuration, gateLength + instrument.pitchEnvelope.release);
+                        }
+                        else {
+                            nextPETime = totalDuration;
+                        }
+                    }
+                    while (nextALTime <= time) {
+                        nextALTime += ampLFOInterval;
+                    }
+                    while (nextPLTime <= time) {
+                        nextPLTime += pitchLFOInterval;
+                    }
+                }
+                let prevAmp = instrumentVolumeAtTime(instrument, gateLength, 0, volume) | 0;
+                let prevPitch = instrumentPitchAtTime(instrument, noteFrequency, gateLength, 0) | 0;
+                let prevTime = 0;
+                let nextAmp;
+                let nextPitch;
+                const out = new Uint8Array(BUFFER_SIZE * (timePoints.length + 1));
+                for (let i = 1; i < timePoints.length; i++) {
+                    if (timePoints[i] - prevTime < 5) {
+                        prevTime = timePoints[i];
+                        continue;
+                    }
+                    nextAmp = instrumentVolumeAtTime(instrument, gateLength, timePoints[i], volume) | 0;
+                    nextPitch = instrumentPitchAtTime(instrument, noteFrequency, gateLength, timePoints[i]) | 0;
+                    addNote(out, (i - 1) * 12, (timePoints[i] - prevTime) | 0, prevAmp, nextAmp, instrument.waveform, prevPitch, nextPitch);
+                    prevAmp = nextAmp;
+                    prevPitch = nextPitch;
+                    prevTime = timePoints[i];
+                }
+                addNote(out, timePoints.length * 12, 10, prevAmp, 0, instrument.waveform, prevPitch, prevPitch);
+                return out;
+            }
+            music.renderInstrument = renderInstrument;
+            function renderDrumInstrument(sound, volume) {
+                let prevAmp = sound.startVolume;
+                let prevFreq = sound.startFrequency;
+                const scaleVolume = (value) => (value / 1024) * volume;
+                let out = new Uint8Array((sound.steps.length + 1) * BUFFER_SIZE);
+                for (let i = 0; i < sound.steps.length; i++) {
+                    addNote(out, i * BUFFER_SIZE, sound.steps[i].duration, scaleVolume(prevAmp), scaleVolume(sound.steps[i].volume), sound.steps[i].waveform, prevFreq, sound.steps[i].frequency);
+                    prevAmp = sound.steps[i].volume;
+                    prevFreq = sound.steps[i].frequency;
+                }
+                addNote(out, sound.steps.length * BUFFER_SIZE, 10, scaleVolume(prevAmp), 0, sound.steps[sound.steps.length - 1].waveform, prevFreq, prevFreq);
+                return out;
+            }
+            music.renderDrumInstrument = renderDrumInstrument;
+            function instrumentPitchAtTime(instrument, noteFrequency, gateLength, time) {
+                var _a, _b;
+                let mod = 0;
+                if ((_a = instrument.pitchEnvelope) === null || _a === void 0 ? void 0 : _a.amplitude) {
+                    mod += envelopeValueAtTime(instrument.pitchEnvelope, time, gateLength);
+                }
+                if ((_b = instrument.pitchLFO) === null || _b === void 0 ? void 0 : _b.amplitude) {
+                    mod += lfoValueAtTime(instrument.pitchLFO, time);
+                }
+                return Math.max(noteFrequency + mod, 0);
+            }
+            function instrumentVolumeAtTime(instrument, gateLength, time, maxVolume) {
+                var _a;
+                let mod = 0;
+                if (instrument.ampEnvelope.amplitude) {
+                    mod += envelopeValueAtTime(instrument.ampEnvelope, time, gateLength);
+                }
+                if ((_a = instrument.ampLFO) === null || _a === void 0 ? void 0 : _a.amplitude) {
+                    mod += lfoValueAtTime(instrument.ampLFO, time);
+                }
+                return ((Math.max(Math.min(mod, instrument.ampEnvelope.amplitude), 0) / 1024) * maxVolume) | 0;
+            }
+            function envelopeValueAtTime(envelope, time, gateLength) {
+                const adjustedSustain = (envelope.sustain / 1024) * envelope.amplitude;
+                if (time > gateLength) {
+                    if (time - gateLength > envelope.release)
+                        return 0;
+                    else if (time < envelope.attack) {
+                        const height = (envelope.amplitude / envelope.attack) * gateLength;
+                        return height - ((height / envelope.release) * (time - gateLength));
+                    }
+                    else if (time < envelope.attack + envelope.decay) {
+                        const height2 = envelope.amplitude - ((envelope.amplitude - adjustedSustain) / envelope.decay) * (gateLength - envelope.attack);
+                        return height2 - ((height2 / envelope.release) * (time - gateLength));
+                    }
+                    else {
+                        return adjustedSustain - (adjustedSustain / envelope.release) * (time - gateLength);
+                    }
+                }
+                else if (time < envelope.attack) {
+                    return (envelope.amplitude / envelope.attack) * time;
+                }
+                else if (time < envelope.attack + envelope.decay) {
+                    return envelope.amplitude - ((envelope.amplitude - adjustedSustain) / envelope.decay) * (time - envelope.attack);
+                }
+                else {
+                    return adjustedSustain;
+                }
+            }
+            function lfoValueAtTime(lfo, time) {
+                return Math.cos(((time / 1000) * lfo.frequency) * 2 * Math.PI) * lfo.amplitude;
+            }
+            function set16BitNumber(buf, offset, value) {
+                const temp = new Uint8Array(2);
+                new Uint16Array(temp.buffer)[0] = value | 0;
+                buf[offset] = temp[0];
+                buf[offset + 1] = temp[1];
+            }
+            function get16BitNumber(buf, offset) {
+                const temp = new Uint8Array(2);
+                temp[0] = buf[offset];
+                temp[1] = buf[offset + 1];
+                return new Uint16Array(temp.buffer)[0];
+            }
+            function addNote(sndInstr, sndInstrPtr, ms, beg, end, soundWave, hz, endHz) {
+                if (ms > 0) {
+                    sndInstr[sndInstrPtr] = soundWave;
+                    sndInstr[sndInstrPtr + 1] = 0;
+                    set16BitNumber(sndInstr, sndInstrPtr + 2, hz);
+                    set16BitNumber(sndInstr, sndInstrPtr + 4, ms);
+                    set16BitNumber(sndInstr, sndInstrPtr + 6, (beg * 255) >> 6);
+                    set16BitNumber(sndInstr, sndInstrPtr + 8, (end * 255) >> 6);
+                    set16BitNumber(sndInstr, sndInstrPtr + 10, endHz);
+                    sndInstrPtr += BUFFER_SIZE;
+                }
+                sndInstr[sndInstrPtr] = 0;
+                return sndInstrPtr;
+            }
+            function encodeSongToHex(song) {
+                const encoded = encodeSong(song);
+                return pxt.U.toHex(encoded);
+            }
+            music.encodeSongToHex = encodeSongToHex;
+            function decodeSongFromHex(hex) {
+                const bytes = pxt.U.fromHex(hex);
+                return decodeSong(bytes);
+            }
+            music.decodeSongFromHex = decodeSongFromHex;
+            /**
+             * Byte encoding format for songs
+             * FIXME: should this all be word aligned?
+             *
+             * song(7 + length of all tracks bytes)
+             *     0 version
+             *     1 beats per minute
+             *     3 beats per measure
+             *     4 ticks per beat
+             *     5 measures
+             *     6 number of tracks
+             *     ...tracks
+             *
+             * track(6 + instrument length + note length bytes)
+             *     0 id
+             *     1 flags
+             *     2 instruments byte length
+             *     4...instrument
+             *     notes byte length
+             *     ...note events
+             *
+             * instrument(27 bytes)
+             *     0 waveform
+             *     1 amp attack
+             *     3 amp decay
+             *     5 amp sustain
+             *     7 amp release
+             *     9 amp amp
+             *     11 pitch attack
+             *     13 pitch decay
+             *     15 pitch sustain
+             *     17 pitch release
+             *     19 pitch amp
+             *     21 amp lfo freq
+             *     22 amp lfo amp
+             *     24 pitch lfo freq
+             *     25 pitch lfo amp
+             *
+             * drum(5 + 7 * steps bytes)
+             *     0 steps
+             *     1 start freq
+             *     3 start amp
+             *     5...steps
+             *
+             * drum step(7 bytes)
+             *     0 waveform
+             *     1 freq
+             *     3 volume
+             *     5 duration
+             *
+             * note event(5 + 1 * polyphony bytes)
+             *     0 start tick
+             *     2 end tick
+             *     4 polyphony
+             *     5...notes(1 byte each)
+             *
+             */
+            function encodeSong(song) {
+                const encodedTracks = song.tracks
+                    .filter((track) => track.notes.length > 0)
+                    .map(encodeTrack);
+                const trackLength = encodedTracks.reduce((d, c) => c.length + d, 0);
+                const out = new Uint8Array(7 + trackLength);
+                out[0] = 0; // encoding version
+                set16BitNumber(out, 1, song.beatsPerMinute);
+                out[3] = song.beatsPerMeasure;
+                out[4] = song.ticksPerBeat;
+                out[5] = song.measures;
+                out[6] = encodedTracks.length;
+                let current = 7;
+                for (const track of encodedTracks) {
+                    out.set(track, current);
+                    current += track.length;
+                }
+                return out;
+            }
+            function decodeSong(buf) {
+                const res = {
+                    beatsPerMinute: get16BitNumber(buf, 1),
+                    beatsPerMeasure: buf[3],
+                    ticksPerBeat: buf[4],
+                    measures: buf[5],
+                    tracks: []
+                };
+                let current = 7;
+                while (current < buf.length) {
+                    const [track, pointer] = decodeTrack(buf, current);
+                    current = pointer;
+                    res.tracks.push(track);
+                }
+                return res;
+            }
+            function encodeInstrument(instrument) {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+                const out = new Uint8Array(28);
+                out[0] = instrument.waveform;
+                set16BitNumber(out, 1, instrument.ampEnvelope.attack);
+                set16BitNumber(out, 3, instrument.ampEnvelope.decay);
+                set16BitNumber(out, 5, instrument.ampEnvelope.sustain);
+                set16BitNumber(out, 7, instrument.ampEnvelope.release);
+                set16BitNumber(out, 9, instrument.ampEnvelope.amplitude);
+                set16BitNumber(out, 11, ((_a = instrument.pitchEnvelope) === null || _a === void 0 ? void 0 : _a.attack) || 0);
+                set16BitNumber(out, 13, ((_b = instrument.pitchEnvelope) === null || _b === void 0 ? void 0 : _b.decay) || 0);
+                set16BitNumber(out, 15, ((_c = instrument.pitchEnvelope) === null || _c === void 0 ? void 0 : _c.sustain) || 0);
+                set16BitNumber(out, 17, ((_d = instrument.pitchEnvelope) === null || _d === void 0 ? void 0 : _d.release) || 0);
+                set16BitNumber(out, 19, ((_e = instrument.pitchEnvelope) === null || _e === void 0 ? void 0 : _e.amplitude) || 0);
+                out[21] = ((_f = instrument.ampLFO) === null || _f === void 0 ? void 0 : _f.frequency) || 0;
+                set16BitNumber(out, 22, ((_g = instrument.ampLFO) === null || _g === void 0 ? void 0 : _g.amplitude) || 0);
+                out[24] = ((_h = instrument.pitchLFO) === null || _h === void 0 ? void 0 : _h.frequency) || 0;
+                set16BitNumber(out, 25, ((_j = instrument.pitchLFO) === null || _j === void 0 ? void 0 : _j.amplitude) || 0);
+                return out;
+            }
+            function decodeInstrument(buf, offset) {
+                return {
+                    waveform: buf[offset],
+                    ampEnvelope: {
+                        attack: get16BitNumber(buf, offset + 1),
+                        decay: get16BitNumber(buf, offset + 3),
+                        sustain: get16BitNumber(buf, offset + 5),
+                        release: get16BitNumber(buf, offset + 7),
+                        amplitude: get16BitNumber(buf, offset + 9),
+                    },
+                    pitchEnvelope: {
+                        attack: get16BitNumber(buf, offset + 11),
+                        decay: get16BitNumber(buf, offset + 13),
+                        sustain: get16BitNumber(buf, offset + 15),
+                        release: get16BitNumber(buf, offset + 17),
+                        amplitude: get16BitNumber(buf, offset + 19),
+                    },
+                    ampLFO: {
+                        frequency: buf[offset + 21],
+                        amplitude: get16BitNumber(buf, 22)
+                    },
+                    pitchLFO: {
+                        frequency: buf[offset + 24],
+                        amplitude: get16BitNumber(buf, 25)
+                    }
+                };
+            }
+            function decodeTrack(buf, offset) {
+                if (buf[offset + 1]) {
+                    return decodeDrumTrack(buf, offset);
+                }
+                return decodeMelodicTrack(buf, offset);
+            }
+            function encodeDrumInstrument(drum) {
+                const out = new Uint8Array(5 + 7 * drum.steps.length);
+                out[0] = drum.steps.length;
+                set16BitNumber(out, 1, drum.startFrequency);
+                set16BitNumber(out, 3, drum.startVolume);
+                for (let i = 0; i < drum.steps.length; i++) {
+                    const start = 5 + i * 7;
+                    out[start] = drum.steps[i].waveform;
+                    set16BitNumber(out, start + 1, drum.steps[i].frequency);
+                    set16BitNumber(out, start + 3, drum.steps[i].volume);
+                    set16BitNumber(out, start + 5, drum.steps[i].duration);
+                }
+                return out;
+            }
+            function decodeDrumInstrument(buf, offset) {
+                const res = {
+                    startFrequency: get16BitNumber(buf, offset + 1),
+                    startVolume: get16BitNumber(buf, offset + 3),
+                    steps: []
+                };
+                for (let i = 0; i < buf[offset]; i++) {
+                    const start = offset + 5 + i * 7;
+                    res.steps.push({
+                        waveform: buf[start],
+                        frequency: get16BitNumber(buf, start + 1),
+                        volume: get16BitNumber(buf, start + 3),
+                        duration: get16BitNumber(buf, start + 5)
+                    });
+                }
+                return res;
+            }
+            function encodeNoteEvent(event) {
+                const out = new Uint8Array(5 + event.notes.length);
+                set16BitNumber(out, 0, event.startTick);
+                set16BitNumber(out, 2, event.endTick);
+                out[4] = event.notes.length;
+                for (let i = 0; i < event.notes.length; i++) {
+                    out[5 + i] = event.notes[i];
+                }
+                return out;
+            }
+            function decodeNoteEvent(buf, offset) {
+                const res = {
+                    startTick: get16BitNumber(buf, offset),
+                    endTick: get16BitNumber(buf, offset + 2),
+                    notes: []
+                };
+                for (let i = 0; i < buf[offset + 4]; i++) {
+                    res.notes.push(buf[offset + 5 + i]);
+                }
+                return res;
+            }
+            function encodeTrack(track) {
+                if (track.drums)
+                    return encodeDrumTrack(track);
+                return encodeMelodicTrack(track);
+            }
+            function encodeMelodicTrack(track) {
+                const encodedInstrument = encodeInstrument(track.instrument);
+                const encodedNotes = track.notes.map(encodeNoteEvent);
+                const noteLength = encodedNotes.reduce((d, c) => c.length + d, 0);
+                const out = new Uint8Array(6 + encodedInstrument.length + noteLength);
+                out[0] = track.id;
+                out[1] = 0;
+                set16BitNumber(out, 2, encodedInstrument.length);
+                let current = 4;
+                out.set(encodedInstrument, current);
+                current += encodedInstrument.length;
+                set16BitNumber(out, current, noteLength);
+                current += 2;
+                for (const note of encodedNotes) {
+                    out.set(note, current);
+                    current += note.length;
+                }
+                return out;
+            }
+            function decodeMelodicTrack(buf, offset) {
+                const res = {
+                    id: buf[offset],
+                    instrument: decodeInstrument(buf, offset + 4),
+                    notes: []
+                };
+                const noteStart = offset + 4 + get16BitNumber(buf, offset + 2);
+                const noteLength = get16BitNumber(buf, noteStart);
+                let currentOffset = noteStart + 2;
+                while (currentOffset < noteStart + 2 + noteLength) {
+                    res.notes.push(decodeNoteEvent(buf, currentOffset));
+                    currentOffset += 5 + res.notes[res.notes.length - 1].notes.length;
+                }
+                return [res, currentOffset];
+            }
+            function encodeDrumTrack(track) {
+                const encodedDrums = track.drums.map(encodeDrumInstrument);
+                const drumLength = encodedDrums.reduce((d, c) => c.length + d, 0);
+                const encodedNotes = track.notes.map(encodeNoteEvent);
+                const noteLength = encodedNotes.reduce((d, c) => c.length + d, 0);
+                const out = new Uint8Array(6 + drumLength + noteLength);
+                out[0] = track.id;
+                out[1] = 1;
+                set16BitNumber(out, 2, drumLength);
+                let current = 4;
+                for (const drum of encodedDrums) {
+                    out.set(drum, current);
+                    current += drum.length;
+                }
+                set16BitNumber(out, current, noteLength);
+                current += 2;
+                for (const note of encodedNotes) {
+                    out.set(note, current);
+                    current += note.length;
+                }
+                return out;
+            }
+            function decodeDrumTrack(buf, offset) {
+                const res = {
+                    id: buf[offset],
+                    instrument: { ampEnvelope: { attack: 0, decay: 0, sustain: 0, release: 0, amplitude: 0 }, waveform: 0 },
+                    notes: [],
+                    drums: []
+                };
+                const drumByteLength = get16BitNumber(buf, offset + 2);
+                let currentOffset = offset + 4;
+                while (currentOffset < offset + 4 + drumByteLength) {
+                    res.drums.push(decodeDrumInstrument(buf, currentOffset));
+                    currentOffset += 5 + 7 * res.drums[res.drums.length - 1].steps.length;
+                }
+                const noteLength = get16BitNumber(buf, currentOffset);
+                currentOffset += 2;
+                while (currentOffset < offset + 4 + drumByteLength + noteLength) {
+                    res.notes.push(decodeNoteEvent(buf, currentOffset));
+                    currentOffset += 5 + res.notes[res.notes.length - 1].notes.length;
+                }
+                return [res, currentOffset];
+            }
+            function cloneSong(song) {
+                return Object.assign(Object.assign({}, song), { tracks: song.tracks.map(track => (Object.assign(Object.assign({}, track), { instrument: track.instrument && Object.assign(Object.assign({}, track.instrument), { ampEnvelope: Object.assign({}, track.instrument.ampEnvelope), pitchEnvelope: track.instrument.pitchEnvelope && Object.assign({}, track.instrument.pitchEnvelope), ampLFO: track.instrument.ampLFO && Object.assign({}, track.instrument.ampLFO), pitchLFO: track.instrument.pitchLFO && Object.assign({}, track.instrument.pitchLFO) }), drums: track.drums && track.drums.map(drum => (Object.assign(Object.assign({}, drum), { steps: drum.steps.map(step => (Object.assign({}, step))) }))), notes: track.notes.map(noteEvent => (Object.assign(Object.assign({}, noteEvent), { notes: noteEvent.notes.slice() }))) }))) });
+            }
+            music.cloneSong = cloneSong;
+            function songEquals(a, b) {
+                return naiveEqualCheck(a, b);
+            }
+            music.songEquals = songEquals;
+            function naiveEqualCheck(a, b) {
+                if (typeof a !== typeof b)
+                    return false;
+                else if (typeof a !== "object")
+                    return a === b;
+                else if (Array.isArray(a)) {
+                    if (a.length !== b.length)
+                        return false;
+                    for (let i = 0; i < a.length; i++) {
+                        if (!naiveEqualCheck(a[i], b[i]))
+                            return false;
+                    }
+                    return true;
+                }
+                const aKeys = Object.keys(a);
+                const bKeys = Object.keys(b);
+                if (aKeys.length !== bKeys.length)
+                    return false;
+                for (const key of aKeys) {
+                    if (bKeys.indexOf(key) === -1)
+                        return false;
+                    if (!naiveEqualCheck(a[key], b[key]))
+                        return false;
+                }
+                return true;
+            }
+            function inflateSong(song) {
+                const base = getEmptySong(1);
+                song.tracks = base.tracks.map((track, index) => {
+                    const existing = song.tracks.find(t => t.id === index);
+                    if (existing)
+                        track.notes = existing.notes;
+                    return track;
+                });
+            }
+            music.inflateSong = inflateSong;
+            function getEmptySong(measures) {
+                return {
+                    ticksPerBeat: 8,
+                    beatsPerMeasure: 4,
+                    beatsPerMinute: 120,
+                    measures,
+                    tracks: [
+                        {
+                            id: 0,
+                            name: lf("Duck"),
+                            notes: [],
+                            iconURI: "/static/music-editor/duck.png",
+                            instrument: {
+                                waveform: 15,
+                                octave: 4,
+                                ampEnvelope: {
+                                    attack: 5,
+                                    decay: 530,
+                                    sustain: 705,
+                                    release: 450,
+                                    amplitude: 1024
+                                },
+                                pitchEnvelope: {
+                                    attack: 5,
+                                    decay: 40,
+                                    sustain: 0,
+                                    release: 100,
+                                    amplitude: 40
+                                },
+                                ampLFO: {
+                                    frequency: 3,
+                                    amplitude: 20
+                                },
+                                pitchLFO: {
+                                    frequency: 6,
+                                    amplitude: 2
+                                }
+                            }
+                        },
+                        {
+                            id: 1,
+                            name: lf("Cat"),
+                            notes: [],
+                            iconURI: "/static/music-editor/cat.png",
+                            instrument: {
+                                waveform: 12,
+                                octave: 5,
+                                ampEnvelope: {
+                                    attack: 150,
+                                    decay: 100,
+                                    sustain: 365,
+                                    release: 400,
+                                    amplitude: 1024
+                                },
+                                pitchEnvelope: {
+                                    attack: 120,
+                                    decay: 300,
+                                    sustain: 0,
+                                    release: 100,
+                                    amplitude: 50
+                                },
+                                pitchLFO: {
+                                    frequency: 10,
+                                    amplitude: 6
+                                }
+                            }
+                        },
+                        {
+                            id: 2,
+                            name: lf("Dog"),
+                            notes: [],
+                            iconURI: "/static/music-editor/dog.png",
+                            instrument: {
+                                waveform: 1,
+                                octave: 4,
+                                ampEnvelope: {
+                                    attack: 10,
+                                    decay: 100,
+                                    sustain: 500,
+                                    release: 100,
+                                    amplitude: 1024
+                                },
+                                pitchLFO: {
+                                    frequency: 5,
+                                    amplitude: 0
+                                }
+                            }
+                        },
+                        {
+                            id: 3,
+                            name: lf("Fish"),
+                            notes: [],
+                            iconURI: "/static/music-editor/fish.png",
+                            instrument: {
+                                waveform: 1,
+                                octave: 3,
+                                ampEnvelope: {
+                                    attack: 220,
+                                    decay: 105,
+                                    sustain: 1024,
+                                    release: 350,
+                                    amplitude: 1024
+                                },
+                                ampLFO: {
+                                    frequency: 5,
+                                    amplitude: 100
+                                },
+                                pitchLFO: {
+                                    frequency: 1,
+                                    amplitude: 4
+                                }
+                            }
+                        },
+                        {
+                            id: 4,
+                            name: lf("Car"),
+                            notes: [],
+                            iconURI: "/static/music-editor/car.png",
+                            instrument: {
+                                waveform: 16,
+                                octave: 4,
+                                ampEnvelope: {
+                                    attack: 5,
+                                    decay: 100,
+                                    sustain: 1024,
+                                    release: 30,
+                                    amplitude: 1024
+                                },
+                                pitchLFO: {
+                                    frequency: 10,
+                                    amplitude: 4
+                                }
+                            }
+                        },
+                        {
+                            id: 5,
+                            name: lf("Computer"),
+                            notes: [],
+                            iconURI: "/static/music-editor/computer.png",
+                            instrument: {
+                                waveform: 15,
+                                octave: 1,
+                                ampEnvelope: {
+                                    attack: 10,
+                                    decay: 100,
+                                    sustain: 500,
+                                    release: 10,
+                                    amplitude: 1024
+                                }
+                            }
+                        },
+                        {
+                            id: 6,
+                            name: lf("Burger"),
+                            notes: [],
+                            iconURI: "/static/music-editor/burger.png",
+                            instrument: {
+                                waveform: 1,
+                                octave: 1,
+                                ampEnvelope: {
+                                    attack: 10,
+                                    decay: 100,
+                                    sustain: 500,
+                                    release: 100,
+                                    amplitude: 1024
+                                }
+                            }
+                        },
+                        {
+                            id: 7,
+                            name: lf("Cherry"),
+                            notes: [],
+                            iconURI: "/static/music-editor/cherry.png",
+                            instrument: {
+                                waveform: 2,
+                                octave: 3,
+                                ampEnvelope: {
+                                    attack: 10,
+                                    decay: 100,
+                                    sustain: 500,
+                                    release: 100,
+                                    amplitude: 1024
+                                }
+                            }
+                        },
+                        {
+                            id: 8,
+                            name: lf("Lemon"),
+                            notes: [],
+                            iconURI: "/static/music-editor/lemon.png",
+                            instrument: {
+                                waveform: 15,
+                                octave: 2,
+                                ampEnvelope: {
+                                    attack: 10,
+                                    decay: 100,
+                                    sustain: 500,
+                                    release: 10,
+                                    amplitude: 1024
+                                }
+                            }
+                        },
+                        {
+                            id: 9,
+                            name: lf("Explosion"),
+                            notes: [],
+                            iconURI: "/static/music-editor/explosion.png",
+                            instrument: {
+                                waveform: 11,
+                                octave: 4,
+                                ampEnvelope: {
+                                    attack: 10,
+                                    decay: 100,
+                                    sustain: 500,
+                                    release: 100,
+                                    amplitude: 1024
+                                }
+                            },
+                            drums: [
+                                {
+                                    startFrequency: 100,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 3,
+                                            frequency: 120,
+                                            duration: 10,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 3,
+                                            frequency: 1,
+                                            duration: 100,
+                                            volume: 0
+                                        }
+                                    ]
+                                },
+                                {
+                                    startFrequency: 1,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 0
+                                        }
+                                    ]
+                                },
+                                {
+                                    startFrequency: 1,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 480
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 260
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 200
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 200,
+                                            volume: 0
+                                        },
+                                    ]
+                                },
+                                {
+                                    startFrequency: 175,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 1,
+                                            frequency: 200,
+                                            duration: 10,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 1,
+                                            frequency: 150,
+                                            duration: 20,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 100
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 300,
+                                            volume: 0
+                                        },
+                                    ]
+                                },
+                                {
+                                    startFrequency: 100,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 3,
+                                            frequency: 120,
+                                            duration: 10,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 1,
+                                            frequency: 120,
+                                            duration: 100,
+                                            volume: 0
+                                        }
+                                    ]
+                                },
+                                {
+                                    startFrequency: 1,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 0
+                                        }
+                                    ]
+                                },
+                                {
+                                    startFrequency: 1,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 480
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 260
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 200
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 200,
+                                            volume: 0
+                                        },
+                                    ]
+                                },
+                                {
+                                    startFrequency: 175,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 1,
+                                            frequency: 200,
+                                            duration: 10,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 1,
+                                            frequency: 150,
+                                            duration: 20,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 100
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 300,
+                                            volume: 0
+                                        },
+                                    ]
+                                },
+                                {
+                                    startFrequency: 100,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 3,
+                                            frequency: 120,
+                                            duration: 10,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 1,
+                                            frequency: 120,
+                                            duration: 100,
+                                            volume: 0
+                                        }
+                                    ]
+                                },
+                                {
+                                    startFrequency: 1,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 0
+                                        }
+                                    ]
+                                },
+                                {
+                                    startFrequency: 1,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 480
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 260
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 200
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 200,
+                                            volume: 0
+                                        },
+                                    ]
+                                },
+                                {
+                                    startFrequency: 175,
+                                    startVolume: 1024,
+                                    steps: [
+                                        {
+                                            waveform: 1,
+                                            frequency: 200,
+                                            duration: 10,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 1,
+                                            frequency: 150,
+                                            duration: 20,
+                                            volume: 1024
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 20,
+                                            volume: 100
+                                        },
+                                        {
+                                            waveform: 5,
+                                            frequency: 1,
+                                            duration: 300,
+                                            volume: 0
+                                        },
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                };
+            }
+            music.getEmptySong = getEmptySong;
+        })(music = assets.music || (assets.music = {}));
+    })(assets = pxt.assets || (pxt.assets = {}));
+})(pxt || (pxt = {}));
 /// <reference path="../localtypings/pxtpackage.d.ts"/>
 /// <reference path="../localtypings/pxtparts.d.ts"/>
 /// <reference path="../localtypings/pxtarget.d.ts"/>
@@ -115431,6 +116487,7 @@ var pxt;
     pxt.IMAGE_MIME_TYPE = "image/x-mkcd-f4";
     pxt.TILEMAP_MIME_TYPE = "application/mkcd-tilemap";
     pxt.ANIMATION_MIME_TYPE = "application/mkcd-animation";
+    pxt.SONG_MIME_TYPE = "application/mkcd-song";
     class AssetCollection {
         constructor() {
             this.assets = [];
@@ -115617,21 +116674,24 @@ var pxt;
                 tilemaps: new AssetCollection(),
                 tiles: new AssetCollection(),
                 animations: new AssetCollection(),
-                images: new AssetCollection()
+                images: new AssetCollection(),
+                songs: new AssetCollection(),
             };
             this.state = {
                 revision: this.nextID++,
                 tilemaps: new AssetCollection(),
                 tiles: new AssetCollection(),
                 animations: new AssetCollection(),
-                images: new AssetCollection()
+                images: new AssetCollection(),
+                songs: new AssetCollection(),
             };
             this.gallery = {
                 revision: 0,
                 tilemaps: new AssetCollection(),
                 tiles: new AssetCollection(),
                 animations: new AssetCollection(),
-                images: new AssetCollection()
+                images: new AssetCollection(),
+                songs: new AssetCollection(),
             };
             this.undoStack = [];
             this.redoStack = [];
@@ -115733,6 +116793,19 @@ var pxt;
             };
             return this.state.images.add(newImage);
         }
+        createNewSong(data, displayName) {
+            this.onChange();
+            const newSong = {
+                internalID: this.getNewInternalId(),
+                id: this.generateNewID("song" /* AssetType.Song */),
+                type: "song" /* AssetType.Song */,
+                song: pxt.assets.music.cloneSong(data),
+                meta: {
+                    displayName
+                },
+            };
+            return this.state.songs.add(newSong);
+        }
         updateTile(tile) {
             this.onChange();
             const existing = this.resolveProjectTileByInternalID(tile.internalID);
@@ -115769,6 +116842,7 @@ var pxt;
             const blob = {};
             this.state.images.serializeToJRes(blob);
             this.state.animations.serializeToJRes(blob);
+            this.state.songs.serializeToJRes(blob);
             blob["*"] = {
                 "mimeType": "image/x-mkcd-f4",
                 "dataEncoding": "base64",
@@ -115850,6 +116924,7 @@ var pxt;
                 tilemaps: this.state.tilemaps.clone(),
                 animations: this.state.animations.clone(),
                 tiles: this.state.tiles.clone(),
+                songs: this.state.songs.clone(),
             };
         }
         undo() {
@@ -115862,6 +116937,7 @@ var pxt;
                 this.state.images.applyDiff(undo.images, true);
                 this.state.tilemaps.applyDiff(undo.tilemaps, true);
                 this.state.animations.applyDiff(undo.animations, true);
+                this.state.songs.applyDiff(undo.songs, true);
                 this.state.revision = undo.beforeRevision;
                 this.redoStack.push(undo);
                 this.committedState = this.cloneState();
@@ -115875,6 +116951,7 @@ var pxt;
                 this.state.images.applyDiff(redo.images);
                 this.state.tilemaps.applyDiff(redo.tilemaps);
                 this.state.animations.applyDiff(redo.animations);
+                this.state.songs.applyDiff(redo.songs);
                 this.state.revision = redo.afterRevision;
                 this.undoStack.push(redo);
                 this.committedState = this.cloneState();
@@ -115891,7 +116968,8 @@ var pxt;
                 tiles: this.state.tiles.diff(this.committedState.tiles),
                 images: this.state.images.diff(this.committedState.images),
                 tilemaps: this.state.tilemaps.diff(this.committedState.tilemaps),
-                animations: this.state.animations.diff(this.committedState.animations)
+                animations: this.state.animations.diff(this.committedState.animations),
+                songs: this.state.songs.diff(this.committedState.songs)
             });
             this.committedState = this.cloneState();
             this.cleanupTemporaryAssets();
@@ -115921,16 +116999,8 @@ var pxt;
         }
         isNameTaken(assetType, name) {
             const isTaken = (id) => {
-                switch (assetType) {
-                    case "image" /* AssetType.Image */:
-                        return this.state.images.isIDTaken(id) || this.gallery.images.isIDTaken(id);
-                    case "tile" /* AssetType.Tile */:
-                        return this.state.tiles.isIDTaken(id) || this.gallery.tiles.isIDTaken(id);
-                    case "tilemap" /* AssetType.Tilemap */:
-                        return this.state.tilemaps.isIDTaken(id) || this.gallery.tilemaps.isIDTaken(id);
-                    case "animation" /* AssetType.Animation */:
-                        return this.state.animations.isIDTaken(id) || this.gallery.animations.isIDTaken(id);
-                }
+                return getAssetCollection(this.state, assetType).isIDTaken(id) ||
+                    getAssetCollection(this.gallery, assetType).isIDTaken(id);
             };
             const shortId = getShortIDCore(assetType, name);
             const checkShortId = shortId && shortId !== name;
@@ -115956,6 +117026,10 @@ var pxt;
          * assets.animation`shortId`
          * assets.animation`displayName`
          *
+         * SONGS:
+         * assets.song`shortId`
+         * assets.song`displayName`
+         *
          * TILEMAPS:
          * tilemap`shortId`
          *
@@ -115994,6 +117068,11 @@ var pxt;
                         if (displayName)
                             assetTsRefs += `|assets.animation\`${displayName}\``;
                         break;
+                    case "song" /* pxt.AssetType.Song */:
+                        assetTsRefs = `assets.song\`${shortId}\``;
+                        if (displayName)
+                            assetTsRefs += `|assets.song\`${displayName}\``;
+                        break;
                     default:
                         assetTsRefs = `assets.image\`${shortId}\``;
                         if (displayName)
@@ -116016,6 +117095,11 @@ var pxt;
                         if (displayName)
                             assetPyRefs += `|assets.animation\("""${displayName}"""\)`;
                         break;
+                    case "song" /* pxt.AssetType.Song */:
+                        assetPyRefs = `assets.song\("""${shortId}"""\)`;
+                        if (displayName)
+                            assetPyRefs += `|assets.song\("""${displayName}"""\)`;
+                        break;
                     default:
                         assetPyRefs = `assets.image\("""${shortId}"""\)`;
                         if (displayName)
@@ -116041,65 +117125,29 @@ var pxt;
             return false;
         }
         lookupAsset(assetType, name) {
-            switch (assetType) {
-                case "image" /* AssetType.Image */:
-                    return this.state.images.getByID(name) || this.gallery.images.getByID(name);
-                case "tile" /* AssetType.Tile */:
-                    return this.state.tiles.getByID(name) || this.gallery.tiles.getByID(name);
-                case "tilemap" /* AssetType.Tilemap */:
-                    return this.state.tilemaps.getByID(name) || this.gallery.tilemaps.getByID(name);
-                case "animation" /* AssetType.Animation */:
-                    return this.state.animations.getByID(name) || this.gallery.animations.getByID(name);
-            }
+            return getAssetCollection(this.state, assetType).getByID(name) ||
+                getAssetCollection(this.gallery, assetType).getByID(name);
         }
         lookupAssetByName(assetType, name) {
-            switch (assetType) {
-                case "image" /* AssetType.Image */:
-                    return this.state.images.getByDisplayName(name);
-                case "tile" /* AssetType.Tile */:
-                    return this.state.tiles.getByDisplayName(name);
-                case "tilemap" /* AssetType.Tilemap */:
-                    return this.state.tilemaps.getByDisplayName(name);
-                case "animation" /* AssetType.Animation */:
-                    return this.state.animations.getByDisplayName(name);
-            }
+            return getAssetCollection(this.state, assetType).getByDisplayName(name);
         }
         getAssets(type) {
-            switch (type) {
-                case "image" /* AssetType.Image */: return this.state.images.getSnapshot();
-                case "tile" /* AssetType.Tile */: return this.state.tiles.getSnapshot();
-                case "tilemap" /* AssetType.Tilemap */: return this.state.tilemaps.getSnapshot();
-                case "animation" /* AssetType.Animation */: return this.state.animations.getSnapshot();
-            }
+            return getAssetCollection(this.state, type).getSnapshot();
         }
         getGalleryAssets(type) {
-            switch (type) {
-                case "image" /* AssetType.Image */: return this.gallery.images.getSnapshot();
-                case "tile" /* AssetType.Tile */: return this.gallery.tiles.getSnapshot();
-                case "tilemap" /* AssetType.Tilemap */: return this.gallery.tilemaps.getSnapshot();
-                case "animation" /* AssetType.Animation */: return this.gallery.animations.getSnapshot();
-            }
+            return getAssetCollection(this.gallery, type).getSnapshot();
         }
         lookupBlockAsset(type, blockID) {
             let filter = (a) => { var _a, _b; return ((_b = (_a = a.meta) === null || _a === void 0 ? void 0 : _a.blockIDs) === null || _b === void 0 ? void 0 : _b.indexOf(blockID)) !== -1; };
-            switch (type) {
-                case "image" /* AssetType.Image */: return this.state.images.getSnapshot(filter)[0];
-                case "tile" /* AssetType.Tile */: return this.state.tiles.getSnapshot(filter)[0];
-                case "tilemap" /* AssetType.Tilemap */: return this.state.tilemaps.getSnapshot(filter)[0];
-                case "animation" /* AssetType.Animation */: return this.state.animations.getSnapshot(filter)[0];
-            }
+            return getAssetCollection(this.state, type).getSnapshot(filter)[0];
         }
         updateAsset(asset) {
             this.onChange();
             switch (asset.type) {
-                case "image" /* AssetType.Image */:
-                    return this.state.images.update(asset.id, asset);
                 case "tile" /* AssetType.Tile */:
                     return this.updateTile(asset);
-                case "tilemap" /* AssetType.Tilemap */:
-                    return this.state.tilemaps.update(asset.id, asset);
-                case "animation" /* AssetType.Animation */:
-                    return this.state.animations.update(asset.id, asset);
+                default:
+                    return getAssetCollection(this.state, asset.type).update(asset.id, asset);
             }
         }
         duplicateAsset(asset, displayName) {
@@ -116121,53 +117169,22 @@ var pxt;
                     break;
                 case "animation" /* AssetType.Animation */:
                     newAsset = this.createNewAnimationFromData(clone.frames, clone.interval, name);
+                    break;
+                case "song" /* AssetType.Song */:
+                    newAsset = this.createNewSong(asset.song, name);
+                    break;
             }
             return newAsset;
         }
         removeAsset(asset) {
             this.onChange();
-            switch (asset.type) {
-                case "image" /* AssetType.Image */:
-                    return this.state.images.removeByID(asset.id);
-                case "tile" /* AssetType.Tile */:
-                    return this.state.tiles.removeByID(asset.id);
-                case "tilemap" /* AssetType.Tilemap */:
-                    return this.state.tilemaps.removeByID(asset.id);
-                case "animation" /* AssetType.Animation */:
-                    return this.state.animations.removeByID(asset.id);
-            }
+            getAssetCollection(this.state, asset.type).removeByID(asset.id);
         }
         addChangeListener(asset, listener) {
-            switch (asset.type) {
-                case "image" /* AssetType.Image */:
-                    this.state.images.addListener(asset.internalID, listener);
-                    break;
-                case "tile" /* AssetType.Tile */:
-                    this.state.tiles.addListener(asset.internalID, listener);
-                    break;
-                case "tilemap" /* AssetType.Tilemap */:
-                    this.state.tilemaps.addListener(asset.internalID, listener);
-                    break;
-                case "animation" /* AssetType.Animation */:
-                    this.state.animations.addListener(asset.internalID, listener);
-                    break;
-            }
+            getAssetCollection(this.state, asset.type).addListener(asset.internalID, listener);
         }
         removeChangeListener(type, listener) {
-            switch (type) {
-                case "image" /* AssetType.Image */:
-                    this.state.images.removeListener(listener);
-                    break;
-                case "tile" /* AssetType.Tile */:
-                    this.state.tiles.removeListener(listener);
-                    break;
-                case "tilemap" /* AssetType.Tilemap */:
-                    this.state.tilemaps.removeListener(listener);
-                    break;
-                case "animation" /* AssetType.Animation */:
-                    this.state.animations.removeListener(listener);
-                    break;
-            }
+            getAssetCollection(this.state, type).removeListener(listener);
         }
         loadPackage(pack) {
             const allPackages = pack.sortedDeps();
@@ -116192,7 +117209,7 @@ var pxt;
                             this.gallery.images.add(image);
                         }
                     }
-                    else {
+                    else if (image.type === "animation" /* AssetType.Animation */) {
                         if (isProject) {
                             this.state.animations.add(image);
                         }
@@ -116200,6 +117217,14 @@ var pxt;
                             this.gallery.animations.add(image);
                         }
                     }
+                    else {
+                        if (isProject) {
+                            this.state.songs.add(image);
+                        }
+                        else {
+                            this.gallery.songs.add(image);
+                        }
+                    }
                 }
             }
             for (const tm of getTilemaps(pack.parseJRes())) {
@@ -116276,6 +117301,9 @@ var pxt;
                         this.state.animations.add(animation);
                     }
                 }
+                else if (entry.mimeType === pxt.SONG_MIME_TYPE) {
+                    this.state.songs.add(this.generateSong(entry));
+                }
             }
             for (const animation of toInflate) {
                 this.state.animations.add(this.inflateAnimation(animation, this.state.images.getSnapshot()));
@@ -116286,6 +117314,7 @@ var pxt;
             cleanupCollection(this.state.tiles);
             cleanupCollection(this.state.tilemaps);
             cleanupCollection(this.state.animations);
+            cleanupCollection(this.state.songs);
             function cleanupCollection(collection) {
                 const inactiveAssets = collection.getSnapshot(asset => { var _a; return !asset.meta.displayName && ((_a = asset.meta.blockIDs) === null || _a === void 0 ? void 0 : _a.some(id => activeBlockIDs.indexOf(id) === -1)); });
                 const toRemove = [];
@@ -116315,6 +117344,17 @@ var pxt;
                 bitmap: pxt.sprite.getBitmapFromJResURL(`data:${pxt.IMAGE_MIME_TYPE};base64,${entry.data}`).data()
             };
         }
+        generateSong(entry) {
+            return {
+                internalID: this.getNewInternalId(),
+                type: "song" /* AssetType.Song */,
+                id: entry.id,
+                meta: {
+                    displayName: entry.displayName
+                },
+                song: pxt.assets.music.decodeSongFromHex(entry.data)
+            };
+        }
         generateAnimation(entry) {
             if (entry.dataEncoding === "json") {
                 let data;
@@ -116368,6 +117408,8 @@ var pxt;
                     return this.generateNewIDInternal("tile" /* AssetType.Tile */, pxt.sprite.TILE_PREFIX, pxt.sprite.TILE_NAMESPACE);
                 case "tilemap" /* AssetType.Tilemap */:
                     return this.generateNewIDInternal("tilemap" /* AssetType.Tilemap */, lf("level"));
+                case "song" /* AssetType.Song */:
+                    return this.generateNewIDInternal("song" /* AssetType.Song */, pxt.sprite.SONG_PREFIX, pxt.sprite.SONG_NAMESPACE);
             }
         }
         generateNewIDInternal(type, varPrefix, namespaceString) {
@@ -116405,6 +117447,9 @@ var pxt;
                         assets.push(animation);
                     }
                 }
+                else if (entry.mimeType === pxt.SONG_MIME_TYPE) {
+                    assets.push(this.generateSong(entry));
+                }
             }
             for (const animation of toInflate) {
                 assets.push(this.inflateAnimation(animation, assets));
@@ -116465,6 +117510,7 @@ var pxt;
         let out = "";
         const imageEntries = [];
         const animationEntries = [];
+        const songEntries = [];
         for (const key of entries) {
             if (key === "*")
                 continue;
@@ -116491,10 +117537,17 @@ var pxt;
                     expression: `[${animation.frames.map(f => pxt.sprite.bitmapToImageLiteral(pxt.sprite.Bitmap.fromData(f), "typescript")).join(", ")}]`
                 });
             }
+            else if (entry.mimeType === pxt.SONG_MIME_TYPE) {
+                songEntries.push({
+                    keys: [getShortIDCore("song" /* AssetType.Song */, key, true), entry.displayName],
+                    expression: `hex\`${entry.data}\``
+                });
+            }
         }
         const warning = lf("Auto-generated code. Do not edit.");
         out += emitFactoryHelper("image", imageEntries);
         out += emitFactoryHelper("animation", animationEntries);
+        out += emitFactoryHelper("song", songEntries);
         return `// ${warning}\nnamespace ${pxt.sprite.IMAGES_NAMESPACE} {\n${out}\n}\n// ${warning}\n`;
     }
     pxt.emitProjectImages = emitProjectImages;
@@ -116538,6 +117591,8 @@ var pxt;
                 return Object.assign(Object.assign({}, asset), { frames: asset.frames.map(frame => cloneBitmap(frame)) });
             case "tilemap" /* AssetType.Tilemap */:
                 return Object.assign(Object.assign({}, asset), { data: asset.data.cloneData() });
+            case "song" /* AssetType.Song */:
+                return Object.assign(Object.assign({}, asset), { song: pxt.assets.music.cloneSong(asset.song) });
         }
     }
     pxt.cloneAsset = cloneAsset;
@@ -116571,6 +117626,13 @@ var pxt;
             case "animation" /* AssetType.Animation */:
                 allJRes[id] = serializeAnimation(asset);
                 break;
+            case "song" /* AssetType.Song */:
+                allJRes[id] = {
+                    data: pxt.assets.music.encodeSongToHex(asset.song),
+                    mimeType: pxt.SONG_MIME_TYPE,
+                    displayName: asset.meta.displayName
+                };
+                break;
         }
     }
     function assetEquals(a, b) {
@@ -116590,6 +117652,8 @@ var pxt;
                 return a.interval === bAnimation.interval && pxt.U.arrayEquals(a.frames, bAnimation.frames, pxt.sprite.bitmapEquals);
             case "tilemap" /* AssetType.Tilemap */:
                 return a.data.equals(b.data);
+            case "song" /* AssetType.Song */:
+                return pxt.assets.music.songEquals(a.song, b.song);
         }
     }
     pxt.assetEquals = assetEquals;
@@ -116629,11 +117693,13 @@ var pxt;
                 return `assets.animation${leftTick}${shortId}${rightTick}`;
             case "tilemap" /* AssetType.Tilemap */:
                 return `tilemap${leftTick}${shortId}${rightTick}`;
+            case "song" /* AssetType.Song */:
+                return `assets.song${leftTick}${shortId}${rightTick}`;
         }
     }
     pxt.getTSReferenceForAsset = getTSReferenceForAsset;
     function parseAssetTSReference(ts) {
-        const match = /^\s*(?:(?:assets\s*\.\s*(image|tile|animation|tilemap))|(tilemap))\s*(?:`|\(""")([^`"]+)(?:`|"""\))\s*$/m.exec(ts);
+        const match = /^\s*(?:(?:assets\s*\.\s*(image|tile|animation|tilemap|song))|(tilemap))\s*(?:`|\(""")([^`"]+)(?:`|"""\))\s*$/m.exec(ts);
         if (match) {
             const type = match[1] || match[2];
             const name = match[3].trim();
@@ -116657,6 +117723,8 @@ var pxt;
                     return project.lookupAssetByName("tilemap" /* AssetType.Tilemap */, name) || project.lookupAsset("tilemap" /* AssetType.Tilemap */, name);
                 case "animation":
                     return project.lookupAssetByName("animation" /* AssetType.Animation */, name);
+                case "song":
+                    return project.lookupAssetByName("song" /* AssetType.Song */, name);
             }
         }
         return undefined;
@@ -116672,6 +117740,8 @@ var pxt;
                 return lf("level");
             case "animation" /* pxt.AssetType.Animation */:
                 return lf("myAnim");
+            case "song" /* pxt.AssetType.Song */:
+                return lf("mySong");
             default:
                 return lf("asset");
         }
@@ -116696,6 +117766,9 @@ var pxt;
             case "animation" /* AssetType.Animation */:
                 prefix = pxt.sprite.ANIMATION_NAMESPACE + ".";
                 break;
+            case "song" /* AssetType.Song */:
+                prefix = pxt.sprite.SONG_NAMESPACE + ".";
+                break;
         }
         if (prefix) {
             if (id.startsWith(prefix)) {
@@ -116780,6 +117853,15 @@ var pxt;
     function read16Bit(buf, offset) {
         return buf[offset] | (buf[offset + 1] << 8);
     }
+    function getAssetCollection(snapshot, type) {
+        switch (type) {
+            case "animation" /* AssetType.Animation */: return snapshot.animations;
+            case "image" /* AssetType.Image */: return snapshot.images;
+            case "tile" /* AssetType.Tile */: return snapshot.tiles;
+            case "tilemap" /* AssetType.Tilemap */: return snapshot.tilemaps;
+            case "song" /* AssetType.Song */: return snapshot.songs;
+        }
+    }
 })(pxt || (pxt = {}));
 var pxt;
 (function (pxt) {
@@ -120724,7 +121806,7 @@ var pxt;
                 return undefined;
             if (scriptid[0] == "_" && scriptid.length == 13)
                 return scriptid;
-            if (scriptid.length == 23 && /^[0-9\-]+$/.test(scriptid))
+            if (scriptid.length == 23 && /^[0-9\-]+$/.test(scriptid) || scriptid.length == 24 && /^S[0-9\-]+$/.test(scriptid))
                 return scriptid;
             return undefined;
         }
@@ -154609,7 +155691,7 @@ var pxsim;
                 channel.gain.gain.value = 0;
                 channel.gain.gain.setValueAtTime(volume, context().currentTime);
                 channel.gain.connect(destination);
-                if (channels.length > 5)
+                if (channels.length > 20)
                     channels[0].remove();
                 channels.push(channel);
                 const checkCancel = () => {
@@ -154679,7 +155761,7 @@ var pxsim;
                 let resolved = false;
                 let ctx = context();
                 let channel = new Channel();
-                if (channels.length > 5)
+                if (channels.length > 20)
                     channels[0].remove();
                 channels.push(channel);
                 channel.gain = ctx.createGain();
@@ -154713,6 +155795,10 @@ var pxsim;
                     const endVolume = readUint16(instructions, i + 8);
                     const endFrequency = readUint16(instructions, i + 10);
                     totalDuration += duration;
+                    if (wave === 0) {
+                        currentTime += duration;
+                        continue;
+                    }
                     const isSquareWave = 11 <= wave && wave <= 15;
                     if (!oscillators[wave]) {
                         oscillators[wave] = getGenerator(wave, startFrequency);
@@ -154755,7 +155841,8 @@ var pxsim;
                             return;
                         }
                         const { frequency, volume } = findFrequencyAndVolumeAtTime((time - startTime) * 1000, instructions);
-                        onPull(frequency, volume / 1024);
+                        if (onPull)
+                            onPull(frequency, volume / 1024);
                         requestAnimationFrame(handleAnimationFrame);
                     };
                     requestAnimationFrame(handleAnimationFrame);
@@ -158167,7 +159254,8 @@ function pxtFileList(pref) {
         .concat(nodeutil.allFiles(pref + "built/web/fonts", { maxDepth: 1 }))
         .concat(nodeutil.allFiles(pref + "built/web/vs", { maxDepth: 4 }))
         .concat(nodeutil.allFiles(pref + "built/web/skillmap", { maxDepth: 4 }))
-        .concat(nodeutil.allFiles(pref + "built/web/authcode", { maxDepth: 4 }));
+        .concat(nodeutil.allFiles(pref + "built/web/authcode", { maxDepth: 4 }))
+        .concat(nodeutil.allFiles(pref + "built/web/multiplayer", { maxDepth: 4 }));
 }
 function semverCmp(a, b) {
     let parse = (s) => {
@@ -158248,7 +159336,8 @@ function ciAsync() {
                         .then(() => buildWebStringsAsync())
                         .then(() => crowdin.execCrowdinAsync("upload", "built/webstrings.json"))
                         .then(() => crowdin.execCrowdinAsync("upload", "built/skillmap-strings.json"))
-                        .then(() => crowdin.execCrowdinAsync("upload", "built/authcode-strings.json"));
+                        .then(() => crowdin.execCrowdinAsync("upload", "built/authcode-strings.json"))
+                        .then(() => crowdin.execCrowdinAsync("upload", "built/multiplayer-strings.json"));
                 if (uploadApiStrings)
                     p = p.then(() => crowdin.execCrowdinAsync("upload", "built/strings.json"));
                 if (uploadDocs || uploadApiStrings)
@@ -158767,6 +159856,7 @@ function uploadCoreAsync(opts) {
             "asseteditorUrl": opts.localDir + "asseteditor.html",
             "skillmapUrl": opts.localDir + "skillmap.html",
             "authcodeUrl": opts.localDir + "authcode.html",
+            "multiplayerUrl": opts.localDir + "multiplayer.html",
             "isStatic": true,
         };
         const targetImagePaths = targetImages.map(k => `${opts.localDir}${path.join('./docs', logos[k])}`);
@@ -158813,14 +159903,16 @@ function uploadCoreAsync(opts) {
         "multi.html",
         "asseteditor.html",
         "skillmap.html",
-        "authcode.html"
+        "authcode.html",
+        "multiplayer.html",
     ];
     // expandHtml is manually called on these files before upload
     // runs <!-- @include --> substitutions, fills in locale, etc
     let expandFiles = [
         "index.html",
         "skillmap.html",
-        "authcode.html"
+        "authcode.html",
+        "multiplayer.html",
     ];
     nodeutil.mkdirP("built/uploadrepl");
     function encodeURLs(urls) {
@@ -159614,33 +160706,29 @@ async function buildSemanticUIAsync(parsed) {
             ]
         });
     }
-    // Generate react-common css for skillmap and authcode
-    const skillmapFile = isPxtCore ? "react-common/styles/react-common-skillmap-core.less" :
-        "node_modules/pxt-core/react-common/styles/react-common-skillmap.less";
-    await nodeutil.spawnAsync({
-        cmd: "node",
-        args: [
-            lessCPath,
-            skillmapFile,
-            "built/web/react-common-skillmap.css",
-            "--include-path=" + lessIncludePaths
-        ]
-    });
-    const authcodeFile = isPxtCore ? "react-common/styles/react-common-authcode-core.less" :
-        "node_modules/pxt-core/react-common/styles/react-common-authcode.less";
-    await nodeutil.spawnAsync({
-        cmd: "node",
-        args: [
-            lessCPath,
-            authcodeFile,
-            "built/web/react-common-authcode.css",
-            "--include-path=" + lessIncludePaths
-        ]
-    });
-    let skillmapCss = await readFileAsync(`built/web/react-common-skillmap.css`, "utf8");
-    skillmapCss = await linkFontAsync("fa-solid-900", skillmapCss, fontAwesomeSource, "\\.\\.\\/webfonts\\/");
-    skillmapCss = await linkFontAsync("fa-regular-400", skillmapCss, fontAwesomeSource, "\\.\\.\\/webfonts\\/");
-    await writeFileAsync(`built/web/react-common-skillmap.css`, skillmapCss, "utf8");
+    async function generateReactCommonCss(app) {
+        const appFile = isPxtCore ? `react-common/styles/react-common-${app}-core.less` :
+            `node_modules/pxt-core/react-common/styles/react-common-${app}.less`;
+        await nodeutil.spawnAsync({
+            cmd: "node",
+            args: [
+                lessCPath,
+                appFile,
+                `built/web/react-common-${app}.css`,
+                "--include-path=" + lessIncludePaths
+            ]
+        });
+        let appCss = await readFileAsync(`built/web/react-common-${app}.css`, "utf8");
+        appCss = await linkFontAsync("fa-solid-900", appCss, fontAwesomeSource, "\\.\\.\\/webfonts\\/");
+        appCss = await linkFontAsync("fa-regular-400", appCss, fontAwesomeSource, "\\.\\.\\/webfonts\\/");
+        await writeFileAsync(`built/web/react-common-${app}.css`, appCss, "utf8");
+    }
+    // Generate react-common css for skillmap, authcode, and multiplayer
+    await Promise.all([
+        generateReactCommonCss("skillmap"),
+        generateReactCommonCss("authcode"),
+        generateReactCommonCss("multiplayer")
+    ]);
     // Run postcss with autoprefixer and rtlcss
     pxt.debug("running postcss");
     const postcss = require('postcss');
@@ -159660,7 +160748,7 @@ async function buildSemanticUIAsync(parsed) {
         autoprefixer: { browsers: browserList, add: true }
     });
     const rtlcss = require("rtlcss");
-    const files = ["semantic.css", "blockly.css", "react-common-skillmap.css"];
+    const files = ["semantic.css", "blockly.css", "react-common-skillmap.css", "react-common-authcode.css", "react-common-multiplayer.css"];
     for (const cssFile of files) {
         const css = await readFileAsync(`built/web/${cssFile}`, "utf8");
         const processed = await postcss([cssnano])
@@ -159671,9 +160759,13 @@ async function buildSemanticUIAsync(parsed) {
         await writeFileAsync(`built/web/rtl${cssFile}`, processedRtl.css, "utf8");
     }
     if (!isPxtCore) {
-        // This is just to support the local skillmap serve for development
+        // This is just to support the local skillmap/cra-app serve for development
         nodeutil.cp("built/web/react-common-skillmap.css", "node_modules/pxt-core/skillmap/public/blb");
+        nodeutil.cp("built/web/react-common-authcode.css", "node_modules/pxt-core/authcode/public/blb");
+        nodeutil.cp("built/web/react-common-multiplayer.css", "node_modules/pxt-core/multiplayer/public/blb");
         nodeutil.cp("built/web/semantic.css", "node_modules/pxt-core/skillmap/public/blb");
+        nodeutil.cp("built/web/semantic.css", "node_modules/pxt-core/authcode/public/blb");
+        nodeutil.cp("built/web/semantic.css", "node_modules/pxt-core/multiplayer/public/blb");
     }
 }
 async function linkFontAsync(font, semCss, sourceDir = "node_modules/semantic-ui-less/themes/default/assets/fonts/", refDir = "fonts\\/") {
@@ -159692,47 +160784,13 @@ function buildWebStringsAsync() {
     nodeutil.writeFileSync("built/webstrings.json", nodeutil.stringify(webstringsJson()));
     return Promise.resolve();
 }
-function buildSkillMapAsync(parsed) {
+function buildReactAppAsync(app, parsed, opts) {
+    opts = opts || {
+        copyAssets: true
+    };
     // local serve
-    const skillmapRoot = "node_modules/pxt-core/skillmap";
-    const reactScriptsConfigRoot = `${skillmapRoot}/node_modules/react-scripts/config`;
+    const appRoot = `node_modules/pxt-core/${app}`;
     const docsPath = parsed.flags["docs"];
-    return rimrafAsync(`${skillmapRoot}/public/blb`, {})
-        .then(() => rimrafAsync(`${skillmapRoot}/build/assets`, {}))
-        .then(() => rimrafAsync(`${skillmapRoot}/public/docs`, {}))
-        .then(() => rimrafAsync(`${skillmapRoot}/public/static`, {}))
-        .then(() => {
-        // read pxtarget.json, save into 'pxtTargetBundle' global variable
-        let cfg = readLocalPxTarget();
-        nodeutil.writeFileSync(`${skillmapRoot}/public/blb/target.js`, "// eslint-disable-next-line \n" + targetJsPrefix + JSON.stringify(cfg));
-        nodeutil.cp("node_modules/pxt-core/built/pxtlib.js", `${skillmapRoot}/public/blb`);
-        nodeutil.cp("built/web/semantic.css", `${skillmapRoot}/public/blb`);
-        nodeutil.cp("node_modules/pxt-core/built/web/icons.css", `${skillmapRoot}/public/blb`);
-        nodeutil.cp("node_modules/pxt-core/built/web/react-common-skillmap.css", `${skillmapRoot}/public/blb`);
-        // copy 'assets' over from docs/static
-        nodeutil.cpR("docs/static/skillmap/assets", `${skillmapRoot}/public/assets`);
-        // copy default react-scripts webpack config into a webpack.config.base file if necessary
-        if (!fs.existsSync(`${reactScriptsConfigRoot}/webpack.config.base.js`)) {
-            nodeutil.cp(`${reactScriptsConfigRoot}/webpack.config.js`, reactScriptsConfigRoot, "webpack.config.base.js");
-        }
-        // wrap the config in our webpack.config.override for build customization
-        nodeutil.cp(`${skillmapRoot}/webpack.config.override.js`, reactScriptsConfigRoot, "webpack.config.js");
-        if (docsPath) {
-            // copy docs over from specified path
-            nodeutil.cpR(`docs/${docsPath}`, `${skillmapRoot}/public/docs/${docsPath}`);
-            nodeutil.cpR(`docs/static/${docsPath}`, `${skillmapRoot}/public/static/${docsPath}`);
-        }
-        return nodeutil.spawnAsync({
-            cmd: os.platform() === "win32" ? "npm.cmd" : "npm",
-            args: ["run-script", "start"],
-            cwd: skillmapRoot,
-            shell: true
-        });
-    });
-}
-function buildAuthcodeAsync(parsed) {
-    // local serve
-    const appRoot = "node_modules/pxt-core/authcode";
     return rimrafAsync(`${appRoot}/public/blb`, {})
         .then(() => rimrafAsync(`${appRoot}/build/assets`, {}))
         .then(() => rimrafAsync(`${appRoot}/public/docs`, {}))
@@ -159744,9 +160802,16 @@ function buildAuthcodeAsync(parsed) {
         nodeutil.cp("node_modules/pxt-core/built/pxtlib.js", `${appRoot}/public/blb`);
         nodeutil.cp("built/web/semantic.css", `${appRoot}/public/blb`);
         nodeutil.cp("node_modules/pxt-core/built/web/icons.css", `${appRoot}/public/blb`);
-        nodeutil.cp("node_modules/pxt-core/built/web/react-common-authcode.css", `${appRoot}/public/blb`);
-        // copy 'assets' over from docs/static
-        nodeutil.cpR("docs/static/authcode/assets", `${appRoot}/public/assets`);
+        nodeutil.cp(`node_modules/pxt-core/built/web/react-common-${app}.css`, `${appRoot}/public/blb`);
+        if (opts.copyAssets) {
+            // copy 'assets' over from docs/static
+            nodeutil.cpR(`docs/static/${app}/assets`, `${appRoot}/public/assets`);
+        }
+        if (docsPath) {
+            // copy docs over from specified path
+            nodeutil.cpR(`docs/${docsPath}`, `${appRoot}/public/docs/${docsPath}`);
+            nodeutil.cpR(`docs/static/${docsPath}`, `${appRoot}/public/static/${docsPath}`);
+        }
         return nodeutil.spawnAsync({
             cmd: os.platform() === "win32" ? "npm.cmd" : "npm",
             args: ["run-script", "start"],
@@ -159755,6 +160820,15 @@ function buildAuthcodeAsync(parsed) {
         });
     });
 }
+function buildSkillMapAsync(parsed) {
+    return buildReactAppAsync("skillmap", parsed);
+}
+function buildAuthcodeAsync(parsed) {
+    return buildReactAppAsync("authcode", parsed, { copyAssets: false });
+}
+function buildMultiplayerAsync(parsed) {
+    return buildReactAppAsync("multiplayer", parsed, { copyAssets: false });
+}
 function updateDefaultProjects(cfg) {
     let defaultProjects = [
         pxt.BLOCKS_PROJECT_NAME,
@@ -164146,9 +165220,30 @@ ${pxt.crowdin.KEY_VARIABLE} - crowdin key
         flags: {
             serve: {
                 description: "Serve the authcode app locally after building (npm start)"
+            },
+            docs: {
+                description: "Path to local docs folder to copy into authcode",
+                type: "string",
+                argument: "docs"
             }
         }
     }, buildAuthcodeAsync);
+    p.defineCommand({
+        name: "buildmultiplayer",
+        aliases: ["multiplayer", "mp"],
+        advanced: true,
+        help: "Serves the multiplayer webapp",
+        flags: {
+            serve: {
+                description: "Serve the multiplayer app locally after building (npm start)"
+            },
+            docs: {
+                description: "Path to local docs folder to copy into multiplayer",
+                type: "string",
+                argument: "docs"
+            }
+        }
+    }, buildMultiplayerAsync);
     advancedCommand("augmentdocs", "test markdown docs replacements", augmnetDocsAsync, "<temlate.md> <doc.md>");
     advancedCommand("crowdin", "upload, download, clean, stats files to/from crowdin", pc => crowdin.execCrowdinAsync.apply(undefined, pc.args), "<cmd> <path> [output]");
     advancedCommand("hidlist", "list HID devices", hid.listAsync);