refactor(animation): rename beatsPerFrame to frameDurationBeats for clarity and consistency

KristofferKarlAxelEkstrand · KristofferKarlAxelEkstrand · commit 7823d36c2483 · 2025-12-14T20:58:27.000Z
diff --git a/animations/0/0/0/meta.json b/animations/0/0/0/meta.json
@@ -4,5 +4,5 @@
 	"framesPerRow": 8,
 	"loop": true,
 	"retrigger": true,
-	"beatsPerFrame": 0.5
+	"frameDurationBeats": 0.5
 }
diff --git a/animations/0/1/0/meta.json b/animations/0/1/0/meta.json
@@ -4,5 +4,5 @@
 	"framesPerRow": 8,
 	"loop": true,
 	"retrigger": true,
-	"beatsPerFrame": 0.5
+	"frameDurationBeats": 0.5
 }
diff --git a/animations/0/2/0/meta.json b/animations/0/2/0/meta.json
@@ -4,5 +4,5 @@
 	"framesPerRow": 8,
 	"loop": true,
 	"retrigger": true,
-	"beatsPerFrame": 2
+	"frameDurationBeats": 2
 }
diff --git a/animations/4/0/0/meta.json b/animations/4/0/0/meta.json
@@ -4,5 +4,5 @@
 	"framesPerRow": 8,
 	"loop": true,
 	"retrigger": true,
-	"beatsPerFrame": 0.25
+	"frameDurationBeats": 0.25
 }
diff --git a/animations/5/0/0/meta.json b/animations/5/0/0/meta.json
@@ -4,5 +4,5 @@
 	"framesPerRow": 8,
 	"loop": true,
 	"retrigger": true,
-	"beatsPerFrame": 0.5
+	"frameDurationBeats": 0.5
 }
diff --git a/scripts/animations/lib/generate.js b/scripts/animations/lib/generate.js
@@ -66,13 +66,13 @@ export async function generate(sourceDir, outputPath) {
 					entry.bitDepth = metadata.bitDepth;
 				}
 
-				// Ensure beatsPerFrame is included if specified (for BPM sync)
-				if (metadata.beatsPerFrame !== undefined) {
-					entry.beatsPerFrame = metadata.beatsPerFrame;
+				// Ensure frameDurationBeats is included if specified (for BPM sync)
+				if (metadata.frameDurationBeats !== undefined) {
+					entry.frameDurationBeats = metadata.frameDurationBeats;
 				}
 
 				output[channel][note][velocity] = entry;
-				console.log(`    Velocity ${velocity}: ${pngFile || '(no png)'}${metadata.bitDepth ? ` (${metadata.bitDepth}-bit)` : ''}${metadata.beatsPerFrame ? ' (BPM sync)' : ''}`);
+				console.log(`    Velocity ${velocity}: ${pngFile || '(no png)'}${metadata.bitDepth ? ` (${metadata.bitDepth}-bit)` : ''}${metadata.frameDurationBeats ? ' (BPM sync)' : ''}`);
 			}
 		}
 	}
diff --git a/scripts/animations/lib/validate.js b/scripts/animations/lib/validate.js
@@ -131,32 +131,32 @@ async function validateAnimation(animationDir, animationPath) {
 			}
 		}
 
-		// Validate beatsPerFrame - must be positive number or array of positive numbers matching numberOfFrames
-		if (meta.beatsPerFrame !== undefined) {
-			if (Array.isArray(meta.beatsPerFrame)) {
+		// Validate frameDurationBeats - must be positive number or array of positive numbers matching numberOfFrames
+		if (meta.frameDurationBeats !== undefined) {
+			if (Array.isArray(meta.frameDurationBeats)) {
 				// Check for empty array (AnimationLayer will warn and fall back, but we should catch it here)
-				if (meta.beatsPerFrame.length === 0) {
-					errors.push('meta.json: beatsPerFrame array cannot be empty');
+				if (meta.frameDurationBeats.length === 0) {
+					errors.push('meta.json: frameDurationBeats array cannot be empty');
 				}
 				// Array form - must match numberOfFrames length and all values must be positive
-				if (meta.numberOfFrames && meta.beatsPerFrame.length > 0 && meta.beatsPerFrame.length !== meta.numberOfFrames) {
-					errors.push(`meta.json: beatsPerFrame array length (${meta.beatsPerFrame.length}) must match numberOfFrames (${meta.numberOfFrames})`);
+				if (meta.numberOfFrames && meta.frameDurationBeats.length > 0 && meta.frameDurationBeats.length !== meta.numberOfFrames) {
+					errors.push(`meta.json: frameDurationBeats array length (${meta.frameDurationBeats.length}) must match numberOfFrames (${meta.numberOfFrames})`);
 				}
-				for (let i = 0; i < meta.beatsPerFrame.length; i++) {
-					const val = meta.beatsPerFrame[i];
+				for (let i = 0; i < meta.frameDurationBeats.length; i++) {
+					const val = meta.frameDurationBeats[i];
 					if (typeof val !== 'number') {
-						errors.push(`meta.json: beatsPerFrame[${i}] must be a number (got ${typeof val})`);
+						errors.push(`meta.json: frameDurationBeats[${i}] must be a number (got ${typeof val})`);
 					} else if (val <= 0) {
-						errors.push(`meta.json: beatsPerFrame[${i}] must be a positive number (got ${val})`);
+						errors.push(`meta.json: frameDurationBeats[${i}] must be a positive number (got ${val})`);
 					}
 				}
-			} else if (typeof meta.beatsPerFrame === 'number') {
+			} else if (typeof meta.frameDurationBeats === 'number') {
 				// Shorthand form - single positive number applies to all frames
-				if (meta.beatsPerFrame <= 0) {
-					errors.push(`meta.json: beatsPerFrame must be a positive number (got ${meta.beatsPerFrame})`);
+				if (meta.frameDurationBeats <= 0) {
+					errors.push(`meta.json: frameDurationBeats must be a positive number (got ${meta.frameDurationBeats})`);
 				}
 			} else {
-				errors.push('meta.json: beatsPerFrame must be a positive number or array of positive numbers');
+				errors.push('meta.json: frameDurationBeats must be a positive number or array of positive numbers');
 			}
 		}
 
diff --git a/src/js/core/AdventureKidVideoJockey.js b/src/js/core/AdventureKidVideoJockey.js
@@ -92,16 +92,32 @@ class AdventureKidVideoJockey extends HTMLElement {
 	}
 
 	disconnectedCallback() {
+		// Use individual try-catch blocks so one failure doesn't prevent other cleanup
 		try {
 			this.#teardownMIDIEventListeners();
+		} catch (error) {
+			console.error('Error tearing down MIDI event listeners:', error);
+		}
+
+		try {
 			this.#renderer?.stop();
 			this.#renderer?.destroy();
+		} catch (error) {
+			console.error('Error destroying renderer:', error);
+		}
+
+		try {
 			this.#layerManager?.clearLayers();
 			this.#layerManager?.destroy();
+		} catch (error) {
+			console.error('Error destroying layer manager:', error);
+		}
+
+		try {
 			this.#animationLoader?.cleanup(this.#animations);
 			this.#animations = {};
 		} catch (error) {
-			console.error('Error during AdventureKidVideoJockey cleanup in disconnectedCallback:', error);
+			console.error('Error cleaning up animation loader:', error);
 		}
 	}
 
diff --git a/src/js/visuals/AnimationLayer.js b/src/js/visuals/AnimationLayer.js
@@ -4,7 +4,7 @@
  *
  * Supports two timing modes:
  * 1. frameRatesForFrames (FPS) - Frame timing in frames-per-second (default)
- * 2. beatsPerFrame (BPM sync) - Frame timing in beats, synced to current BPM
+ * 2. frameDurationBeats (BPM sync) - Frame timing in beats, synced to current BPM
  *    When MIDI clock is active, uses real-time clock pulses (24 PPQN)
  *    When no clock, falls back to time-based BPM calculation
  */
@@ -18,7 +18,7 @@ class AnimationLayer {
 	#numberOfFrames;
 	#framesPerRow;
 	#frameRatesForFrames;
-	#beatsPerFrame; // Array or single number for BPM sync
+	#frameDurationBeats; // Array or single number for BPM sync
 	#frameWidth;
 	#frameHeight;
 	#loop;
@@ -35,11 +35,11 @@ class AnimationLayer {
 	#isFinished = false;
 	#defaultFrameRate; // Cached fallback rate when frame-specific rate is undefined
 	#useBPMSync = false; // Whether to use BPM sync mode
-	#pulsesPerFrame; // Array of pulses per frame for clock sync (derived from beatsPerFrame)
+	#pulsesPerFrame; // Array of pulses per frame for clock sync (derived from frameDurationBeats)
 	#pulseCount = 0; // Accumulated clock pulses since last frame advance
 	#unsubscribeClock = null; // Cleanup for clock subscription
 
-	constructor({ canvas2dContext, image, numberOfFrames, framesPerRow, loop = true, frameRatesForFrames = { 0: 1 }, beatsPerFrame = null, retrigger = true, bitDepth = null }) {
+	constructor({ canvas2dContext, image, numberOfFrames, framesPerRow, loop = true, frameRatesForFrames = { 0: 1 }, frameDurationBeats = null, retrigger = true, bitDepth = null }) {
 		if (!numberOfFrames || numberOfFrames < 1) {
 			throw new Error('AnimationLayer requires numberOfFrames >= 1');
 		}
@@ -53,26 +53,26 @@ class AnimationLayer {
 		this.#framesPerRow = framesPerRow;
 		this.#bitDepth = bitDepth;
 
-		// Process beatsPerFrame - supports both clock sync and time-based BPM sync
+		// Process frameDurationBeats - supports both clock sync and time-based BPM sync
 		// When MIDI clock is active, uses clock pulses for real-time sync (24 PPQN)
 		// When no clock, falls back to time-based BPM calculation
-		if (beatsPerFrame !== null && beatsPerFrame !== undefined) {
+		if (frameDurationBeats !== null && frameDurationBeats !== undefined) {
 			this.#useBPMSync = true;
 
-			if (Array.isArray(beatsPerFrame)) {
+			if (Array.isArray(frameDurationBeats)) {
 				// Enforce strict array length equal to numberOfFrames
-				if (beatsPerFrame.length !== numberOfFrames) {
-					throw new Error(`AnimationLayer: beatsPerFrame array length (${beatsPerFrame.length}) must equal numberOfFrames (${numberOfFrames})`);
+				if (frameDurationBeats.length !== numberOfFrames) {
+					throw new Error(`AnimationLayer: frameDurationBeats array length (${frameDurationBeats.length}) must equal numberOfFrames (${numberOfFrames})`);
 				}
-				this.#beatsPerFrame = beatsPerFrame;
+				this.#frameDurationBeats = frameDurationBeats;
 				// Pre-calculate pulsesPerFrame for when clock is active (24 PPQN)
-				this.#pulsesPerFrame = beatsPerFrame.map(b => Math.round(b * 24));
-			} else if (typeof beatsPerFrame === 'number' && beatsPerFrame > 0) {
+				this.#pulsesPerFrame = frameDurationBeats.map(b => Math.round(b * 24));
+			} else if (typeof frameDurationBeats === 'number' && frameDurationBeats > 0) {
 				// Shorthand: single number applies to all frames
-				this.#beatsPerFrame = Array(numberOfFrames).fill(beatsPerFrame);
-				this.#pulsesPerFrame = Array(numberOfFrames).fill(Math.round(beatsPerFrame * 24));
+				this.#frameDurationBeats = Array(numberOfFrames).fill(frameDurationBeats);
+				this.#pulsesPerFrame = Array(numberOfFrames).fill(Math.round(frameDurationBeats * 24));
 			} else {
-				throw new Error('AnimationLayer: invalid beatsPerFrame');
+				throw new Error('AnimationLayer: invalid frameDurationBeats');
 			}
 
 			// Subscribe to MIDI clock events for real-time sync when clock is active
@@ -149,12 +149,12 @@ class AnimationLayer {
 
 	/**
 	 * Advance the animation frame based on elapsed time
-	 * Uses BPM sync if beatsPerFrame is defined, otherwise uses frameRatesForFrames
+	 * Uses BPM sync if frameDurationBeats is defined, otherwise uses frameRatesForFrames
 	 * Clock sync mode skips time-based advancement (pulses drive frames directly)
 	 * @param {number} timestamp - Current timestamp
 	 */
 	#advanceFrame(timestamp) {
-		// When clock is active and we have beatsPerFrame, let pulses drive frames
+		// When clock is active and we have frameDurationBeats, let pulses drive frames
 		if (this.#useBPMSync && this.#pulsesPerFrame && appState.bpmSource === 'clock') {
 			return;
 		}
@@ -213,16 +213,16 @@ class AnimationLayer {
 
 	/**
 	 * Calculate the interval (ms) for a given frame
-	 * Uses BPM sync if beatsPerFrame is defined, otherwise uses frameRatesForFrames
+	 * Uses BPM sync if frameDurationBeats is defined, otherwise uses frameRatesForFrames
 	 * @param {number} frameIndex - The frame index
 	 * @returns {number} - Interval in milliseconds
 	 */
 	#getFrameInterval(frameIndex) {
-		if (this.#useBPMSync && this.#beatsPerFrame) {
-			// BPM sync mode: interval = (beatsPerFrame * 60000) / bpm
-			// beatsPerFrame[i] = number of beats this frame should last
-			// e.g., beatsPerFrame=0.25 at 120 BPM = 125ms (16th note)
-			const beats = this.#beatsPerFrame[frameIndex] ?? this.#beatsPerFrame[0] ?? 0.25;
+		if (this.#useBPMSync && this.#frameDurationBeats) {
+			// BPM sync mode: interval = (frameDurationBeats * 60000) / bpm
+			// frameDurationBeats[i] = number of beats this frame should last
+			// e.g., frameDurationBeats=0.25 at 120 BPM = 125ms (16th note)
+			const beats = this.#frameDurationBeats[frameIndex] ?? this.#frameDurationBeats[0] ?? 0.25;
 			// Ensure BPM is at least the configured minimum to prevent extremely long intervals.
 			// Fallback to 1 if settings.bpm.min is 0 or invalid to prevent division by zero.
 			const minBPM = settings.bpm.min > 0 ? settings.bpm.min : 1;
diff --git a/src/js/visuals/AnimationLoader.js b/src/js/visuals/AnimationLoader.js
@@ -78,7 +78,7 @@ class AnimationLoader {
 				framesPerRow: animationData.framesPerRow,
 				loop: animationData.loop,
 				frameRatesForFrames: animationData.frameRatesForFrames,
-				beatsPerFrame: animationData.beatsPerFrame ?? null,
+				frameDurationBeats: animationData.frameDurationBeats ?? null,
 				retrigger: animationData.retrigger,
 				bitDepth: animationData.bitDepth ?? null
 			});
diff --git a/src/js/visuals/Renderer.js b/src/js/visuals/Renderer.js
@@ -126,6 +126,9 @@ class Renderer {
 		this.#ctxMask = null;
 		this.#canvasMixed = null;
 		this.#ctxMixed = null;
+		// Release large typed arrays to help GC
+		this.#outputImageData = null;
+		this.#scratchBuffer = null;
 	}
 
 	/**
diff --git a/test/AnimationLayer.test.js b/test/AnimationLayer.test.js
@@ -38,7 +38,7 @@ describe('AnimationLayer', () => {
 		vi.restoreAllMocks();
 	});
 
-	test('beatsPerFrame array controls per-frame timing and falls back to first element', () => {
+	test('frameDurationBeats array controls per-frame timing and falls back to first element', () => {
 		// Create a fake context that captures drawImage sx value
 		let lastSx = null;
 		const ctx = {
@@ -50,13 +50,13 @@ describe('AnimationLayer', () => {
 		const image = { width: 30, height: 10 }; // frameWidth = 10
 
 		// numberOfFrames = 3, framesPerRow = 3
-		// Provide a beatsPerFrame array with explicit per-frame values
+		// Provide a frameDurationBeats array with explicit per-frame values
 		const layer = new AnimationLayer({
 			canvas2dContext: ctx,
 			image,
 			numberOfFrames: 3,
 			framesPerRow: 3,
-			beatsPerFrame: [0.25, 0.5, 0.25],
+			frameDurationBeats: [0.25, 0.5, 0.25],
 			loop: false
 		});
 
@@ -72,18 +72,18 @@ describe('AnimationLayer', () => {
 		layer.playToContext(ctx, 375);
 		expect(lastSx).toBe(20);
 
-		// If beatsPerFrame array length doesn't match numberOfFrames, constructor should throw
+		// If frameDurationBeats array length doesn't match numberOfFrames, constructor should throw
 		expect(
 			() =>
 				new AnimationLayer({
 					canvas2dContext: ctx,
 					image,
 					numberOfFrames: 4,
 					framesPerRow: 4,
-					beatsPerFrame: [0.25, 0.5],
+					frameDurationBeats: [0.25, 0.5],
 					loop: false
 				})
-		).toThrow('beatsPerFrame array length');
+		).toThrow('frameDurationBeats array length');
 	});
 
 	describe('constructor', () => {
@@ -405,8 +405,8 @@ describe('AnimationLayer', () => {
 		});
 	});
 
-	describe('BPM sync mode (beatsPerFrame)', () => {
-		test('accepts beatsPerFrame as single number and uses BPM sync', async () => {
+	describe('BPM sync mode (frameDurationBeats)', () => {
+		test('accepts frameDurationBeats as single number and uses BPM sync', async () => {
 			const ctx = createMockContext();
 			// Import appState to set BPM
 			const appState = (await import('../src/js/core/AppState.js')).default;
@@ -417,7 +417,7 @@ describe('AnimationLayer', () => {
 					canvas2dContext: ctx,
 					numberOfFrames: 4,
 					framesPerRow: 4,
-					beatsPerFrame: 0.5 // Half beat per frame = 250ms at 120 BPM
+					frameDurationBeats: 0.5 // Half beat per frame = 250ms at 120 BPM
 				})
 			);
 
@@ -435,7 +435,7 @@ describe('AnimationLayer', () => {
 			expect(ctx.drawImage.mock.calls.at(-1)[1]).toBe(60);
 		});
 
-		test('accepts beatsPerFrame as array with per-frame values', async () => {
+		test('accepts frameDurationBeats as array with per-frame values', async () => {
 			const ctx = createMockContext();
 			const appState = (await import('../src/js/core/AppState.js')).default;
 			appState.bpm = 120; // 120 BPM
@@ -446,7 +446,7 @@ describe('AnimationLayer', () => {
 					numberOfFrames: 4,
 					framesPerRow: 4,
 					// Frame 0: 0.25 beat (125ms), Frame 1: 0.5 beat (250ms), etc.
-					beatsPerFrame: [0.25, 0.5, 0.25, 0.5]
+					frameDurationBeats: [0.25, 0.5, 0.25, 0.5]
 				})
 			);
 
@@ -473,7 +473,7 @@ describe('AnimationLayer', () => {
 					canvas2dContext: ctx,
 					numberOfFrames: 4,
 					framesPerRow: 4,
-					beatsPerFrame: 0.5
+					frameDurationBeats: 0.5
 				})
 			);
 
@@ -489,7 +489,7 @@ describe('AnimationLayer', () => {
 			appState.bpm = 120;
 		});
 
-		test('throws when beatsPerFrame is invalid (no fallback)', async () => {
+		test('throws when frameDurationBeats is invalid (no fallback)', async () => {
 			const ctx = createMockContext();
 
 			expect(
@@ -499,14 +499,14 @@ describe('AnimationLayer', () => {
 							canvas2dContext: ctx,
 							numberOfFrames: 2,
 							framesPerRow: 2,
-							beatsPerFrame: 'invalid', // Invalid value
+							frameDurationBeats: 'invalid', // Invalid value
 							frameRatesForFrames: { 0: 1000 } // would be used previously
 						})
 					)
-			).toThrow('invalid beatsPerFrame');
+			).toThrow('invalid frameDurationBeats');
 		});
 
-		test('beatsPerFrame takes priority over frameRatesForFrames', async () => {
+		test('frameDurationBeats takes priority over frameRatesForFrames', async () => {
 			const ctx = createMockContext();
 			const appState = (await import('../src/js/core/AppState.js')).default;
 			appState.bpm = 120;
@@ -516,7 +516,7 @@ describe('AnimationLayer', () => {
 					canvas2dContext: ctx,
 					numberOfFrames: 2,
 					framesPerRow: 2,
-					beatsPerFrame: 0.5, // 250ms at 120 BPM
+					frameDurationBeats: 0.5, // 250ms at 120 BPM
 					frameRatesForFrames: { 0: 1000 } // Would be 1ms if used
 				})
 			);
diff --git a/test/validate-extended.test.js b/test/validate-extended.test.js

Original file line number	Diff line number	Diff line change
`@@ -4,5 +4,5 @@`
`4`	`4`	`"framesPerRow": 8,`
`5`	`5`	`"loop": true,`
`6`	`6`	`"retrigger": true,`
`7`		`- "beatsPerFrame": 0.5`
	`7`	`+ "frameDurationBeats": 0.5`
`8`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,13 +66,13 @@ export async function generate(sourceDir, outputPath) {`
`66`	`66`	`entry.bitDepth = metadata.bitDepth;`
`67`	`67`	`}`
`68`	`68`
`69`		`- // Ensure beatsPerFrame is included if specified (for BPM sync)`
`70`		`- if (metadata.beatsPerFrame !== undefined) {`
`71`		`- entry.beatsPerFrame = metadata.beatsPerFrame;`
	`69`	`+ // Ensure frameDurationBeats is included if specified (for BPM sync)`
	`70`	`+ if (metadata.frameDurationBeats !== undefined) {`
	`71`	`+ entry.frameDurationBeats = metadata.frameDurationBeats;`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`output[channel][note][velocity] = entry;`
`75`		- console.log(` Velocity ${velocity}: ${pngFile \|\| '(no png)'}${metadata.bitDepth ? ` (${metadata.bitDepth}-bit)` : ''}${metadata.beatsPerFrame ? ' (BPM sync)' : ''}`);
	`75`	+ console.log(` Velocity ${velocity}: ${pngFile \|\| '(no png)'}${metadata.bitDepth ? ` (${metadata.bitDepth}-bit)` : ''}${metadata.frameDurationBeats ? ' (BPM sync)' : ''}`);
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -131,32 +131,32 @@ async function validateAnimation(animationDir, animationPath) {`
`131`	`131`	`}`
`132`	`132`	`}`
`133`	`133`
`134`		`- // Validate beatsPerFrame - must be positive number or array of positive numbers matching numberOfFrames`
`135`		`- if (meta.beatsPerFrame !== undefined) {`
`136`		`- if (Array.isArray(meta.beatsPerFrame)) {`
	`134`	`+ // Validate frameDurationBeats - must be positive number or array of positive numbers matching numberOfFrames`
	`135`	`+ if (meta.frameDurationBeats !== undefined) {`
	`136`	`+ if (Array.isArray(meta.frameDurationBeats)) {`
`137`	`137`	`// Check for empty array (AnimationLayer will warn and fall back, but we should catch it here)`
`138`		`- if (meta.beatsPerFrame.length === 0) {`
`139`		`- errors.push('meta.json: beatsPerFrame array cannot be empty');`
	`138`	`+ if (meta.frameDurationBeats.length === 0) {`
	`139`	`+ errors.push('meta.json: frameDurationBeats array cannot be empty');`
`140`	`140`	`}`
`141`	`141`	`// Array form - must match numberOfFrames length and all values must be positive`
`142`		`- if (meta.numberOfFrames && meta.beatsPerFrame.length > 0 && meta.beatsPerFrame.length !== meta.numberOfFrames) {`
`143`		- errors.push(`meta.json: beatsPerFrame array length (${meta.beatsPerFrame.length}) must match numberOfFrames (${meta.numberOfFrames})`);
	`142`	`+ if (meta.numberOfFrames && meta.frameDurationBeats.length > 0 && meta.frameDurationBeats.length !== meta.numberOfFrames) {`
	`143`	+ errors.push(`meta.json: frameDurationBeats array length (${meta.frameDurationBeats.length}) must match numberOfFrames (${meta.numberOfFrames})`);
`144`	`144`	`}`
`145`		`- for (let i = 0; i < meta.beatsPerFrame.length; i++) {`
`146`		`- const val = meta.beatsPerFrame[i];`
	`145`	`+ for (let i = 0; i < meta.frameDurationBeats.length; i++) {`
	`146`	`+ const val = meta.frameDurationBeats[i];`
`147`	`147`	`if (typeof val !== 'number') {`
`148`		- errors.push(`meta.json: beatsPerFrame[${i}] must be a number (got ${typeof val})`);
	`148`	+ errors.push(`meta.json: frameDurationBeats[${i}] must be a number (got ${typeof val})`);
`149`	`149`	`} else if (val <= 0) {`
`150`		- errors.push(`meta.json: beatsPerFrame[${i}] must be a positive number (got ${val})`);
	`150`	+ errors.push(`meta.json: frameDurationBeats[${i}] must be a positive number (got ${val})`);
`151`	`151`	`}`
`152`	`152`	`}`
`153`		`- } else if (typeof meta.beatsPerFrame === 'number') {`
	`153`	`+ } else if (typeof meta.frameDurationBeats === 'number') {`
`154`	`154`	`// Shorthand form - single positive number applies to all frames`
`155`		`- if (meta.beatsPerFrame <= 0) {`
`156`		- errors.push(`meta.json: beatsPerFrame must be a positive number (got ${meta.beatsPerFrame})`);
	`155`	`+ if (meta.frameDurationBeats <= 0) {`
	`156`	+ errors.push(`meta.json: frameDurationBeats must be a positive number (got ${meta.frameDurationBeats})`);
`157`	`157`	`}`
`158`	`158`	`} else {`
`159`		`- errors.push('meta.json: beatsPerFrame must be a positive number or array of positive numbers');`
	`159`	`+ errors.push('meta.json: frameDurationBeats must be a positive number or array of positive numbers');`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`