Merge pull request #407 from bcorfman/musicfix

Another audio fix

Author: bcorfman

src/cloud/assetUrls.ts

@@ -3,6 +3,7 @@ import { resolveProjectAssetPathToUrl } from '../assets/projectAssetPaths';
 import { resolveApiUrl } from './api';
 
 const cloudAssetUrlCache = new Map<string, Promise<string | null>>();
+const pathAudioUrlCache = new Map<string, Promise<string>>();
 
 function cloudAssetContentUrl(assetId: string): string {
   return resolveApiUrl(`/api/v1/assets/${encodeURIComponent(assetId)}/content`);
@@ -27,7 +28,26 @@ export function inlinePreviewUrlForAssetSource(source: AssetFileSource): string
 
 export async function resolveAssetSourceUrl(source: AssetFileSource): Promise<string | null> {
   if (source.kind === 'embedded') return source.dataUrl;
-  if (source.kind === 'path') return resolveProjectAssetPathToUrl(source.path);
+  if (source.kind === 'path') {
+    const directUrl = resolveProjectAssetPathToUrl(source.path);
+    if (!source.mimeType?.startsWith('audio/')) return directUrl;
+
+    let pending = pathAudioUrlCache.get(source.path);
+    if (!pending) {
+      pending = (async () => {
+        try {
+          const res = await fetch(directUrl, { cache: 'force-cache' });
+          if (!res.ok) return directUrl;
+          const blob = await res.blob();
+          return URL.createObjectURL(blob);
+        } catch {
+          return directUrl;
+        }
+      })();
+      pathAudioUrlCache.set(source.path, pending);
+    }
+    return pending;
+  }
 
   let pending = cloudAssetUrlCache.get(source.assetId);
   if (!pending) {

src/phaser/EditorScene.ts

@@ -1589,6 +1589,7 @@ export class EditorScene extends Phaser.Scene {
           pending = (async () => {
             const url = await resolveAssetSourceUrl(asset.source);
             if (!url || asset.source.kind !== 'path') return;
+            if (url.startsWith('blob:')) return;
             const response = await fetch(url, { cache: 'force-cache' });
             if (!response.ok) return;
             await response.blob();

src/runtime/services/BasicAudioService.ts

@@ -19,6 +19,16 @@ export interface SoundManagerLike {
   removeByKey?(key: string): void;
 }
 
+type AudioContextLike = {
+  state?: string;
+  resume?: () => Promise<unknown> | unknown;
+};
+
+type UnlockableSoundManagerLike = SoundManagerLike & {
+  context?: AudioContextLike;
+  unlock?: () => void;
+};
+
 function clamp01(value: number): number {
   if (!Number.isFinite(value)) return 1;
   return Math.max(0, Math.min(1, value));
@@ -33,7 +43,25 @@ export class BasicAudioService implements AudioService {
     private readonly getKey: (assetId: string) => string = (assetId) => `audio:${assetId}`,
   ) {}
 
+  private resumeManagerIfNeeded(): void {
+    const manager = this.manager as UnlockableSoundManagerLike;
+    try {
+      manager.unlock?.();
+    } catch {
+      // ignore unlock errors
+    }
+    const context = manager.context;
+    if (!context?.resume) return;
+    if (context.state && context.state !== 'suspended' && context.state !== 'interrupted') return;
+    try {
+      void context.resume();
+    } catch {
+      // ignore resume errors
+    }
+  }
+
   public playMusic(assetId: string, options: { loop?: boolean; volume?: number; fadeMs?: number } = {}): void {
+    this.resumeManagerIfNeeded();
     const loop = options.loop ?? true;
     const volume = clamp01(options.volume ?? 1);
     const fadeMs = Number.isFinite(Number(options.fadeMs)) ? Math.max(0, Number(options.fadeMs)) : 0;
@@ -101,6 +129,7 @@ export class BasicAudioService implements AudioService {
   }
 
   public playSfx(assetId: string, options: { volume?: number } = {}): void {
+    this.resumeManagerIfNeeded();
     const volume = clamp01(options.volume ?? 1);
     const key = this.getKey(assetId);
     try {

tests/cloud/asset-urls.test.ts

@@ -1,8 +1,12 @@
-import { describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { inlinePreviewUrlForAssetSource, resolveAssetSourceUrl } from '../../src/cloud/assetUrls';
 
 describe('asset URL helpers', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   it('resolves project-relative path assets to usable browser URLs', async () => {
     const source = {
       kind: 'path' as const,
@@ -17,4 +21,22 @@ describe('asset URL helpers', () => {
     expect(inlineUrl).toContain('enemy_A.png');
     expect(resolvedUrl).toContain('enemy_A.png');
   });
+
+  it('resolves path-backed audio assets to blob URLs for runtime playback', async () => {
+    const fetchMock = vi.fn(async () => new Response(new Blob(['mp3'], { type: 'audio/mpeg' }), { status: 200 }));
+    vi.stubGlobal('fetch', fetchMock);
+    const createObjectUrl = vi.fn(() => 'blob:demo-pack-theme');
+    vi.spyOn(URL, 'createObjectURL').mockImplementation(createObjectUrl);
+
+    const resolvedUrl = await resolveAssetSourceUrl({
+      kind: 'path',
+      path: 'assets/demo-pack/audio/Simulacra-chosic.com_.mp3',
+      originalName: 'Simulacra-chosic.com_.mp3',
+      mimeType: 'audio/mpeg',
+    });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(createObjectUrl).toHaveBeenCalledTimes(1);
+    expect(resolvedUrl).toBe('blob:demo-pack-theme');
+  });
 });

tests/runtime/audio-service.test.ts

@@ -146,6 +146,36 @@ describe('BasicAudioService', () => {
     expect(sound?.playCount).toBeGreaterThanOrEqual(2);
   });
 
+  it('resumes a suspended audio context before starting music playback', () => {
+    const sound = new FakeSound();
+    let resumeCalls = 0;
+    const context = {
+      state: 'suspended',
+      resume() {
+        resumeCalls += 1;
+        context.state = 'running';
+        return Promise.resolve();
+      },
+    };
+    const manager: SoundManagerLike = {
+      add() {
+        if (context.state === 'suspended') throw new Error('audio context is suspended');
+        return sound;
+      },
+      removeByKey() {},
+      context,
+    } as SoundManagerLike & { context: typeof context };
+
+    const svc = new BasicAudioService(manager, (id) => `audio:${id}`);
+    const project = { audio: { sounds: { a: { id: 'a', source: { kind: 'embedded', dataUrl: 'data:audio/mp3;base64,AAAA', originalName: 'a.mp3', mimeType: 'audio/mpeg' } } } } } as any;
+
+    svc.applySceneAudio({ music: { assetId: 'a', loop: true, volume: 1, fadeMs: 0 } } as any, project);
+
+    expect(resumeCalls).toBe(1);
+    expect(context.state).toBe('running');
+    expect(sound.isPlaying).toBe(true);
+  });
+
   it('retries ambience playback when the first attempt fails', () => {
     let shouldThrow = true;
     const sounds = new Map<string, FakeSound>();