@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.3

package/out-tsc/scripts/version/copy-to-binary.d.ts

@@ -0,0 +1 @@
+export {};

package/out-tsc/scripts/version/copy-to-binary.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const argv = process.argv.slice(2);
+let sourceArg;
+let binaryArg;
+let outDirArg;
+for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--source") {
+        sourceArg = argv[++i];
+    }
+    else if (a === "--binary") {
+        binaryArg = argv[++i];
+    }
+    else if (a === "--out-dir") {
+        outDirArg = argv[++i];
+    }
+    else if (a === "--help" || a === "-h") {
+        process.exit(0);
+    }
+    else {
+        console.error(`Unknown arg: ${a}`);
+        process.exit(1);
+    }
+}
+// Default source: attempt to locate project-version.json at repo root
+const defaultSource = path_1.default.resolve(__dirname, "..", "..", "..", "project-version.json");
+const sourcePath = sourceArg ? path_1.default.resolve(sourceArg) : defaultSource;
+if (!fs_1.default.existsSync(sourcePath)) {
+    console.error(`Source project-version.json not found at '${sourcePath}'. Please provide --source or ensure file exists.`);
+    process.exit(2);
+}
+let destDir = null;
+if (binaryArg) {
+    const binPath = path_1.default.resolve(binaryArg);
+    // If it's an existing file, use its directory, otherwise assume user passed target path and use its parent
+    if (fs_1.default.existsSync(binPath) && fs_1.default.statSync(binPath).isFile()) {
+        destDir = path_1.default.dirname(binPath);
+    }
+    else {
+        // If binPath looks like a file path (has extension) use parent, else treat as dir
+        const ext = path_1.default.extname(binPath);
+        if (ext) {
+            destDir = path_1.default.dirname(binPath);
+        }
+        else {
+            destDir = binPath;
+        }
+    }
+}
+else if (outDirArg) {
+    destDir = path_1.default.resolve(outDirArg);
+}
+else {
+    // Default: try to copy next to the running node current working dir (useful when packaging)
+    destDir = process.cwd();
+}
+if (!destDir) {
+    console.error("Could not resolve destination directory");
+    process.exit(3);
+}
+try {
+    if (!fs_1.default.existsSync(destDir)) {
+        fs_1.default.mkdirSync(destDir, { recursive: true });
+    }
+    const destPath = path_1.default.join(destDir, "project-version.json");
+    fs_1.default.copyFileSync(sourcePath, destPath);
+    console.log(`project-version.json copied to '${destPath}'`);
+    process.exit(0);
+}
+catch (err) {
+    console.error("Failed to copy project-version.json:", err);
+    process.exit(4);
+}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@devaloop/devalang",
   "private": false,
-  "version": "0.0.1-beta.1",
+  "version": "0.0.1-beta.3",
   "description": "Write music like code. Devalang is a domain-specific language (DSL) for sound designers and music hackers. Compose, automate, and control sound — in plain text.",
+  "longDescription": "Devalang is a compact, performant DSL and toolchain for composing, automating and rendering sound. It provides a CLI, WASM bindings, a TypeScript API, and plugins for editors. Ideal for live-coding, sample-based production, algorithmic composition, and fast prototyping.",
   "main": "out-tsc/index.js",
   "bin": {
     "devalang": "./out-tsc/bin/index.js"
@@ -18,6 +19,7 @@
     "rust:prepack": "cargo build --release",
     "scripts:postbuild": "tsc && node out-tsc/scripts/postbuild.js",
     "scripts:version:bump": "tsc && node out-tsc/scripts/version/index.js",
+    "scripts:copy-version": "tsc && node out-tsc/scripts/version/copy-to-binary.js --out-dir ./out-tsc/bin",
     "scripts:build": "tsc",
     "types:build": "tsc --emitDeclarationOnly",
     "types:wasm": "tsc && node out-tsc/scripts/copy-wasm-dts.js",
@@ -25,25 +27,36 @@
     "test:rust": "cargo test",
     "test:ts": "mocha -r ts-node/register tests/typescript/**/*.spec.ts --exit",
     "test": "npm run test:ts",
-    "postinstall": "node out-tsc/scripts/postinstall.js"
+    "postinstall": "node out-tsc/scripts/postinstall.js",
+    "beforepublish": "npm run types:all && npm run scripts:copy-version"
   },
   "homepage": "https://devalang.com",
   "keywords": [
     "devalang",
     "music",
     "sound",
-    "domain-specific language",
     "dsl",
-    "programming language",
-    "sound design",
-    "music hacking",
+    "domain-specific-language",
     "audio",
+    "music-programming",
     "synthesis",
-    "scripting",
-    "sound synthesis",
-    "music programming"
+    "midi",
+    "wasm",
+    "vscode",
+    "live-coding",
+    "sound-design",
+    "samples",
+    "cli"
   ],
-  "author": "Devaloop",
+  "author": {
+    "name": "Devaloop",
+    "email": "contact@devaloop.com",
+    "url": "https://devaloop.com"
+  },
+  "bugs": {
+    "url": "https://github.com/devaloop-labs/devalang/issues",
+    "email": "contact@devaloop.com"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",

package/project-version.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.0.1-beta.1",
+  "version": "0.0.1-beta.3",
   "channel": "beta",
-  "lastCommit": "888ed3a754f3bc95362eb9742c2ed8873b3cfd5f",
-  "build": 0
+  "lastCommit": "d9c8d5927288897aebf7faceb2b3495b5b8b87eb",
+  "build": 2
 }

package/rust/bindings/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "devalang_bindings"
+version = "0.0.1"
+description = "Bindings for Devalang (to use them in external contexts)"
+license = "MIT"
+authors = ["Devaloop <contact@devaloop.com>"]
+edition = "2024"
+
+[dependencies]

package/rust/bindings/src/lib.rs

@@ -0,0 +1,86 @@
+//! Minimal, focused bindings helpers for writing custom render functions in
+//! plugin crates.
+//!
+//! The core runtime already handles registration and FFI bridging. This crate
+//! only exports the types and function-signature aliases that plugin authors
+//! should implement in safe Rust. The host will convert raw buffers/pointers
+//! into these safe types before calling the plugin function.
+//!
+//! Guiding principle: plugin authors write purely safe Rust functions with
+//! clear parameters (slices and small structs). No registration helpers or
+//! global registries are provided here.
+
+/// Lightweight representation of a musical note.
+#[derive(Debug, Clone, Copy)]
+pub struct Note {
+	/// MIDI pitch 0..127
+	pub pitch: u8,
+	/// Velocity 0..127
+	pub velocity: u8,
+	/// Note duration in milliseconds (approximate)
+	pub duration_ms: u32,
+}
+
+impl Default for Note {
+	fn default() -> Self {
+		Self { pitch: 60, velocity: 100, duration_ms: 500 }
+	}
+}
+
+/// Parameters describing the output buffer and audio context.
+#[derive(Debug, Clone, Copy)]
+pub struct BufferParams {
+	/// Sample rate in Hz
+	pub sample_rate: u32,
+	/// Number of channels (1 = mono, 2 = stereo, ...)
+	pub channels: u32,
+	/// Number of frames (samples per channel) available in the buffer
+	pub frames: u32,
+}
+
+/// Helper to compute expected buffer length (frames * channels).
+impl BufferParams {
+	/// Returns the expected length of the interleaved buffer (frames * channels)
+	/// as a host-friendly `usize`. The host is responsible for converting
+	/// its platform-sized integers into these explicit-width fields.
+	pub fn buffer_len(&self) -> usize {
+		(self.frames as usize).saturating_mul(self.channels as usize)
+	}
+
+	/// Quick validation helper that plugins can call to ensure the provided
+	/// output slice matches the declared `params` length.
+	pub fn validate_buffer(out: &mut [f32], params: BufferParams) -> Result<(), &'static str> {
+		let expected = params.buffer_len();
+		if out.len() < expected { Err("output buffer too small") } else { Ok(()) }
+	}
+}
+
+impl Default for BufferParams {
+	fn default() -> Self {
+		Self { sample_rate: 44100, channels: 1, frames: 0 }
+	}
+}
+
+/// Common render function signature plugin authors should implement.
+///
+/// - `out` is a mutable slice of f32 samples (interleaved if channels > 1).
+/// - `params` provides sample rate / channels / frames info.
+/// - `note` is the Note descriptor.
+/// - `freq`/`amp` give additional voice parameters the host may pass.
+pub type RenderFn = fn(out: &mut [f32], params: BufferParams, note: Note, freq: f32, amp: f32);
+
+/// A more complete signature used by synth-style plugins that also need
+/// access to extra controls (e.g. voice index or time offset).
+pub type RenderFnExt = fn(
+	out: &mut [f32],
+	params: BufferParams,
+	note: Note,
+	freq: f32,
+	amp: f32,
+	voice_index: u32,
+	time_ms: u64,
+);
+
+/// Optional signature for control parameter setters. The host can call these
+/// safely by converting raw values into primitives.
+pub type SetParamFn = fn(param_name: &str, value: f32);

package/rust/cli/addon/commands.rs

@@ -0,0 +1,35 @@
+use crate::cli::addon::{
+    install::install_addon, list::list_addons, remove::remove_addon, update::update_addon,
+};
+
+pub async fn handle_install_addon_command(name: String, no_clear_tmp: bool) -> Result<(), String> {
+    if let Err(e) = install_addon(name, no_clear_tmp).await {
+        return Err(format!("Failed to install addon: {}", e));
+    }
+
+    Ok(())
+}
+
+pub async fn handle_list_addon_command() -> Result<(), String> {
+    if let Err(e) = list_addons().await {
+        return Err(format!("Failed to list addons: {}", e));
+    }
+
+    Ok(())
+}
+
+pub async fn handle_remove_addon_command(name: String) -> Result<(), String> {
+    if let Err(e) = remove_addon(name).await {
+        return Err(format!("Failed to remove addon: {}", e));
+    }
+
+    Ok(())
+}
+
+pub async fn handle_update_addon_command(name: String) -> Result<(), String> {
+    if let Err(e) = update_addon(name).await {
+        return Err(format!("Failed to update addon: {}", e));
+    }
+
+    Ok(())
+}

package/rust/cli/addon/download.rs

@@ -0,0 +1,234 @@
+use crate::{
+    cli::addon::{metadata::AddonToDownloadMetadata, utils::ask_api_for_signed_url},
+    config::ops::load_config,
+    web::cdn::download_from_cdn,
+};
+use devalang_core::config::driver::{ProjectConfig, ProjectConfigExt};
+use devalang_types::{AddonType, ProjectConfigBankEntry, ProjectConfigPluginEntry};
+use devalang_utils::{
+    file::extract_zip_safely,
+    logger::{LogLevel, Logger},
+    spinner::start_spinner,
+};
+use std::fs;
+
+pub async fn download_addon(
+    slug: &str,
+    addon_metadata: &AddonToDownloadMetadata,
+) -> Result<(), String> {
+    let logger = Logger::new();
+    let deva_dir = devalang_utils::path::ensure_deva_dir()?;
+
+    let target_dir = match addon_metadata.addon_type {
+        AddonType::Bank => deva_dir.join("banks"),
+        AddonType::Plugin => deva_dir.join("plugins"),
+        AddonType::Preset => deva_dir.join("presets"),
+        AddonType::Template => deva_dir.join("templates"),
+    };
+
+    if !target_dir.exists() {
+        fs::create_dir_all(&target_dir).map_err(|e| {
+            format!(
+                "Failed to create target dir '{}': {}",
+                target_dir.display(),
+                e
+            )
+        })?;
+    }
+
+    let user_provided_publisher = slug.contains('.');
+    let display_name = if user_provided_publisher {
+        format!("{}.{}", addon_metadata.publisher, addon_metadata.name)
+    } else {
+        addon_metadata.name.clone()
+    };
+
+    let archive_path = {
+        let tmp_root = deva_dir.join("tmp");
+        if !tmp_root.exists() {
+            fs::create_dir_all(&tmp_root)
+                .map_err(|e| format!("Failed to create tmp dir '{}': {}", tmp_root.display(), e))?;
+        }
+        tmp_root.join(&display_name).with_extension("tar.gz")
+    };
+
+    if let Some(parent) = archive_path.parent() {
+        if !parent.exists() {
+            fs::create_dir_all(parent)
+                .map_err(|e| format!("Failed to prepare tmp dir '{}': {}", parent.display(), e))?;
+        }
+    }
+
+    let extract_path = target_dir
+        .join(&addon_metadata.publisher)
+        .join(&addon_metadata.name);
+
+    let signed_url = {
+        let spinner =
+            start_spinner(format!("Requesting download link for {}", display_name).as_str());
+        let request = if user_provided_publisher {
+            ask_api_for_signed_url(
+                addon_metadata.addon_type.clone(),
+                addon_metadata.publisher.clone(),
+                &addon_metadata.name,
+            )
+        } else {
+            ask_api_for_signed_url(
+                addon_metadata.addon_type.clone(),
+                String::new(),
+                &addon_metadata.name,
+            )
+        };
+
+        match request.await {
+            Ok(url) => url,
+            Err(err) => {
+                let message = format!("Failed to obtain download link: {}", err);
+                println!("{}", message);
+                return Err(message);
+            }
+        }
+    };
+
+    let config_path = devalang_utils::path::get_devalang_config_path()?;
+    let mut config = load_config(Some(&config_path))
+        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
+
+    if extract_path.exists() {
+        logger.log_message(
+            LogLevel::Info,
+            format!(
+                "Addon '{}' already present at {}",
+                display_name.as_str(),
+                extract_path.display()
+            )
+            .as_str(),
+        );
+
+        if ensure_config_entry(&mut config, addon_metadata) {
+            if let Err(err) = config.write_config(&config) {
+                logger.log_message(
+                    LogLevel::Error,
+                    format!("Failed to write config: {}", err).as_str(),
+                );
+            }
+        }
+
+        if matches!(
+            addon_metadata.addon_type,
+            AddonType::Preset | AddonType::Template
+        ) {
+            logger.log_message(
+                LogLevel::Info,
+                "Presets and templates are not tracked in project config yet.",
+            );
+        }
+
+        return Ok(());
+    }
+
+    let download_spinner = start_spinner("Downloading archive...");
+    match download_from_cdn(&signed_url, &archive_path).await {
+        Ok(_) => println!("Downloaded archive to {}", archive_path.display()),
+        Err(err) => {
+            let message = format!("Failed to download archive: {}", err);
+            println!("{}", message);
+            return Err(message);
+        }
+    }
+
+    let extract_spinner = start_spinner("Extracting archive");
+    match extract_zip_safely(&archive_path, &extract_path) {
+        Ok(_) => println!("Installed at {}", extract_path.display()),
+        Err(err) => {
+            println!("Failed to extract archive: {}", err);
+            return Err(err);
+        }
+    }
+
+    let mut config_updated = false;
+    if ensure_config_entry(&mut config, addon_metadata) {
+        match config.write_config(&config) {
+            Ok(_) => {
+                config_updated = true;
+            }
+            Err(err) => {
+                logger.log_message(
+                    LogLevel::Error,
+                    format!("Failed to write config: {}", err).as_str(),
+                );
+            }
+        }
+    }
+
+    logger.log_message(
+        LogLevel::Info,
+        format!(
+            "Addon '{}' installed at {}",
+            display_name,
+            extract_path.display()
+        )
+        .as_str(),
+    );
+
+    if config_updated {
+        logger.log_message(LogLevel::Info, "Project config updated");
+    } else if matches!(
+        addon_metadata.addon_type,
+        AddonType::Preset | AddonType::Template
+    ) {
+        logger.log_message(
+            LogLevel::Info,
+            "Presets and templates are not tracked in project config yet.",
+        );
+    }
+
+    // Cleanup temporary files used during download/install
+    if let Err(err) = devalang_utils::file::clear_tmp_folder() {
+        logger.log_message(
+            LogLevel::Warning,
+            format!("Failed to clear tmp folder: {}", err).as_str(),
+        );
+    }
+
+    Ok(())
+}
+
+fn ensure_config_entry(
+    config: &mut ProjectConfig,
+    addon_metadata: &AddonToDownloadMetadata,
+) -> bool {
+    match addon_metadata.addon_type {
+        AddonType::Bank => {
+            let dependency_path = format!(
+                "devalang://bank/{}/{}",
+                addon_metadata.publisher, addon_metadata.name
+            );
+            let banks = config.banks.get_or_insert_with(Vec::new);
+            if banks.iter().any(|entry| entry.path == dependency_path) {
+                false
+            } else {
+                banks.push(ProjectConfigBankEntry {
+                    path: dependency_path,
+                });
+                true
+            }
+        }
+        AddonType::Plugin => {
+            let dependency_path = format!(
+                "devalang://plugin/{}/{}",
+                addon_metadata.publisher, addon_metadata.name
+            );
+            let plugins = config.plugins.get_or_insert_with(Vec::new);
+            if plugins.iter().any(|entry| entry.path == dependency_path) {
+                false
+            } else {
+                plugins.push(ProjectConfigPluginEntry {
+                    path: dependency_path,
+                });
+                true
+            }
+        }
+        AddonType::Preset | AddonType::Template => false,
+    }
+}

package/rust/cli/addon/install.rs

@@ -0,0 +1,33 @@
+use devalang_utils::logger::Logger;
+
+use crate::cli::addon::{download::download_addon, metadata::get_addon_from_api};
+
+pub async fn install_addon(slug: String, no_clear_tmp: bool) -> Result<(), String> {
+    let addon_metadata = get_addon_from_api(&slug).await?;
+
+    if let Err(e) = download_addon(&slug, &addon_metadata).await {
+        eprintln!("Failed to download addon '{}': {}", slug, e);
+    }
+
+    let logger = Logger::new();
+    logger.log_message(
+        devalang_utils::logger::LogLevel::Success,
+        &format!(
+            "Successfully installed addon '{}.{}' ({})",
+            addon_metadata.publisher,
+            addon_metadata.name,
+            match addon_metadata.addon_type {
+                devalang_types::AddonType::Bank => "bank",
+                devalang_types::AddonType::Plugin => "plugin",
+                devalang_types::AddonType::Preset => "preset",
+                devalang_types::AddonType::Template => "template",
+            }
+        ),
+    );
+
+    if !no_clear_tmp {
+        let _ = devalang_utils::file::clear_tmp_folder();
+    }
+
+    Ok(())
+}