@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

package/tests/typescript/render_e2e.spec.ts

@@ -0,0 +1,77 @@
+import { expect } from "chai";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+const core: any = require("../../out-tsc");
+
+describe("devalang debug_render and render_audio E2E", () => {
+  let origCwd: string;
+  let tmpDir: string | null = null;
+
+  before(function () {
+    origCwd = process.cwd();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devalang-e2e-"));
+    fs.writeFileSync(
+      path.join(tmpDir, ".devalang"),
+      'name = "devalang-test"\n'
+    );
+    fs.mkdirSync(path.join(tmpDir, ".deva"), { recursive: true });
+    process.chdir(tmpDir as string);
+  });
+
+  after(function () {
+    if (tmpDir) {
+      try {
+        process.chdir(origCwd);
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      } catch (e) {
+        // ignore
+      }
+    }
+  });
+
+  it("debug_render should return diagnostics including note_count and global_vars", function () {
+    const dbg = core.pkg && core.pkg.debug_render;
+    if (typeof dbg !== "function") {
+      // skip if wasm binding missing
+      // eslint-disable-next-line no-invalid-this
+      this.skip();
+    }
+
+    const sampleProgram = `# sample program\nbpm 120\n\ngroup myLead:\n  let mySynth = synth sine\n  mySynth -> note(C4, { duration: 400 })\n  mySynth -> note(G4, { duration: 400 })\ncall myLead\n`;
+
+    const out = dbg(sampleProgram);
+    expect(out).to.be.an("object");
+    expect(out).to.have.property("samples_len");
+    expect(out).to.have.property("any_nonzero");
+    expect(out).to.have.property("note_count");
+    expect(out).to.have.property("global_vars");
+
+    // Basic assertions: at least one non-zero sample or note_count > 0
+    expect(out.note_count).to.be.at.least(0);
+    expect(out.global_vars).to.include("myLead");
+  });
+
+  it("render_audio should return a Float32Array and not be completely silent", function () {
+    const render = (core.pkg && core.pkg.render_audio) || core.render_audio;
+    if (typeof render !== "function") {
+      // eslint-disable-next-line no-invalid-this
+      this.skip();
+    }
+
+    const sampleProgram = `# sample program\nbpm 120\n\ngroup myLead:\n  let mySynth = synth sine\n  mySynth -> note(C4, { duration: 400 })\n  mySynth -> note(G4, { duration: 400 })\ncall myLead\n`;
+
+    const arr = render(sampleProgram);
+    // If wasm returns JS typed array wrapper, check constructor name
+    expect(arr.constructor && arr.constructor.name).to.match(
+      /Float32Array|Float64Array|ArrayBuffer|Uint8Array/
+    );
+
+    // Convert to plain array if needed
+    const samples: number[] = Array.from(arr as any);
+    // Expect either note_count > 0 indirectly via nonzero samples
+    const anyNonZero = samples.some((s) => s !== 0);
+    expect(anyNonZero).to.be.true;
+  });
+});

package/tsconfig.json

@@ -11,7 +11,7 @@
     // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
 
     /* Language and Environment */
-    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
     // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
     // "jsx": "preserve",                                /* Specify what JSX code is generated. */
     // "libReplacement": true,                           /* Enable lib replacement. */
@@ -26,8 +26,8 @@
     // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
 
     /* Modules */
-    "module": "commonjs",                                /* Specify what module code is generated. */
-    "rootDir": "./typescript",                                  /* Specify the root folder within your source files. */
+    "module": "commonjs" /* Specify what module code is generated. */,
+    "rootDir": "./typescript" /* Specify the root folder within your source files. */,
     // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
     // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
@@ -52,14 +52,14 @@
     // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
 
     /* Emit */
-    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
     // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
     // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
     // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
     // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
     // "noEmit": true,                                   /* Disable emitting files from a compilation. */
     // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-    "outDir": "./out-tsc",                                   /* Specify an output folder for all emitted files. */
+    "outDir": "./out-tsc" /* Specify an output folder for all emitted files. */,
     // "removeComments": true,                           /* Disable emitting comments. */
     // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
     // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
@@ -80,12 +80,12 @@
     // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
     // "erasableSyntaxOnly": true,                       /* Do not allow runtime constructs that are not part of ECMAScript. */
     // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
     // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
 
     /* Type Checking */
-    "strict": true,                                      /* Enable all strict type-checking options. */
+    "strict": true /* Enable all strict type-checking options. */,
     // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
     // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
@@ -108,6 +108,8 @@
 
     /* Completeness */
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
-  }
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  },
+  "include": ["typescript/**/*.ts"],
+  "exclude": ["node_modules", "out-tsc", "target", "dist", "**/*.spec.ts"]
 }

package/typescript/bin/index.ts

@@ -1,14 +1,28 @@
 #!/usr/bin/env node
 
 import { spawn } from "child_process";
-import path from "path";
+import * as path from "path";
 
-const binaryPath = path.join(__dirname, "devalang.exe");
+let binaryName: string;
 
-const subCommand = process.argv[2] || "help";
+switch (process.platform) {
+  case "win32":
+    binaryName = "devalang-x86_64-pc-windows-msvc.exe";
+    break;
+  case "darwin":
+    binaryName = "devalang-x86_64-apple-darwin";
+    break;
+  case "linux":
+    binaryName = "devalang-x86_64-unknown-linux-gnu";
+    break;
+  default:
+    console.error(`Unsupported platform: ${process.platform}`);
+    process.exit(1);
+}
+
+const binaryPath = path.join(__dirname, binaryName);
 
 const args = process.argv.slice(2);
 const child = spawn(binaryPath, args, { stdio: "inherit" });
 
-
-child.on("exit", (code) => process.exit(code));
+child.on("exit", (code) => process.exit(code ?? 1));

package/typescript/core/functions/index.ts

@@ -0,0 +1,94 @@
+import { ParseResult } from "../types/result";
+import { DebugResult } from "../types/result";
+
+let wasmPkg: any = undefined;
+try {
+  // prefer runtime pkg generated by wasm-pack when available
+  // require at runtime so the package can be used even if wasm hasn't been built
+  // (this keeps tests and consumers robust).
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  wasmPkg = require("../../pkg/devalang_core");
+} catch (_e) {
+  wasmPkg = undefined;
+}
+
+/**
+ * Parses the user code.
+ * @param entry_path The entry path for the code.
+ * @param source The source code to parse.
+ * @returns ParseResult | any
+ */
+export function parse(entry_path: string, source: string): ParseResult | any {
+  if (wasmPkg && typeof wasmPkg.parse === "function") {
+    return wasmPkg.parse(entry_path, source);
+  }
+
+  throw new Error(
+    "WASM binding 'parse' not available. Build the wasm package or use the JS runtime."
+  );
+}
+
+/**
+ * Renders the debug information for the user code.
+ * @param user_code The user-provided code to render debug information for.
+ * @returns DebugResult | any
+ */
+export function debug_render(user_code: string): DebugResult | any {
+  if (wasmPkg && typeof wasmPkg.debug_render === "function") {
+    return wasmPkg.debug_render(user_code);
+  }
+
+  throw new Error(
+    "WASM binding 'debug_render' not available. Build the wasm package or use the JS runtime."
+  );
+}
+
+/**
+ * Renders audio from the user code.
+ * @param user_code The user-provided code to render audio from.
+ * @returns Float32Array
+ */
+export function render_audio(user_code: string): Float32Array {
+  if (wasmPkg && typeof wasmPkg.render_audio === "function") {
+    return wasmPkg.render_audio(user_code);
+  }
+
+  // Fallback: indicate missing wasm with an empty buffer rather than breaking consumers.
+  return new Float32Array(0);
+}
+
+/**
+ * Register a JS callback to receive playhead events { time, line, column } during playback.
+ * The callback will be called with a single object argument.
+ * @param cb The callback function to register.
+ * @returns void
+ */
+export function register_playhead_callback(cb: (ev: { time: number; line: number; column: number }) => void) {
+  if (wasmPkg && typeof wasmPkg.register_playhead_callback === "function") {
+    return wasmPkg.register_playhead_callback(cb);
+  }
+  // no-op fallback
+  return;
+}
+
+/**
+ * Collects playhead events that have been recorded during playback.
+ * @returns Array of playhead events { time, line, column }.
+ */
+export function collect_playhead_events() {
+  if (wasmPkg && typeof wasmPkg.collect_playhead_events === "function") {
+    return wasmPkg.collect_playhead_events();
+  }
+  return [];
+}
+
+/**
+ * Unregisters the JS callback for playhead events.
+ * @returns void
+ */
+export function unregister_playhead_callback() {
+  if (wasmPkg && typeof wasmPkg.unregister_playhead_callback === "function") {
+    return wasmPkg.unregister_playhead_callback();
+  }
+  return;
+}

package/typescript/core/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Core functionality for the Devalang language.
+ * This module exports all the core types and functions used in the language.
+ */
+export * from "./types/index";
+export * from "./functions/index";

package/typescript/core/types/index.ts

@@ -0,0 +1,4 @@
+export * from "./result";
+export * from "./statement";
+export * from "./value";
+export * from "./plugin";

package/typescript/core/types/plugin.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a plugin export.
+ */
+export interface PluginExport {
+  name: string;
+  kind: string;
+  default?: any;
+}
+
+/**
+ * Represents a plugin.
+ */
+export interface PluginInfo {
+  author: string;
+  name: string;
+  version?: string;
+  description?: string;
+  exports: PluginExport[];
+}

package/typescript/core/types/result.ts

@@ -0,0 +1,29 @@
+/**
+ * Represents an error that occurred during parsing.
+ */
+export interface ErrorResult {
+  message: string;
+  line: number;
+  column: number;
+}
+
+/**
+ * Represents the result of parsing user code.
+ */
+export interface ParseResult {
+  ok: boolean;
+  ast: string;
+  errors: ErrorResult[];
+}
+
+/**
+ * Represents the result of debugging user code.
+ */
+export interface DebugResult {
+  samples_len: number;
+  any_nonzero: boolean;
+  ast: string;
+  note_count: number;
+  global_vars: string[];
+  statements_count: number;
+}

package/typescript/core/types/statement.ts

@@ -0,0 +1,47 @@
+import { Value, Duration } from "./value";
+
+/**
+ * Represents a statement kind in the code.
+ */
+ export type StatementKind =
+   | { kind: "Tempo" }
+   | { kind: "Bank"; alias?: string }
+   | { kind: "Print" }
+   | { kind: "Load"; source: string; alias: string }
+   | { kind: "Use"; name: string; alias?: string }
+   | { kind: "Let"; name: string }
+   | { kind: "Automate"; target: string }
+   | { kind: "ArrowCall"; target: string; method: string; args: Value[] }
+   | { kind: "Function"; name: string; parameters: string[]; body: Statement[] }
+   | { kind: "Synth" }
+   | { kind: "Trigger"; entity: string; duration: Duration; effects?: Value }
+   | { kind: "Sleep" }
+   | { kind: "Call"; name: string; args: Value[] }
+   | { kind: "Spawn"; name: string; args: Value[] }
+   | { kind: "Loop" }
+   | { kind: "Group" }
+   | { kind: "Include"; path: string }
+   | { kind: "Export"; names: string[]; source: string }
+   | { kind: "Import"; names: string[]; source: string }
+   | { kind: "If" }
+   | { kind: "Else" }
+   | { kind: "ElseIf" }
+   | { kind: "Comment" }
+   | { kind: "Indent" }
+   | { kind: "Dedent" }
+   | { kind: "NewLine" }
+   | { kind: "On"; event: string; args?: Value[]; body: Statement[] }
+   | { kind: "Emit"; event: string; payload?: Value }
+   | { kind: "Unknown" }
+   | { kind: "Error"; message: string };
+
+/**
+ * Represents a statement in the code.
+ */
+ export interface Statement {
+   kind: StatementKind;
+   value: Value;
+   indent: number;
+   line: number;
+   column: number;
+ }

package/typescript/core/types/value.ts

@@ -0,0 +1,29 @@
+import { Statement } from "./statement";
+
+/**
+ * Represents a duration in the code.
+ */
+export type Duration =
+  | { Number: number }
+  | { Identifier: string }
+  | { Beat: string }
+  | { Auto: null };
+
+/**
+ * Represents a value in the code.
+ */
+export type Value =
+  | { Boolean: boolean }
+  | { Number: number }
+  | { Duration: Duration }
+  | { Identifier: string }
+  | { String: string }
+  | { Array: Value[] }
+  | { Map: Record<string, Value> }
+  | { Block: Statement[] }
+  | { Sample: string }
+  | { Beat: string }
+  | { Statement: Statement }
+  | { StatementKind: any }
+  | { Unknown: null }
+  | null;

package/typescript/index.ts

@@ -1 +1,8 @@
-// This file is part of the Devalang project
+/**
+ * Public TypeScript definitions for Devalang.
+ * ————————————————————————————————————————
+ * Used to provide TypeScript types for the Devalang WASM package.
+ */
+
+export * as pkg from "./pkg/devalang_core";
+export * as core from "./core/index";

package/typescript/pkg/devalang_core.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This module exports all the core types and functions used in the WASM package.
+ */
+export * from "../../pkg/devalang_core";

package/typescript/pkg/devalang_core.ts

@@ -0,0 +1,65 @@
+/**
+ * Shim TypeScript source that re-exports the runtime wasm-pack package when
+ * available, or provides safe stubs when not present. Compiles to
+ * out-tsc/pkg/devalang_core.js so compiled code can require("./pkg/devalang_core").
+ */
+let runtimePkg: any;
+try {
+  // prefer runtime pkg generated by wasm-pack when available
+  // require at runtime so the package can be used even if wasm hasn't been built
+  // (this keeps tests and consumers robust).
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  runtimePkg = require("../../pkg/devalang_core");
+} catch (e) {
+  runtimePkg = undefined;
+}
+
+export function parse(...args: any[]) {
+  if (runtimePkg && typeof runtimePkg.parse === "function")
+    return runtimePkg.parse(...args);
+  throw new Error("WASM package not built: pkg/devalang_core not found");
+}
+
+export function debug_render(...args: any[]) {
+  if (runtimePkg && typeof runtimePkg.debug_render === "function")
+    return runtimePkg.debug_render(...args);
+  throw new Error("WASM package not built: pkg/devalang_core not found");
+}
+
+export function render_audio(...args: any[]) {
+  if (runtimePkg && typeof runtimePkg.render_audio === "function")
+    return runtimePkg.render_audio(...args);
+  return new Float32Array(0);
+}
+
+export function register_playhead_callback(cb?: any) {
+  if (runtimePkg && typeof runtimePkg.register_playhead_callback === "function")
+    return runtimePkg.register_playhead_callback(cb);
+  return;
+}
+
+export function collect_playhead_events() {
+  if (runtimePkg && typeof runtimePkg.collect_playhead_events === "function") {
+    return runtimePkg.collect_playhead_events();
+  }
+  return [];
+}
+
+export function unregister_playhead_callback() {
+  if (
+    runtimePkg &&
+    typeof runtimePkg.unregister_playhead_callback === "function"
+  )
+    return runtimePkg.unregister_playhead_callback();
+  return;
+}
+
+const pkg = {
+  parse,
+  debug_render,
+  render_audio,
+  register_playhead_callback,
+  collect_playhead_events,
+  unregister_playhead_callback,
+};
+export default pkg;

package/typescript/scripts/copy-wasm-dts.ts

@@ -0,0 +1,41 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Copies .d.ts files from pkg/ (wasm-pack output) into out-tsc/pkg/
+const ROOT = path.resolve(__dirname, '..', '..');
+const PKG_DIR = path.join(ROOT, 'pkg');
+const OUT_DIR = path.join(ROOT, 'out-tsc', 'pkg');
+
+function ensureDir(p: string): void {
+  if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true });
+}
+
+function copyDir(src: string, dest: string): void {
+  ensureDir(dest);
+  const items = fs.readdirSync(src, { withFileTypes: true });
+  for (const item of items) {
+    const srcPath = path.join(src, item.name);
+    const destPath = path.join(dest, item.name);
+    if (item.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else if (item.isFile() && item.name.endsWith('.d.ts')) {
+      fs.copyFileSync(srcPath, destPath);
+      console.log('copied', srcPath, '->', destPath);
+    }
+  }
+}
+
+function main(): number {
+  if (!fs.existsSync(PKG_DIR)) {
+    console.error('pkg directory not found at', PKG_DIR);
+    return 1;
+  }
+
+  ensureDir(OUT_DIR);
+  copyDir(PKG_DIR, OUT_DIR);
+  console.log('done');
+  return 0;
+}
+
+const exitCode = main();
+if (exitCode !== 0) process.exit(exitCode);

package/typescript/scripts/postinstall.ts

@@ -0,0 +1,85 @@
+import { createWriteStream, mkdirSync } from "fs";
+import { join } from "path";
+import { https } from "follow-redirects";
+import fs from "fs";
+import path from "path";
+
+const projectVersionPath = path.join(__dirname, "../../project-version.json");
+let versionString = "";
+try {
+  if (!fs.existsSync(projectVersionPath)) {
+    console.warn(`⚠️  project-version.json not found at ${projectVersionPath}. Skipping postinstall binary download.`);
+  } else {
+    const version = fs.readFileSync(projectVersionPath, "utf-8").trim();
+    try {
+      versionString = JSON.parse(version).version;
+    } catch (e: any) {
+      console.warn(`⚠️  Failed to parse project-version.json: ${e.message}. Skipping binary download.`);
+      versionString = "";
+    }
+  }
+} catch (e: any) {
+  console.warn(`⚠️  Could not read project-version.json: ${e.message}. Skipping binary download.`);
+  versionString = "";
+}
+
+const platform = process.platform;
+
+let binaryName: string = "";
+
+switch (platform) {
+  case "win32":
+    binaryName = "devalang-x86_64-pc-windows-msvc.exe";
+    break;
+  case "darwin":
+    binaryName = "devalang-x86_64-apple-darwin";
+    break;
+  case "linux":
+    binaryName = "devalang-x86_64-unknown-linux-gnu";
+    break;
+}
+
+if (binaryName !== "" && versionString) {
+  const destDir = join(__dirname, "..", "..", "out-tsc", "bin");
+  const dest = join(destDir, binaryName);
+  const url = `https://github.com/devaloop-labs/devalang/releases/download/v${versionString}/${binaryName}`;
+
+  mkdirSync(destDir, { recursive: true });
+
+  console.log(`⬇️  Downloading ${binaryName} from ${url}`);
+
+  const req = https.get(url, (res: any) => {
+    if (res.statusCode === 404) {
+      console.warn(`⚠️  Asset not found (HTTP 404). Skipping binary download.`);
+      res.resume();
+      return;
+    }
+
+    if (res.statusCode !== 200) {
+      console.warn(`⚠️  Failed (HTTP ${res.statusCode}). Skipping binary download.`);
+      res.resume();
+      return;
+    }
+
+    const file = createWriteStream(dest, { mode: 0o755 });
+    res.pipe(file);
+    file.on("finish", () => {
+      file.close();
+      console.log(`✅ Downloaded ${binaryName} to ${dest}`);
+    });
+  });
+
+  req.setTimeout(30000, () => {
+    console.warn(`⚠️  Download timed out after 30s. Skipping binary download for ${binaryName}.`);
+    try {
+      req.destroy();
+    } catch (e) {}
+  });
+
+  req.on("error", (err: any) => {
+    // Network or other errors should not fail CI; log and continue
+    console.warn(`⚠️  Error downloading binary: ${err.message}. Skipping binary download.`);
+  });
+} else {
+  console.warn(`⚠️  Unsupported platform: ${platform}. Skipping binary download.`);
+}

package/typescript/scripts/version/bump.ts

@@ -1,5 +1,4 @@
 import fs from "fs";
-import path from "path";
 
 export const bumpVersion = async (bumpType: string, projectVersionPath: string) => {
     const versionData = JSON.parse(fs.readFileSync(projectVersionPath, "utf-8"));

package/typescript/scripts/version/index.ts

@@ -1,5 +1,4 @@
 import path from "path";
-import fs from "fs";
 
 import { bumpVersion } from "./bump";
 import { syncVersion } from "./sync";