lively 0.11.0 → 0.13.0

data/public/_components/@socketry/live-audio/Live/Audio/Output.js

@@ -0,0 +1,87 @@
+// Base Audio Output Node - handles routing to analysis and/or audio device
+
+export class Output {
+	#audioContext = null;
+	#gainNode = null;
+	#analysisNode = null;
+	#destination = null;
+	
+	constructor(audioContext, initialGain = 1.0) {
+		if (!audioContext || typeof audioContext.createGain !== 'function') {
+			throw new Error('Output requires a valid AudioContext');
+		}
+		
+		this.#audioContext = audioContext;
+		
+		// Initialize audio nodes
+		this.#gainNode = this.#audioContext.createGain();
+		this.#destination = this.#audioContext.destination;
+		
+		// Default volume is 1.0
+		this.#gainNode.gain.value = initialGain;
+		
+		// Connect directly to destination by default
+		this.#gainNode.connect(this.#destination);
+	}
+	
+	// Synchronous getter for audioContext
+	get audioContext() {
+		return this.#audioContext;
+	}
+	
+	// Connect an analysis node for visualization
+	connectAnalysis(analysisNode) {
+		if (this.#analysisNode) {
+			this.#gainNode.disconnect(this.#analysisNode.input);
+		}
+		this.#analysisNode = analysisNode;
+		this.#gainNode.disconnect(this.#destination);
+		this.#gainNode.connect(this.#analysisNode.input);
+		this.#analysisNode.connect(this.#destination);
+	}
+	
+	// Remove analysis and connect directly to destination
+	disconnectAnalysis() {
+		if (this.#analysisNode) {
+			this.#gainNode.disconnect(this.#analysisNode.input);
+			this.#analysisNode.disconnect(this.#destination);
+			this.#analysisNode = null;
+		}
+		this.#gainNode.connect(this.#destination);
+	}
+	
+	get input() {
+		return this.#gainNode;
+	}
+	
+	// Public getter for gain node (for testing)
+	get gainNode() {
+		return this.#gainNode;
+	}
+	
+	// Get current volume from the gain node
+	get volume() {
+		return this.#gainNode.gain.value;
+	}
+	
+	// Apply volume to the gain node (called by Controller)
+	setVolume(volume) {
+		this.#gainNode.gain.value = volume;
+	}
+	
+	// Clean up resources
+	dispose() {
+		if (this.#gainNode) {
+			this.#gainNode.disconnect();
+			this.#gainNode = null;
+		}
+		
+		if (this.#analysisNode) {
+			this.#analysisNode.disconnect();
+			this.#analysisNode = null;
+		}
+		
+		this.#audioContext = null;
+		this.#destination = null;
+	}
+}

data/public/_components/@socketry/live-audio/Live/Audio/Sound.js

@@ -0,0 +1,34 @@
+// Base Sound Class
+export class Sound {
+	createEnvelope(audioContext, gainNode, attack, decay, sustain, release, duration) {
+		const now = audioContext.currentTime;
+		const initialGain = gainNode.gain.value;
+		
+		gainNode.gain.setValueAtTime(0, now);
+		gainNode.gain.linearRampToValueAtTime(initialGain, now + attack);
+		gainNode.gain.linearRampToValueAtTime(initialGain * sustain, now + attack + decay);
+		if (duration - release > attack + decay) {
+			gainNode.gain.setValueAtTime(initialGain * sustain, now + duration - release);
+		}
+		gainNode.gain.linearRampToValueAtTime(0, now + duration);
+	}
+	
+	// Public interface - takes output and extracts what's needed.
+	play(output) {
+		// Return early if volume is zero (muted) - subclasses can override this behavior:
+		if (output.volume <= 0) return;
+		
+		this.start(output);
+	}
+	
+	// Internal method to be implemented by subclasses.
+	start(output) {
+		throw new Error('start() method must be implemented by subclass');
+	}
+	
+	// Default stop implementation (no-op for most sounds).
+	stop() {
+		// Most sounds are fire-and-forget, so this is a no-op by default.
+		// Subclasses can override this for continuous sounds like music.
+	}
+}

data/public/_components/@socketry/live-audio/Live/Audio/Visualizer.js

@@ -0,0 +1,265 @@
+// Analysis Node - handles waveform visualization and audio quality monitoring
+export class Visualizer {
+	constructor(audioContext, waveformCanvas = null, alertCanvas = null) {
+		this.audioContext = audioContext;
+		this.analyser = audioContext.createAnalyser();
+		this.analyser.fftSize = 2048;
+		this.analyser.smoothingTimeConstant = 0.8;
+		
+		this.dataArray = new Uint8Array(this.analyser.frequencyBinCount);
+		this.canvas = waveformCanvas;
+		this.canvasContext = null;
+		this.alertCanvas = alertCanvas;
+		this.alertContext = null;
+		this.animationId = null;
+		
+		// Analysis state
+		this.clipDetected = false;
+		this.popDetected = false;
+		this.clipThreshold = 0.95;
+		this.popThreshold = 0.1;
+		this.clipCounter = 0;
+		this.popCounter = 0;
+		
+		// Rolling peak detection
+		this.peakHistory = new Array(60).fill(0);
+		this.peakHistoryIndex = 0;
+		this.rollingPeak = 0;
+		
+		// Only set up canvas and start visualization if canvases are provided
+		if (this.canvas || this.alertCanvas) {
+			try {
+				this.setupCanvas();
+				this.startVisualization();
+			} catch (error) {
+				console.warn('Visualizer canvas setup failed:', error.message);
+				this.canvasContext = null;
+				this.alertContext = null;
+			}
+		}
+	}
+	
+	get input() {
+		return this.analyser;
+	}
+	
+	connect(destination) {
+		this.analyser.connect(destination);
+	}
+	
+	disconnect(destination) {
+		this.analyser.disconnect(destination);
+	}
+	
+	setupCanvas() {
+		// Use provided canvases or fall back to finding/creating them
+		if (!this.canvas) {
+			this.canvas = document.getElementById('waveform-canvas');
+			if (!this.canvas) {
+				this.canvas = document.createElement('canvas');
+				this.canvas.id = 'waveform-canvas';
+				this.canvas.width = 800;
+				this.canvas.height = 200;
+				this.canvas.style.border = '2px solid #333';
+				this.canvas.style.borderRadius = '8px';
+				this.canvas.style.background = '#000';
+				document.body.appendChild(this.canvas);
+			}
+		}
+		
+		if (this.canvas) {
+			this.canvasContext = this.canvas.getContext('2d');
+		}
+		
+		if (!this.alertCanvas) {
+			this.alertCanvas = document.getElementById('alert-canvas');
+			if (!this.alertCanvas) {
+				this.alertCanvas = document.createElement('canvas');
+				this.alertCanvas.id = 'alert-canvas';
+				this.alertCanvas.width = 800;
+				this.alertCanvas.height = 100;
+				this.alertCanvas.style.border = '2px solid #333';
+				this.alertCanvas.style.borderRadius = '8px';
+				this.alertCanvas.style.background = '#111';
+				this.alertCanvas.style.marginTop = '10px';
+				if (this.canvas && this.canvas.parentNode) {
+					this.canvas.parentNode.insertBefore(this.alertCanvas, this.canvas.nextSibling);
+				} else {
+					document.body.appendChild(this.alertCanvas);
+				}
+			}
+		}
+		
+		if (this.alertCanvas) {
+			this.alertContext = this.alertCanvas.getContext('2d');
+		}
+	}
+	
+	startVisualization() {
+		// Don't start visualization if canvas contexts are not available
+		if (!this.canvasContext || !this.alertContext) {
+			return;
+		}
+		
+		const draw = () => {
+			this.animationId = requestAnimationFrame(draw);
+			this.analyser.getByteTimeDomainData(this.dataArray);
+			this.analyzeAudioQuality();
+			this.drawWaveform();
+			this.drawQualityIndicators();
+		};
+		draw();
+	}
+	
+	analyzeAudioQuality() {
+		this.clipDetected = false;
+		this.popDetected = false;
+		let currentPeak = 0;
+		
+		for (let i = 0; i < this.dataArray.length; i++) {
+			const sample = (this.dataArray[i] - 128) / 128.0;
+			const sampleAbs = Math.abs(sample);
+			currentPeak = Math.max(currentPeak, sampleAbs);
+			
+			if (sampleAbs > this.clipThreshold) {
+				this.clipDetected = true;
+				this.clipCounter = Math.min(this.clipCounter + 1, 60);
+			}
+			
+			if (i > 0) {
+				const previousSample = (this.dataArray[i-1] - 128) / 128.0;
+				const amplitudeChange = Math.abs(sample - previousSample);
+				if (amplitudeChange > this.popThreshold) {
+					this.popDetected = true;
+					this.popCounter = Math.min(this.popCounter + 1, 60);
+				}
+			}
+		}
+		
+		this.peakHistory[this.peakHistoryIndex] = currentPeak;
+		this.peakHistoryIndex = (this.peakHistoryIndex + 1) % this.peakHistory.length;
+		this.rollingPeak = Math.max(...this.peakHistory);
+		
+		if (!this.clipDetected) this.clipCounter = Math.max(this.clipCounter - 1, 0);
+		if (!this.popDetected) this.popCounter = Math.max(this.popCounter - 1, 0);
+	}
+	
+	drawWaveform() {
+		if (!this.canvasContext || !this.canvas) return;
+		
+		this.canvasContext.fillStyle = '#000';
+		this.canvasContext.fillRect(0, 0, this.canvas.width, this.canvas.height);
+		
+		this.canvasContext.lineWidth = 2;
+		this.canvasContext.strokeStyle = this.clipCounter > 0 ? '#ff0000' : 
+		                                  this.popCounter > 0 ? '#ff8800' : '#00ff41';
+		
+		this.canvasContext.beginPath();
+		const sliceWidth = this.canvas.width / this.dataArray.length;
+		let x = 0;
+		
+		for (let i = 0; i < this.dataArray.length; i++) {
+			const v = this.dataArray[i] / 128.0;
+			const y = v * this.canvas.height / 2;
+			
+			if (Math.abs((this.dataArray[i] - 128) / 128.0) > this.clipThreshold) {
+				this.canvasContext.fillStyle = '#ff0000';
+				this.canvasContext.fillRect(x - 1, y - 2, 3, 4);
+			}
+			
+			if (i === 0) {
+				this.canvasContext.moveTo(x, y);
+			} else {
+				this.canvasContext.lineTo(x, y);
+			}
+			x += sliceWidth;
+		}
+		
+		this.canvasContext.stroke();
+		this.drawThresholdLines();
+	}
+	
+	drawThresholdLines() {
+		const clipLine = this.canvas.height / 2 * (1 - this.clipThreshold);
+		const clipLineBottom = this.canvas.height / 2 * (1 + this.clipThreshold);
+		
+		this.canvasContext.strokeStyle = '#444';
+		this.canvasContext.lineWidth = 1;
+		this.canvasContext.setLineDash([5, 5]);
+		
+		this.canvasContext.beginPath();
+		this.canvasContext.moveTo(0, clipLine);
+		this.canvasContext.lineTo(this.canvas.width, clipLine);
+		this.canvasContext.moveTo(0, clipLineBottom);
+		this.canvasContext.lineTo(this.canvas.width, clipLineBottom);
+		this.canvasContext.stroke();
+		this.canvasContext.setLineDash([]);
+	}
+	
+	drawQualityIndicators() {
+		if (!this.alertContext || !this.alertCanvas) return;
+		
+		this.alertContext.fillStyle = '#111';
+		this.alertContext.fillRect(0, 0, this.alertCanvas.width, this.alertCanvas.height);
+		
+		const centerY = this.alertCanvas.height / 2;
+		this.alertContext.font = '16px monospace';
+		this.alertContext.textAlign = 'left';
+		
+		if (this.clipCounter > 0) {
+			this.alertContext.fillStyle = '#ff0000';
+			this.alertContext.fillText('⚠️ CLIPPING DETECTED', 20, centerY - 10);
+			this.alertContext.fillText(`Clip Level: ${Math.round(this.clipCounter / 60 * 100)}%`, 20, centerY + 10);
+		} else if (this.popCounter > 0) {
+			this.alertContext.fillStyle = '#ff8800';
+			this.alertContext.fillText('⚠️ AUDIO POPS DETECTED', 20, centerY - 10);
+			this.alertContext.fillText(`Pop Level: ${Math.round(this.popCounter / 60 * 100)}%`, 20, centerY + 10);
+		} else {
+			this.alertContext.fillStyle = '#00ff41';
+			this.alertContext.fillText('✅ AUDIO QUALITY: GOOD', 20, centerY - 10);
+			this.alertContext.fillText('No clipping or pops detected', 20, centerY + 10);
+		}
+		
+		// Peak level meter
+		const maxSample = Math.max(...Array.from(this.dataArray).map(x => Math.abs((x - 128) / 128.0)));
+		const meterWidth = 200;
+		const meterHeight = 20;
+		const meterX = this.alertCanvas.width - meterWidth - 20;
+		const meterY = centerY - meterHeight / 2;
+		
+		this.alertContext.fillStyle = '#333';
+		this.alertContext.fillRect(meterX, meterY, meterWidth, meterHeight);
+		
+		const currentWidth = maxSample * meterWidth;
+		this.alertContext.fillStyle = '#555';
+		this.alertContext.fillRect(meterX, meterY, currentWidth, meterHeight);
+		
+		const peakWidth = this.rollingPeak * meterWidth;
+		this.alertContext.fillStyle = this.rollingPeak > this.clipThreshold ? '#ff0000' :
+		                              this.rollingPeak > 0.7 ? '#ff8800' : '#00ff41';
+		this.alertContext.fillRect(meterX, meterY, peakWidth, meterHeight);
+		
+		this.alertContext.strokeStyle = '#666';
+		this.alertContext.lineWidth = 1;
+		this.alertContext.strokeRect(meterX, meterY, meterWidth, meterHeight);
+		
+		this.alertContext.fillStyle = '#ccc';
+		this.alertContext.font = '12px monospace';
+		this.alertContext.textAlign = 'center';
+		this.alertContext.fillText('PEAK LEVEL (1s)', meterX + meterWidth / 2, meterY - 5);
+		this.alertContext.fillText(`${Math.round(this.rollingPeak * 100)}%`, meterX + meterWidth / 2, meterY + meterHeight + 15);
+		
+		const clipMarkerX = meterX + this.clipThreshold * meterWidth;
+		this.alertContext.strokeStyle = '#ff0000';
+		this.alertContext.lineWidth = 2;
+		this.alertContext.beginPath();
+		this.alertContext.moveTo(clipMarkerX, meterY - 2);
+		this.alertContext.lineTo(clipMarkerX, meterY + meterHeight + 2);
+		this.alertContext.stroke();
+	}
+	
+	setDetectionSensitivity(clipThreshold = 0.95, popThreshold = 0.1) {
+		this.clipThreshold = clipThreshold;
+		this.popThreshold = popThreshold;
+	}
+}

data/public/_components/@socketry/live-audio/Live/Audio.js

@@ -0,0 +1,24 @@
+// Live Audio Library
+// Web Audio API-based collection for game sounds and background music
+
+import { Controller } from './Audio/Controller.js';
+
+// Export the essential classes for users
+export { Controller } from './Audio/Controller.js';
+export { Sound } from './Audio/Sound.js';
+export { Visualizer } from './Audio/Visualizer.js';
+export { Output } from './Audio/Output.js';
+
+// Export all sound library classes under Library namespace
+export * as Library from './Audio/Library.js';
+
+// Main Audio namespace with Live.js pattern
+export const Audio = {
+	start(options = {}) {
+		const window = options.window || globalThis;
+		return new Controller(window, options);
+	},
+	
+	// Direct access to Controller for advanced usage
+	Controller
+};

data/public/_components/@socketry/live-audio/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@socketry/live-audio",
+  "type": "module",
+  "version": "0.4.0",
+  "description": "Web Audio API-based game audio synthesis and background music library for Ruby Live applications.",
+  "main": "Live/Audio.js",
+  "files": [
+    "Live/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/socketry/live-audio-js.git"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "devDependencies": {
+    "jsdom": "^24.1.3"
+  },
+  "keywords": [
+    "audio",
+    "webaudio",
+    "game",
+    "sound",
+    "synthesis",
+    "music",
+    "live"
+  ],
+  "author": "Samuel Williams <samuel.williams@oriontransfer.co.nz> (http://www.codeotaku.com/)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/socketry/live-audio-js/issues"
+  },
+  "homepage": "https://github.com/socketry/live-audio-js#readme"
+}

data/public/_components/@socketry/live-audio/readme.md

@@ -0,0 +1,250 @@
+# Live Audio.js
+
+A Web Audio API-based game audio synthesis and background music library for Ruby Live applications.
+
+[![Development Status](https://github.com/socketry/live-audio-js/workflows/Test/badge.svg)](https://github.com/socketry/live-audio-js/actions?workflow=Test)
+
+## Features
+
+- **Synthesized Sound Effects**: Classic game sounds including jump, coin, power-up, death, explosion, laser, and animal sounds.
+- **Background Music**: MP3 playback with loop points and volume control.
+- **Audio Visualization**: Real-time waveform display with quality monitoring.
+- **Anti-Clipping Protection**: Built-in gain management to prevent audio distortion.
+- **Modular Architecture**: Clean separation between sound synthesis, output routing, and visualization.
+- **Live.js Pattern Compliance**: Follows established patterns from the Live.js ecosystem.
+
+## Usage
+
+### Installation
+
+```bash
+npm install @socketry/live-audio
+```
+
+### Basic Setup
+
+```javascript
+import { Audio } from '@socketry/live-audio';
+import { MeowSound, ExplosionSound, BackgroundMusicSound } from '@socketry/live-audio/Live/Audio/Library.js';
+
+// Audio.start() pattern - follows Live.js conventions
+window.liveAudio = Audio.start();
+
+// Add sounds using the controller
+const meow = new MeowSound();
+const explosion = new ExplosionSound();
+const music = new BackgroundMusicSound('/assets/music.mp3', 10.0, 45.0);
+
+window.liveAudio.addSound('meow', meow);
+window.liveAudio.addSound('explosion', explosion);
+window.liveAudio.addSound('music', music);
+window.liveAudio.setVolume(0.8);
+
+// Play sounds anywhere in your app
+window.liveAudio.playSound('meow');
+```
+
+### Alternative: Direct Controller Usage
+
+```javascript
+import { Audio } from '@socketry/live-audio';
+import { CoinSound, LaserSound } from '@socketry/live-audio/Live/Audio/Library.js';
+
+const controller = Audio.start();
+
+// Add and play sounds
+const coin = new CoinSound();
+const laser = new LaserSound();
+controller.addSound('coin', coin);
+controller.addSound('laser', laser);
+controller.playSound('coin');
+controller.setVolume(0.8);
+```
+
+## API Reference
+
+### Audio (Main Namespace)
+
+The primary entry point following Live.js conventions.
+
+#### Static Methods
+- `Audio.start(options)` - Create a new controller instance (recommended)
+  - `options.window` - The window object to use (defaults to globalThis)
+  - Returns the controller instance
+- `Audio.Controller` - Direct access to Controller class for advanced usage
+
+### Controller
+
+The main audio controller class that manages all sound playback and audio context.
+
+#### Instance Methods
+- `addSound(name, soundInstance)` - Add a sound instance to the controller
+- `playSound(name)` - Play a sound by name
+- `stopSound(name)` - Stop a sound by name
+- `stopAllSounds()` - Stop all sounds
+- `listSounds()` - Get array of available sound names
+- `removeSound(name)` - Remove a sound from the controller
+- `setVolume(volume)` - Set master volume (0.0 to 1.0)
+- `getSound(name)` - Get direct access to a sound instance
+
+### Sound
+
+Base class for creating custom sound effects. Extend this class to create your own synthesized sounds.
+
+```javascript
+import { Sound } from '@socketry/live-audio';
+
+class CustomSound extends Sound {
+  start(output) {
+    const audioContext = output.audioContext;
+    const oscillator = audioContext.createOscillator();
+    const gainNode = audioContext.createGain();
+    
+    oscillator.type = 'sine';
+    oscillator.frequency.value = 440;
+    
+    this.createEnvelope(audioContext, gainNode, 0.01, 0.1, 0.5, 0.2, 0.5);
+    
+    oscillator.connect(gainNode);
+    gainNode.connect(output.input);
+    
+    oscillator.start();
+    oscillator.stop(audioContext.currentTime + 0.5);
+  }
+}
+```
+
+### Visualizer
+
+Audio analysis and visualization component that provides real-time waveform display and audio quality monitoring.
+
+- Clipping detection and visualization
+- Audio pop/click detection
+- Rolling peak level monitoring
+- Real-time waveform display
+
+## Built-in Sound Library
+
+The library includes a comprehensive collection of pre-built sound classes in `Library.js`:
+
+### Game Sound Effects
+- `JumpSound` - Classic platform game jump sound
+- `CoinSound` - Collectible pickup sound
+- `PowerUpSound` - Power-up acquisition sound
+- `DeathSound` - Game over sound
+- `ExplosionSound` - Explosive sound with multiple rumble layers
+- `LaserSound` - Sci-fi laser sound
+- `BeepSound` - Simple notification beep
+- `BlipSound` - Short UI interaction sound
+
+### Animal Sounds
+- `MeowSound` - Cat meow with frequency modulation
+- `BarkSound` - Dog bark with formant filtering
+- `RoarSound` - Lion roar with noise texture
+- `ChirpSound` - Bird chirp sound
+- `HowlSound` - Wolf howl with harmonic sweep
+- `DuckSound` - Duck quack with FM synthesis
+- `AlienSound` - Alien sound with ring modulation
+
+### Background Music
+- `BackgroundMusicSound(url, loopStart, loopEnd)` - MP3 background music with required URL and loop points
+
+### Usage Example
+
+```javascript
+import { Audio } from '@socketry/live-audio';
+import { MeowSound, ExplosionSound, BackgroundMusicSound } from '@socketry/live-audio/Live/Audio/Library.js';
+
+const controller = Audio.start();
+
+// Add sounds from the library
+const meow = new MeowSound();
+const explosion = new ExplosionSound();
+const music = new BackgroundMusicSound('/assets/background.mp3', 10.5, 45.2);
+
+controller.addSound('meow', meow);
+controller.addSound('explosion', explosion);
+controller.addSound('music', music);
+
+// Play them
+controller.playSound('meow');
+controller.playSound('explosion');
+controller.playSound('music');
+```
+
+## Project Structure
+
+The library follows Live.js ecosystem patterns with a clean modular architecture:
+
+```
+@socketry/live-audio/
+├── Live/
+│   ├── Audio.js              # Main module - exports Controller, Sound, Visualizer
+│   └── Audio/
+│       ├── Controller.js     # Audio controller with window-keyed shared instances
+│       ├── Sound.js          # Base Sound class for custom sounds
+│       ├── Output.js         # Audio routing and master volume control  
+│       ├── Visualizer.js     # Real-time waveform visualization
+│       └── Library.js        # Collection of pre-built game sounds
+└── test/
+    └── LiveAudio.js          # Comprehensive test suite
+```
+
+### Import Patterns
+
+```javascript
+// Main Audio namespace (recommended)
+import { Audio } from '@socketry/live-audio';
+
+// Essential classes for advanced usage
+import { Controller, Sound } from '@socketry/live-audio';
+
+// Full access including visualization
+import { Controller, Sound, Visualizer, Output } from '@socketry/live-audio';
+
+// Pre-built sound library - individual imports (recommended)
+import { MeowSound, ExplosionSound, BackgroundMusicSound } from '@socketry/live-audio/Live/Audio/Library.js';
+
+// Pre-built sound library - namespace import
+import * as Library from '@socketry/live-audio/Live/Audio/Library.js';
+```
+
+## Audio Context Management
+
+The library automatically manages a shared AudioContext to avoid browser limitations and ensure optimal performance:
+
+- Automatic context creation and resumption
+- Safari compatibility with proper latency handling
+- Shared instance pattern to prevent multiple contexts
+- Graceful degradation when audio is unavailable
+
+## Browser Compatibility
+
+- Modern browsers with Web Audio API support
+- Handles browser autoplay policies
+- Safari-specific optimizations for reduced latency
+- Fallback behavior when audio context is unavailable
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.
+
+## See Also
+
+  - [lively](https://github.com/socketry/lively) — Ruby framework for building interactive web applications.
+  - [live](https://github.com/socketry/live) — Provides client-server communication using websockets.
+  - [live-js](https://github.com/socketry/live-js) — JavaScript client library for Live framework.

data/public/application.js

@@ -0,0 +1,4 @@
+import { Live } from 'live';
+
+// Start Live.js with default configuration:
+const live = Live.start();