sonolus-next-rush-engine 0.1.0

package/dist/usc/convert.js

@@ -0,0 +1,496 @@
+const SONOLUS_DIRECTIONS = {
+    left: 1,
+    up: 0,
+    right: 2,
+};
+const SONOLUS_CONNECTOR_EASES = {
+    outin: 5,
+    out: 3,
+    linear: 1,
+    in: 2,
+    inout: 4,
+};
+const mapUscEaseToSonolusEase = (ease) => {
+    const uscEase = ease ?? 'linear';
+    return uscEase;
+};
+const SONOLUS_GUIDE_COLORS = {
+    neutral: 101,
+    red: 102,
+    green: 103,
+    blue: 104,
+    yellow: 105,
+    purple: 106,
+    cyan: 107,
+    black: 108,
+};
+const EPSILON = 1e-6;
+/** Convert a USC to a Level Data */
+export const uscToLevelData = (usc, offset = 0, smoothGuideFade = false, useGuideLayer = false) => {
+    const allUscObjects = usc.objects ?? [];
+    const allIntermediateEntities = [];
+    const simLineEligibleNotes = [];
+    const timeScaleGroupIntermediates = [];
+    const createIntermediate = (archetype, data, isSimEligible = false) => {
+        const intermediateEntity = { archetype, data };
+        allIntermediateEntities.push(intermediateEntity);
+        if (isSimEligible) {
+            simLineEligibleNotes.push(intermediateEntity);
+        }
+        return intermediateEntity;
+    };
+    createIntermediate('Initialization', {});
+    const bpmChanges = allUscObjects.filter((o) => o.type === 'bpm');
+    const timeScaleGroups = allUscObjects.filter((o) => o.type === 'timeScaleGroup');
+    const singleNotes = allUscObjects.filter((o) => o.type === 'single');
+    const damageNotes = allUscObjects.filter((o) => o.type === 'damage');
+    const slideNotes = allUscObjects.filter((o) => o.type === 'slide' || (o.type === 'guide' && !('midpoints' in o)));
+    const guideNotes = allUscObjects.filter((o) => o.type === 'guide' && 'midpoints' in o);
+    const skills = allUscObjects.filter((o) => o.type === 'skill');
+    const feverChance = allUscObjects
+        .filter((o) => o.type === 'feverChance')
+        .sort((a, b) => a.beat - b.beat)
+        .slice(0, 1);
+    const feverStart = allUscObjects
+        .filter((o) => o.type === 'feverStart')
+        .sort((a, b) => a.beat - b.beat)
+        .slice(0, 1);
+    if (bpmChanges.length === 0) {
+        bpmChanges.push({ type: 'bpm', beat: 0, bpm: 160 });
+    }
+    for (const bpmChange of bpmChanges) {
+        createIntermediate('#BPM_CHANGE', {
+            '#BEAT': bpmChange.beat,
+            '#BPM': bpmChange.bpm,
+        });
+    }
+    if (timeScaleGroups.length === 0) {
+        timeScaleGroups.push({
+            type: 'timeScaleGroup',
+            changes: [{ beat: 0, timeScale: 1 }],
+        });
+    }
+    for (const skill of skills) {
+        createIntermediate('Skill', {
+            '#BEAT': skill.beat,
+        });
+    }
+    for (const fc of feverChance) {
+        createIntermediate('FeverChance', {
+            '#BEAT': fc.beat,
+        });
+    }
+    for (const fs of feverStart) {
+        createIntermediate('FeverStart', {
+            '#BEAT': fs.beat,
+        });
+    }
+    for (const timeScaleGroup of timeScaleGroups) {
+        const groupIntermediateEntity = createIntermediate('#TIMESCALE_GROUP', {});
+        timeScaleGroupIntermediates.push(groupIntermediateEntity);
+        let lastChangeIntermediate = null;
+        const changes = [...timeScaleGroup.changes].sort((a, b) => a.beat - b.beat);
+        for (const timeScaleChange of changes) {
+            const newChangeIntermediate = createIntermediate('#TIMESCALE_CHANGE', {
+                '#BEAT': timeScaleChange.beat,
+                '#TIMESCALE': timeScaleChange.timeScale === 0 ? 0.000001 : timeScaleChange.timeScale,
+                '#TIMESCALE_SKIP': 0,
+                '#TIMESCALE_GROUP': groupIntermediateEntity,
+                '#TIMESCALE_EASE': 0,
+            });
+            if (lastChangeIntermediate === null) {
+                groupIntermediateEntity.data.first = newChangeIntermediate;
+            }
+            else {
+                lastChangeIntermediate.data.next = newChangeIntermediate;
+            }
+            lastChangeIntermediate = newChangeIntermediate;
+        }
+    }
+    for (const singleNote of singleNotes) {
+        const name_parts = [];
+        name_parts.push(singleNote.critical ? 'Critical' : 'Normal');
+        if (singleNote.direction === undefined || singleNote.direction === null) {
+            name_parts.push(singleNote.trace ? 'Trace' : 'Tap');
+        }
+        else {
+            name_parts.push(singleNote.trace ? 'TraceFlick' : 'Flick');
+        }
+        name_parts.push('Note');
+        const archetype = name_parts.join('');
+        const timeScaleGroupRef = timeScaleGroupIntermediates[singleNote.timeScaleGroup ?? 0];
+        let sonolusDirName;
+        if (singleNote.direction === undefined || singleNote.direction === null) {
+            sonolusDirName = 'up';
+        }
+        else {
+            sonolusDirName = singleNote.direction;
+        }
+        const data = {
+            '#BEAT': singleNote.beat,
+            lane: singleNote.lane,
+            size: singleNote.size,
+            isAttached: 0,
+            connectorEase: SONOLUS_CONNECTOR_EASES.linear,
+            isSeparator: 0,
+            segmentKind: singleNote.critical ? 2 : 1,
+            segmentAlpha: 1,
+            '#TIMESCALE_GROUP': timeScaleGroupRef,
+        };
+        const directionValue = SONOLUS_DIRECTIONS[sonolusDirName];
+        if (directionValue !== undefined) {
+            data.direction = directionValue;
+        }
+        createIntermediate(archetype, data, true);
+    }
+    for (const damageNote of damageNotes) {
+        const archetype = 'DamageNote';
+        const timeScaleGroupRef = timeScaleGroupIntermediates[damageNote.timeScaleGroup ?? 0];
+        createIntermediate(archetype, {
+            '#BEAT': damageNote.beat,
+            lane: damageNote.lane,
+            size: damageNote.size,
+            direction: SONOLUS_DIRECTIONS.up,
+            isAttached: 0,
+            connectorEase: SONOLUS_CONNECTOR_EASES.linear,
+            isSeparator: 0,
+            segmentKind: 1,
+            segmentAlpha: 1,
+            '#TIMESCALE_GROUP': timeScaleGroupRef,
+        });
+    }
+    for (const slideNote of slideNotes) {
+        let prevJointIntermediate = null;
+        let prevNoteIntermediate = null;
+        let headNoteIntermediate = null;
+        let currentSegmentHead = null;
+        const queuedAttachIntermediates = [];
+        const connectors = [];
+        const pendingSegmentConnectors = [];
+        const connections = [...slideNote.connections].sort((a, b) => a.beat - b.beat);
+        if (connections.length === 0)
+            continue;
+        const stepSize = Math.max(1, connections.length - 1);
+        let nextHiddenTickBeat = Math.floor(connections[0].beat * 2 + 1) / 2;
+        let stepIdx = 0;
+        for (const connectionNote of connections) {
+            let isSimLineEligible = false;
+            let isAttached = false;
+            const name_parts = [];
+            switch (connectionNote.type) {
+                case 'start':
+                    if (connectionNote.judgeType === 'none') {
+                        name_parts.push('Anchor');
+                    }
+                    else {
+                        name_parts.push(connectionNote.critical ? 'Critical' : 'Normal');
+                        name_parts.push('Head');
+                        if (connectionNote.judgeType === 'trace')
+                            name_parts.push('Trace');
+                        else if (connectionNote.judgeType === 'normal')
+                            name_parts.push('Tap');
+                        isSimLineEligible = true;
+                    }
+                    break;
+                case 'end':
+                    if (connectionNote.judgeType === 'none') {
+                        name_parts.push('Anchor');
+                    }
+                    else {
+                        name_parts.push(connectionNote.critical ? 'Critical' : 'Normal');
+                        name_parts.push('Tail');
+                        if (connectionNote.direction === undefined ||
+                            connectionNote.direction === null) {
+                            if (connectionNote.judgeType === 'trace')
+                                name_parts.push('Trace');
+                            else if (connectionNote.judgeType === 'normal')
+                                name_parts.push('Release');
+                        }
+                        else {
+                            if (connectionNote.judgeType === 'trace')
+                                name_parts.push('TraceFlick');
+                            else if (connectionNote.judgeType === 'normal')
+                                name_parts.push('Flick');
+                        }
+                        isSimLineEligible = true;
+                    }
+                    break;
+                case 'tick':
+                    if (connectionNote.critical !== undefined) {
+                        name_parts.push(connectionNote.critical ? 'Critical' : 'Normal');
+                        if (connectionNote.judgeType === 'trace')
+                            name_parts.push('Trace');
+                        else
+                            name_parts.push('Tick');
+                    }
+                    else {
+                        name_parts.push('Anchor');
+                    }
+                    break;
+                case 'attach':
+                    isAttached = true;
+                    if (connectionNote.critical !== undefined) {
+                        name_parts.push(connectionNote.critical ? 'Critical' : 'Normal');
+                        name_parts.push('Tick');
+                    }
+                    else {
+                        name_parts.push('TransientHiddenTick');
+                    }
+                    break;
+            }
+            name_parts.push('Note');
+            const archetype = name_parts.join('');
+            const timeScaleGroupRef = timeScaleGroupIntermediates[connectionNote.timeScaleGroup ?? 0];
+            let sonolusDirName;
+            const direction = connectionNote.direction;
+            if (direction === undefined || direction === null) {
+                sonolusDirName = 'up';
+            }
+            else {
+                sonolusDirName = direction;
+            }
+            const sonolusEaseValue = SONOLUS_CONNECTOR_EASES[mapUscEaseToSonolusEase('ease' in connectionNote
+                ? connectionNote.ease
+                : undefined)];
+            let segmentAlpha = 1;
+            if (slideNote.type === 'guide') {
+                // 공식: 1 - (0.8 * (현재단계 / 전체구간)) -> 1에서 0.2까지 감소
+                segmentAlpha = 1 - 0.8 * (stepIdx / stepSize);
+            }
+            const isSeparatorValue = slideNote.type == 'slide' ? 0 : 1;
+            const data = {
+                '#BEAT': connectionNote.beat,
+                lane: 'lane' in connectionNote ? connectionNote.lane : 0,
+                size: 'size' in connectionNote ? connectionNote.size : 0,
+                isAttached: isAttached ? 1 : 0,
+                connectorEase: sonolusEaseValue,
+                isSeparator: isSeparatorValue,
+                segmentKind: slideNote.type == 'slide'
+                    ? slideNote.critical
+                        ? 2
+                        : 1
+                    : slideNote.critical
+                        ? 105
+                        : 103,
+                segmentAlpha: segmentAlpha,
+                segmentLayer: slideNote.type == 'slide' ? 0 : 1,
+                '#TIMESCALE_GROUP': timeScaleGroupRef,
+            };
+            const directionValue = SONOLUS_DIRECTIONS[sonolusDirName];
+            if (directionValue !== undefined) {
+                data.direction = directionValue;
+            }
+            const connectionIntermediate = createIntermediate(archetype, data, isSimLineEligible);
+            if (headNoteIntermediate === null) {
+                headNoteIntermediate = connectionIntermediate;
+            }
+            if (currentSegmentHead === null) {
+                currentSegmentHead = connectionIntermediate;
+            }
+            connectionIntermediate.data.activeHead = headNoteIntermediate;
+            if (isAttached) {
+                queuedAttachIntermediates.push(connectionIntermediate);
+            }
+            else {
+                if (prevJointIntermediate !== null) {
+                    for (const attachIntermediate of queuedAttachIntermediates) {
+                        attachIntermediate.data.attachHead = prevJointIntermediate;
+                        attachIntermediate.data.attachTail = connectionIntermediate;
+                    }
+                    queuedAttachIntermediates.length = 0;
+                    while (slideNote.type == 'slide' &&
+                        nextHiddenTickBeat + EPSILON <
+                            connectionIntermediate.data['#BEAT']) {
+                        createIntermediate('TransientHiddenTickNote', {
+                            '#BEAT': nextHiddenTickBeat,
+                            '#TIMESCALE_GROUP': timeScaleGroupIntermediates[0],
+                            lane: connectionIntermediate.data.lane,
+                            size: connectionIntermediate.data.size,
+                            direction: SONOLUS_DIRECTIONS.up,
+                            isAttached: 1,
+                            connectorEase: SONOLUS_CONNECTOR_EASES.linear,
+                            isSeparator: 0,
+                            segmentKind: 1,
+                            segmentAlpha: 0,
+                            activeHead: headNoteIntermediate,
+                            attachHead: prevJointIntermediate,
+                            attachTail: connectionIntermediate,
+                        });
+                        nextHiddenTickBeat += 0.5;
+                    }
+                    const connectorIntermediate = createIntermediate('Connector', {
+                        head: prevJointIntermediate,
+                        tail: connectionIntermediate,
+                    });
+                    connectors.push(connectorIntermediate);
+                    pendingSegmentConnectors.push(connectorIntermediate);
+                }
+                prevJointIntermediate = connectionIntermediate;
+            }
+            if (isSeparatorValue === 1) {
+                for (const conn of pendingSegmentConnectors) {
+                    conn.data.segmentHead = currentSegmentHead;
+                    conn.data.segmentTail = connectionIntermediate;
+                }
+                pendingSegmentConnectors.length = 0;
+                currentSegmentHead = connectionIntermediate;
+            }
+            if (prevNoteIntermediate !== null) {
+                prevNoteIntermediate.data.next = connectionIntermediate;
+            }
+            prevNoteIntermediate = connectionIntermediate;
+            stepIdx++;
+        }
+        if (!headNoteIntermediate || !prevJointIntermediate) {
+            continue;
+        }
+        if (currentSegmentHead) {
+            for (const conn of pendingSegmentConnectors) {
+                conn.data.segmentHead = currentSegmentHead;
+                conn.data.segmentTail = prevJointIntermediate;
+            }
+        }
+        if (slideNote.type === 'slide') {
+            for (const connectorIntermediate of connectors) {
+                connectorIntermediate.data.activeHead = headNoteIntermediate;
+                connectorIntermediate.data.activeTail = prevJointIntermediate;
+            }
+        }
+    }
+    for (const guideNote of guideNotes) {
+        const connections = [...guideNote.midpoints].sort((a, b) => a.beat - b.beat);
+        let prevMidpointIntermediate = null;
+        let headMidpointIntermediate = null;
+        const guideConnectors = [];
+        const stepSize = Math.max(1, connections.length - 1);
+        let stepIdx = 0;
+        for (const midpointNote of connections) {
+            const timeScaleGroupRef = timeScaleGroupIntermediates[midpointNote.timeScaleGroup ?? 0];
+            let segmentAlpha = 1;
+            let isSeparator = 0;
+            if (smoothGuideFade) {
+                isSeparator = 1;
+                if (guideNote.fade === 'out') {
+                    segmentAlpha = 1 - 0.8 * (stepIdx / stepSize);
+                }
+                else if (guideNote.fade === 'in') {
+                    segmentAlpha = 1 - 0.8 * ((stepSize - stepIdx) / stepSize);
+                }
+            }
+            const midpointIntermediate = createIntermediate('AnchorNote', {
+                '#BEAT': midpointNote.beat,
+                lane: midpointNote.lane,
+                size: midpointNote.size,
+                direction: SONOLUS_DIRECTIONS.up,
+                isAttached: 0,
+                connectorEase: SONOLUS_CONNECTOR_EASES[mapUscEaseToSonolusEase(midpointNote.ease)],
+                isSeparator: isSeparator,
+                segmentKind: SONOLUS_GUIDE_COLORS[guideNote.color],
+                segmentAlpha: segmentAlpha,
+                segmentLayer: useGuideLayer ? 1 : 0,
+                '#TIMESCALE_GROUP': timeScaleGroupRef,
+            });
+            if (headMidpointIntermediate === null) {
+                headMidpointIntermediate = midpointIntermediate;
+            }
+            if (prevMidpointIntermediate !== null) {
+                const connectorIntermediate = createIntermediate('Connector', {
+                    head: prevMidpointIntermediate,
+                    tail: midpointIntermediate,
+                });
+                guideConnectors.push(connectorIntermediate);
+                prevMidpointIntermediate.data.next = midpointIntermediate;
+            }
+            prevMidpointIntermediate = midpointIntermediate;
+            stepIdx++;
+        }
+        if (!headMidpointIntermediate || !prevMidpointIntermediate) {
+            continue;
+        }
+        for (const connectorIntermediate of guideConnectors) {
+            connectorIntermediate.data.segmentHead = headMidpointIntermediate;
+            connectorIntermediate.data.segmentTail = prevMidpointIntermediate;
+        }
+        if (!smoothGuideFade) {
+            switch (guideNote.fade) {
+                case 'in':
+                    if (headMidpointIntermediate) {
+                        headMidpointIntermediate.data.segmentAlpha = 0;
+                    }
+                    break;
+                case 'out':
+                    if (prevMidpointIntermediate) {
+                        prevMidpointIntermediate.data.segmentAlpha = 0;
+                    }
+                    break;
+                case 'none':
+                    break;
+            }
+        }
+    }
+    simLineEligibleNotes.sort((noteA, noteB) => {
+        const beatA = noteA.data['#BEAT'];
+        const beatB = noteB.data['#BEAT'];
+        if (beatA !== beatB)
+            return beatA - beatB;
+        const laneA = noteA.data.lane;
+        const laneB = noteB.data.lane;
+        return laneA - laneB;
+    });
+    const simGroups = [];
+    let currentSimGroup = [];
+    for (const simNote of simLineEligibleNotes) {
+        if (currentSimGroup.length === 0 ||
+            Math.abs(simNote.data['#BEAT'] - currentSimGroup[0].data['#BEAT']) < 1e-2) {
+            currentSimGroup.push(simNote);
+        }
+        else {
+            simGroups.push(currentSimGroup);
+            currentSimGroup = [simNote];
+        }
+    }
+    if (currentSimGroup.length > 0) {
+        simGroups.push(currentSimGroup);
+    }
+    for (const simGroup of simGroups) {
+        for (let i = 0; i < simGroup.length - 1; i++) {
+            const leftNote = simGroup[i];
+            const rightNote = simGroup[i + 1];
+            createIntermediate('SimLine', {
+                left: leftNote,
+                right: rightNote,
+            });
+        }
+    }
+    const entities = [];
+    const intermediateToRef = new Map();
+    let entityRefCounter = 0;
+    const getRef = (intermediateEntity) => {
+        let ref = intermediateToRef.get(intermediateEntity);
+        if (ref)
+            return ref;
+        ref = (entityRefCounter++).toString(16);
+        intermediateToRef.set(intermediateEntity, ref);
+        return ref;
+    };
+    for (const intermediateEntity of allIntermediateEntities) {
+        const entity = {
+            archetype: intermediateEntity.archetype,
+            name: getRef(intermediateEntity),
+            data: [],
+        };
+        for (const [dataName, dataValue] of Object.entries(intermediateEntity.data)) {
+            if (typeof dataValue === 'number') {
+                entity.data.push({ name: dataName, value: dataValue });
+            }
+            else if (dataValue !== undefined) {
+                entity.data.push({ name: dataName, ref: getRef(dataValue) });
+            }
+        }
+        entities.push(entity);
+    }
+    return {
+        bgmOffset: usc.offset + offset,
+        entities,
+    };
+};

package/dist/usc/index.d.ts

@@ -0,0 +1,112 @@
+export interface USC {
+    offset: number;
+    objects: USCObject[];
+}
+export type USCObject = USCBpmChange | USCTimeScaleChange | USCSingleNote | USCSlideNote | USCGuideNote | USCDamageNote | USCSkill | USCFever;
+interface BaseUSCObject {
+    beat: number;
+    timeScaleGroup: number;
+}
+export type USCBpmChange = Omit<BaseUSCObject, 'timeScaleGroup'> & {
+    type: 'bpm';
+    bpm: number;
+};
+export interface USCTimeScaleChange {
+    type: 'timeScaleGroup';
+    changes: {
+        beat: number;
+        timeScale: number;
+    }[];
+}
+type BaseUSCNote = BaseUSCObject & {
+    lane: number;
+    size: number;
+};
+export type USCSingleNote = BaseUSCNote & {
+    type: 'single';
+    critical: boolean;
+    trace: boolean;
+    direction?: 'left' | 'up' | 'right' | 'none';
+};
+export type USCDamageNote = BaseUSCNote & {
+    type: 'damage';
+};
+export type USCConnectionStartNote = BaseUSCNote & {
+    type: 'start';
+    critical: boolean;
+    ease: 'out' | 'linear' | 'in' | 'inout' | 'outin';
+    judgeType: 'normal' | 'trace' | 'none';
+};
+export type USCConnectionTickNote = BaseUSCNote & {
+    type: 'tick';
+    critical?: boolean;
+    ease: 'out' | 'linear' | 'in' | 'inout' | 'outin';
+    judgeType?: 'normal' | 'trace';
+};
+export type USCConnectionAttachNote = Omit<BaseUSCObject, 'timeScaleGroup'> & {
+    type: 'attach';
+    critical?: boolean;
+    timeScaleGroup?: number;
+};
+export type USCConnectionEndNote = BaseUSCNote & {
+    type: 'end';
+    critical: boolean;
+    direction?: 'left' | 'up' | 'right';
+    judgeType: 'normal' | 'trace' | 'none';
+};
+export interface USCSlideNote {
+    type: 'slide' | 'guide';
+    critical: boolean;
+    connections: [
+        USCConnectionStartNote,
+        ...(USCConnectionTickNote | USCConnectionAttachNote)[],
+        USCConnectionEndNote
+    ];
+}
+export declare const USCColor: {
+    neutral: number;
+    red: number;
+    green: number;
+    blue: number;
+    yellow: number;
+    purple: number;
+    cyan: number;
+    black: number;
+};
+export type USCColor = keyof typeof USCColor;
+export type USCGuideMidpointNote = BaseUSCNote & {
+    ease: 'out' | 'linear' | 'in' | 'inout' | 'outin';
+};
+export declare const USCFade: {
+    in: number;
+    out: number;
+    none: number;
+};
+export type USCFade = keyof typeof USCFade;
+export interface USCGuideNote {
+    type: 'guide';
+    color: USCColor;
+    fade: USCFade;
+    midpoints: USCGuideMidpointNote[];
+}
+export declare const SkillEffects: {
+    readonly none: 0;
+    readonly heal: 1;
+    readonly score: 2;
+    readonly judgment: 3;
+};
+export type SkillEffects = (typeof SkillEffects)[keyof typeof SkillEffects];
+type Level = 1 | 2 | 3 | 4;
+interface USCEvent {
+    beat: number;
+}
+export type USCSkill = USCEvent & {
+    type: 'skill';
+    effect?: SkillEffects;
+    level?: Level;
+};
+export type USCFever = USCEvent & {
+    type: 'feverChance' | 'feverStart';
+    force?: boolean;
+};
+export {};

package/dist/usc/index.js

@@ -0,0 +1,21 @@
+export const USCColor = {
+    neutral: 0,
+    red: 1,
+    green: 2,
+    blue: 3,
+    yellow: 4,
+    purple: 5,
+    cyan: 6,
+    black: 7,
+};
+export const USCFade = {
+    in: 2,
+    out: 0,
+    none: 1,
+};
+export const SkillEffects = {
+    none: 0,
+    heal: 1,
+    score: 2,
+    judgment: 3,
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "sonolus-next-rush-engine",
+  "version": "0.1.0",
+  "description": "Perspective-lane rhythm game for Sonolus",
+  "author": "Hyeon2",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/UntitledCharts/sonolus-next-rush-engine.git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "Sonolus"
+  ],
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./EngineConfiguration": "./dist/EngineConfiguration",
+    "./EnginePlayData": "./dist/EnginePlayData",
+    "./EngineWatchData": "./dist/EngineWatchData",
+    "./EnginePreviewData": "./dist/EnginePreviewData",
+    "./EngineTutorialData": "./dist/EngineTutorialData",
+    "./EngineRom": "./dist/EngineRom",
+    "./EngineThumbnail": "./dist/thumbnail.png"
+  },
+  "scripts": {
+    "check-type": "tsc -p . --noEmit",
+    "check-lint": "biome lint",
+    "check-format": "biome format",
+    "biome": "biome check",
+    "format": "biome format --write",
+    "fix": "biome check --write",
+    "version": "node ./version.js",
+    "build": "tsc -p . && node ./build.js"
+  },
+  "dependencies": {
+    "@sonolus/core": "~7.15.1"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "~2.4.14",
+    "@sonolus/sonolus.js": "~9.7.1",
+    "@types/node": "^25.6.2",
+    "typescript": "~6.0.3"
+  }
+}