nova64 0.2.1

package/runtime/gpu-webgl2.js

@@ -0,0 +1,310 @@
+// runtime/gpu-webgl2.js
+// WebGL2 backend with RGBA16F upload + tone mapping and a simple sprite renderer.
+import { Framebuffer64 } from './framebuffer.js';
+
+const VERT_FSQ = `#version 300 es
+precision highp float;
+layout(location=0) in vec2 a_pos;
+out vec2 v_uv;
+void main() {
+  v_uv = 0.5 * (a_pos + 1.0);
+  gl_Position = vec4(a_pos, 0.0, 1.0);
+}`;
+
+const FRAG_TONEMAP = `#version 300 es
+precision highp float;
+in vec2 v_uv;
+out vec4 o_col;
+uniform sampler2D u_tex;
+// Simple ACES-like tonemapper (approx) then gamma to sRGB.
+vec3 tonemapACES( vec3 x ) {
+  float a = 2.51, b = 0.03, c = 2.43, d = 0.59, e = 0.14;
+  return clamp((x*(a*x+b))/(x*(c*x+d)+e), 0.0, 1.0);
+}
+void main() {
+  vec4 c = texture(u_tex, v_uv);
+  c.rgb = tonemapACES(c.rgb);
+  c.rgb = pow(c.rgb, vec3(1.0/2.2));
+  o_col = c;
+}`;
+
+// Sprite shader (screen-space)
+const VERT_SPR = `#version 300 es
+precision highp float;
+layout(location=0) in vec2 a_pos;      // quad verts in pixels (0..1) scaled in VS
+layout(location=1) in vec2 i_pos;      // instance: screen position (pixels)
+layout(location=2) in vec2 i_size;     // instance: size in pixels
+layout(location=3) in vec4 i_uv;       // instance: uv rect (u0,v0,u1,v1)
+out vec2 v_uv;
+uniform vec2 u_resolution;
+void main() {
+  vec2 px = i_pos + a_pos * i_size;     // pixel space
+  v_uv = mix(i_uv.xy, i_uv.zw, a_pos);
+  vec2 ndc = (px / u_resolution)*2.0 - 1.0;
+  ndc.y = -ndc.y;
+  gl_Position = vec4(ndc, 0.0, 1.0);
+}`;
+
+const FRAG_SPR = `#version 300 es
+precision highp float;
+in vec2 v_uv;
+out vec4 o_col;
+uniform sampler2D u_tex;
+void main(){
+  vec4 c = texture(u_tex, v_uv);
+  o_col = c;
+}`;
+
+export class GpuWebGL2 {
+  constructor(canvas, w, h) {
+    this.canvas = canvas;
+    /** @type {WebGL2RenderingContext} */
+    const gl = canvas.getContext('webgl2', {
+      antialias: false,
+      alpha: false,
+      premultipliedAlpha: false,
+    });
+    if (!gl) throw new Error('WebGL2 not supported');
+    this.gl = gl;
+    this.fb = new Framebuffer64(w, h);
+    this.w = w;
+    this.h = h;
+
+    // Programs
+    this.progFSQ = this._makeProgram(VERT_FSQ, FRAG_TONEMAP);
+    this.progSPR = this._makeProgram(VERT_SPR, FRAG_SPR);
+
+    // Fullscreen triangle VBO
+    this.vboFSQ = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.vboFSQ);
+    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 3, -1, -1, 3]), gl.STATIC_DRAW);
+
+    // Quad for sprites (two-triangle unit quad encoded as [0,0]-[1,1])
+    this.vboQuad = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.vboQuad);
+    gl.bufferData(
+      gl.ARRAY_BUFFER,
+      new Float32Array([0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1]),
+      gl.STATIC_DRAW
+    );
+
+    // Instance buffers
+    this.instPos = gl.createBuffer();
+    this.instSize = gl.createBuffer();
+    this.instUV = gl.createBuffer();
+
+    // Texture for framebuffer upload (RGBA16F, accepts FLOAT data)
+    this.texFB = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, this.texFB);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA16F, w, h, 0, gl.RGBA, gl.FLOAT, null);
+
+    this.tmpF32 = new Float32Array(w * h * 4); // normalized 0..1
+
+    // Sprite batch state
+    this.spriteBatches = new Map(); // texture -> array of instances
+    this.texCache = new WeakMap(); // HTMLImageElement -> WebGLTexture
+
+    gl.enable(gl.BLEND);
+    gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+    gl.viewport(0, 0, canvas.width, canvas.height);
+  }
+
+  _makeProgram(vsSrc, fsSrc) {
+    const gl = this.gl;
+    const vs = gl.createShader(gl.VERTEX_SHADER);
+    gl.shaderSource(vs, vsSrc);
+    gl.compileShader(vs);
+    if (!gl.getShaderParameter(vs, gl.COMPILE_STATUS)) throw new Error(gl.getShaderInfoLog(vs));
+    const fs = gl.createShader(gl.FRAGMENT_SHADER);
+    gl.shaderSource(fs, fsSrc);
+    gl.compileShader(fs);
+    if (!gl.getShaderParameter(fs, gl.COMPILE_STATUS)) throw new Error(gl.getShaderInfoLog(fs));
+    const p = gl.createProgram();
+    gl.attachShader(p, vs);
+    gl.attachShader(p, fs);
+    gl.linkProgram(p);
+    if (!gl.getProgramParameter(p, gl.LINK_STATUS)) throw new Error(gl.getProgramInfoLog(p));
+    return p;
+  }
+
+  beginFrame() {
+    const gl = this.gl;
+    gl.viewport(0, 0, this.canvas.width, this.canvas.height);
+    gl.clearColor(0, 0, 0, 1);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+  }
+
+  // Queue a sprite instance; img is HTMLImageElement, uv rect in pixels of the image
+  queueSprite(img, sx, sy, sw, sh, dx, dy, scale = 1) {
+    const gltex = this._getTexture(img);
+    let arr = this.spriteBatches.get(gltex);
+    if (!arr) {
+      arr = [];
+      this.spriteBatches.set(gltex, arr);
+    }
+    arr.push({
+      sx,
+      sy,
+      sw,
+      sh,
+      dx,
+      dy,
+      scale,
+      tex: gltex,
+      iw: img.naturalWidth,
+      ih: img.naturalHeight,
+    });
+  }
+
+  _getTexture(img) {
+    let tex = this.texCache.get(img);
+    if (tex) return tex;
+    const gl = this.gl;
+    tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.RGBA,
+      img.naturalWidth,
+      img.naturalHeight,
+      0,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      img
+    );
+    this.texCache.set(img, tex);
+    return tex;
+  }
+
+  endFrame() {
+    const gl = this.gl;
+
+    // Upload framebuffer as RGBA16F using Float32 normalized data
+    const p = this.fb.pixels;
+    const f = this.tmpF32;
+    let k = 0;
+    for (let i = 0; i < p.length; i += 4) {
+      f[k++] = p[i] / 65535.0;
+      f[k++] = p[i + 1] / 65535.0;
+      f[k++] = p[i + 2] / 65535.0;
+      f[k++] = p[i + 3] / 65535.0;
+    }
+    gl.bindTexture(gl.TEXTURE_2D, this.texFB);
+    gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, this.w, this.h, gl.RGBA, gl.FLOAT, f);
+
+    // Draw FSQ with tone mapping
+    gl.useProgram(this.progFSQ);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, this.texFB);
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.vboFSQ);
+    gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+    gl.enableVertexAttribArray(0);
+    gl.drawArrays(gl.TRIANGLES, 0, 3);
+
+    // Draw sprite batches on top
+    if (this.spriteBatches.size) {
+      gl.useProgram(this.progSPR);
+      const uRes = gl.getUniformLocation(this.progSPR, 'u_resolution');
+      gl.uniform2f(uRes, this.canvas.width, this.canvas.height);
+      // bind quad verts
+      gl.bindBuffer(gl.ARRAY_BUFFER, this.vboQuad);
+      gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+      gl.enableVertexAttribArray(0);
+
+      // instance attribute locations
+      gl.bindBuffer(gl.ARRAY_BUFFER, this.instPos);
+      gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 0, 0);
+      gl.enableVertexAttribArray(1);
+      gl.vertexAttribDivisor(1, 1);
+
+      gl.bindBuffer(gl.ARRAY_BUFFER, this.instSize);
+      gl.vertexAttribPointer(2, 2, gl.FLOAT, false, 0, 0);
+      gl.enableVertexAttribArray(2);
+      gl.vertexAttribDivisor(2, 1);
+
+      gl.bindBuffer(gl.ARRAY_BUFFER, this.instUV);
+      gl.vertexAttribPointer(3, 4, gl.FLOAT, false, 0, 0);
+      gl.enableVertexAttribArray(3);
+      gl.vertexAttribDivisor(3, 1);
+
+      for (const [tex, arr] of this.spriteBatches.entries()) {
+        const n = arr.length;
+        const pos = new Float32Array(n * 2);
+        const size = new Float32Array(n * 2);
+        const uvs = new Float32Array(n * 4);
+        for (let i = 0; i < n; i++) {
+          const s = arr[i];
+          pos[i * 2 + 0] = s.dx;
+          pos[i * 2 + 1] = s.dy;
+          size[i * 2 + 0] = s.sw * s.scale;
+          size[i * 2 + 1] = s.sh * s.scale;
+          const u0 = s.sx / s.iw,
+            v0 = s.sy / s.ih;
+          const u1 = (s.sx + s.sw) / s.iw,
+            v1 = (s.sy + s.sh) / s.ih;
+          uvs[i * 4 + 0] = u0;
+          uvs[i * 4 + 1] = v0;
+          uvs[i * 4 + 2] = u1;
+          uvs[i * 4 + 3] = v1;
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, this.instPos);
+        gl.bufferData(gl.ARRAY_BUFFER, pos, gl.DYNAMIC_DRAW);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this.instSize);
+        gl.bufferData(gl.ARRAY_BUFFER, size, gl.DYNAMIC_DRAW);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this.instUV);
+        gl.bufferData(gl.ARRAY_BUFFER, uvs, gl.DYNAMIC_DRAW);
+
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.drawArraysInstanced(gl.TRIANGLES, 0, 6, n);
+      }
+
+      this.spriteBatches.clear();
+    }
+  }
+
+  // API surface hooks needed by higher-level APIs
+  getFramebuffer() {
+    return this.fb;
+  }
+  supportsSpriteBatch() {
+    return true;
+  }
+
+  updateTextureForImage(img) {
+    const gl = this.gl;
+    let tex = this.texCache.get(img);
+    if (!tex) {
+      tex = gl.createTexture();
+      this.texCache.set(img, tex);
+    }
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.RGBA,
+      img.naturalWidth,
+      img.naturalHeight,
+      0,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      img
+    );
+  }
+}

package/runtime/index.js

@@ -0,0 +1,22 @@
+// runtime/index.js
+// Public entry point for the Nova64 runtime package
+
+export { threeDApi } from './api-3d.js';
+export { uiApi } from './ui.js';
+export { logger } from './logger.js';
+
+// Re-export sub-modules for tree-shaking
+export * from './api-3d/materials.js';
+export * from './api-3d/primitives.js';
+export * from './api-3d/transforms.js';
+export * from './api-3d/camera.js';
+export * from './api-3d/lights.js';
+export * from './api-3d/models.js';
+export * from './api-3d/instancing.js';
+export * from './api-3d/pbr.js';
+export * from './api-3d/scene.js';
+
+export * from './ui/text.js';
+export * from './ui/panels.js';
+export * from './ui/buttons.js';
+export * from './ui/widgets.js';

package/runtime/input.js

@@ -0,0 +1,225 @@
+// runtime/input.js
+// Gamepad button mapping (standard gamepad layout)
+const GAMEPAD_BUTTONS = {
+  0: 12, // A button → Start (button 12)
+  1: 13, // B button → Select (button 13)
+  2: 4, // X button → button 4
+  3: 5, // Y button → button 5
+  4: 6, // LB → button 6
+  5: 7, // RB → button 7
+  6: 8, // LT → button 8
+  7: 9, // RT → button 9
+  8: 13, // Select → button 13
+  9: 12, // Start → button 12
+  12: 0, // D-pad Up → button 0
+  13: 3, // D-pad Down → button 3
+  14: 1, // D-pad Left → button 1
+  15: 2, // D-pad Right → button 2
+};
+
+const KEYMAP = {
+  // arrows + Z X C V
+  0: 'ArrowLeft', // left
+  1: 'ArrowRight', // right
+  2: 'ArrowUp', // up
+  3: 'ArrowDown', // down
+  4: 'KeyZ',
+  5: 'KeyX',
+  6: 'KeyC',
+  7: 'KeyV',
+  8: 'KeyA',
+  9: 'KeyS',
+  10: 'KeyQ',
+  11: 'KeyW',
+  12: 'Enter', // Start
+  13: 'Space', // Select/Action
+};
+
+class Input {
+  constructor() {
+    this.keys = new Map();
+    this.prev = new Map();
+    this.mouse = { x: 0, y: 0, down: false, prevDown: false };
+    this.uiCallbacks = { setMousePosition: null, setMouseButton: null };
+
+    // Gamepad state
+    this.gamepadButtons = new Map();
+    this.gamepadPrev = new Map();
+    this.gamepadAxes = { leftX: 0, leftY: 0, rightX: 0, rightY: 0 };
+    this.gamepadDeadzone = 0.15;
+
+    if (typeof window !== 'undefined') {
+      window.addEventListener('keydown', e => {
+        this.keys.set(e.code, true);
+      });
+      window.addEventListener('keyup', e => {
+        this.keys.set(e.code, false);
+      });
+      window.addEventListener('blur', () => {
+        this.keys.clear();
+      });
+
+      // Mouse event listeners
+      window.addEventListener('mousemove', e => {
+        const canvas = document.querySelector('canvas');
+        if (canvas) {
+          const rect = canvas.getBoundingClientRect();
+          // Scale mouse position to Nova64's 640x360 resolution
+          this.mouse.x = Math.floor(((e.clientX - rect.left) / rect.width) * 640);
+          this.mouse.y = Math.floor(((e.clientY - rect.top) / rect.height) * 360);
+
+          // Update UI system if connected
+          if (this.uiCallbacks.setMousePosition) {
+            this.uiCallbacks.setMousePosition(this.mouse.x, this.mouse.y);
+          }
+        }
+      });
+
+      window.addEventListener('mousedown', _e => {
+        this.mouse.down = true;
+        if (this.uiCallbacks.setMouseButton) {
+          this.uiCallbacks.setMouseButton(true);
+        }
+      });
+
+      window.addEventListener('mouseup', _e => {
+        this.mouse.down = false;
+        if (this.uiCallbacks.setMouseButton) {
+          this.uiCallbacks.setMouseButton(false);
+        }
+      });
+
+      // Gamepad connection events
+      window.addEventListener('gamepadconnected', _e => {
+        // Gamepad connected
+      });
+
+      window.addEventListener('gamepaddisconnected', _e => {
+        this.gamepadButtons.clear();
+        this.gamepadPrev.clear();
+      });
+    }
+  }
+
+  pollGamepad() {
+    const gamepads = navigator.getGamepads ? navigator.getGamepads() : [];
+    const gamepad = gamepads[0]; // Use first connected gamepad
+
+    if (gamepad) {
+      // Read button states
+      gamepad.buttons.forEach((button, index) => {
+        const mappedButton = GAMEPAD_BUTTONS[index];
+        if (mappedButton !== undefined) {
+          this.gamepadButtons.set(mappedButton, button.pressed);
+        }
+      });
+
+      // Read axes with deadzone
+      if (gamepad.axes.length >= 4) {
+        this.gamepadAxes.leftX =
+          Math.abs(gamepad.axes[0]) > this.gamepadDeadzone ? gamepad.axes[0] : 0;
+        this.gamepadAxes.leftY =
+          Math.abs(gamepad.axes[1]) > this.gamepadDeadzone ? gamepad.axes[1] : 0;
+        this.gamepadAxes.rightX =
+          Math.abs(gamepad.axes[2]) > this.gamepadDeadzone ? gamepad.axes[2] : 0;
+        this.gamepadAxes.rightY =
+          Math.abs(gamepad.axes[3]) > this.gamepadDeadzone ? gamepad.axes[3] : 0;
+      }
+    }
+  }
+
+  // Connect UI system callbacks
+  connectUI(setMousePosition, setMouseButton) {
+    this.uiCallbacks.setMousePosition = setMousePosition;
+    this.uiCallbacks.setMouseButton = setMouseButton;
+  }
+  step() {
+    this.prev = new Map(this.keys);
+    this.mouse.prevDown = this.mouse.down;
+    this.gamepadPrev = new Map(this.gamepadButtons);
+    this.pollGamepad(); // Poll gamepad state every frame
+  }
+  btn(i) {
+    // Check keyboard OR gamepad
+    return !!this.keys.get(KEYMAP[i | 0] || '') || !!this.gamepadButtons.get(i | 0);
+  }
+  btnp(i) {
+    const code = KEYMAP[i | 0] || '';
+    const keyPressed = !!this.keys.get(code) && !this.prev.get(code);
+    const gamepadPressed = !!this.gamepadButtons.get(i | 0) && !this.gamepadPrev.get(i | 0);
+    return keyPressed || gamepadPressed;
+  }
+  key(code) {
+    return !!this.keys.get(code);
+  } // Direct key code checking — is currently held
+  keyp(code) {
+    return !!this.keys.get(code) && !this.prev.get(code);
+  } // just-pressed this frame
+
+  // Gamepad-specific functions
+  getGamepadAxis(axisName) {
+    return this.gamepadAxes[axisName] || 0;
+  }
+
+  isGamepadConnected() {
+    const gamepads = navigator.getGamepads ? navigator.getGamepads() : [];
+    return gamepads[0] !== null && gamepads[0] !== undefined;
+  }
+
+  // Helper functions for easier key checking
+  isKeyDown(keyCode) {
+    // Space must be checked before single-char conversion (' ' → 'Key ' is wrong)
+    if (keyCode === ' ') keyCode = 'Space';
+    // Handle single character keys by converting to KeyCode format
+    if (keyCode.length === 1) {
+      keyCode = 'Key' + keyCode.toUpperCase();
+    }
+    return !!this.keys.get(keyCode);
+  }
+
+  isKeyPressed(keyCode) {
+    // Space must be checked before single-char conversion (' ' → 'Key ' is wrong)
+    if (keyCode === ' ') keyCode = 'Space';
+    // Handle single character keys by converting to KeyCode format
+    if (keyCode.length === 1) {
+      keyCode = 'Key' + keyCode.toUpperCase();
+    }
+    return !!this.keys.get(keyCode) && !this.prev.get(keyCode);
+  }
+}
+
+export const input = new Input();
+
+export function inputApi() {
+  return {
+    exposeTo(target) {
+      Object.assign(target, {
+        btn: i => input.btn(i),
+        btnp: i => input.btnp(i),
+        key: code => input.key(code),
+        keyp: code => input.keyp(code),
+        isKeyDown: code => input.isKeyDown(code),
+        isKeyPressed: code => input.isKeyPressed(code),
+        // Mouse functions
+        mouseX: () => input.mouse.x,
+        mouseY: () => input.mouse.y,
+        mouseDown: () => input.mouse.down,
+        mousePressed: () => input.mouse.down && !input.mouse.prevDown,
+        // Gamepad functions
+        gamepadAxis: axisName => input.getGamepadAxis(axisName),
+        gamepadConnected: () => input.isGamepadConnected(),
+        // Axis aliases for convenience
+        leftStickX: () => input.getGamepadAxis('leftX'),
+        leftStickY: () => input.getGamepadAxis('leftY'),
+        rightStickX: () => input.getGamepadAxis('rightX'),
+        rightStickY: () => input.getGamepadAxis('rightY'),
+      });
+    },
+    step() {
+      input.step();
+    },
+    connectUI(setMousePosition, setMouseButton) {
+      input.connectUI(setMousePosition, setMouseButton);
+    },
+  };
+}

package/runtime/logger.js

@@ -0,0 +1,60 @@
+// runtime/logger.js
+// Configurable logging system for Nova64.
+// Replaces scattered console.log calls with leveled, history-tracked output.
+// In production builds the level is automatically raised to WARN.
+
+export const LogLevel = Object.freeze({ DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, NONE: 4 });
+
+class Logger {
+  constructor(initialLevel = LogLevel.INFO) {
+    this.level = initialLevel;
+    this.history = [];
+    this.maxHistory = 200;
+  }
+
+  _record(level, args) {
+    this.history.push({ level, args, ts: Date.now() });
+    if (this.history.length > this.maxHistory) this.history.shift();
+  }
+
+  debug(...args) {
+    if (this.level > LogLevel.DEBUG) return;
+    console.log('[Nova64:DEBUG]', ...args);
+    this._record('DEBUG', args);
+  }
+
+  info(...args) {
+    if (this.level > LogLevel.INFO) return;
+    console.log('[Nova64:INFO]', ...args);
+    this._record('INFO', args);
+  }
+
+  warn(...args) {
+    if (this.level > LogLevel.WARN) return;
+    console.warn('[Nova64:WARN]', ...args);
+    this._record('WARN', args);
+  }
+
+  error(...args) {
+    if (this.level > LogLevel.ERROR) return;
+    console.error('[Nova64:ERROR]', ...args);
+    this._record('ERROR', args);
+  }
+
+  setLevel(level) {
+    this.level = level;
+  }
+  getHistory() {
+    return [...this.history];
+  }
+  clearHistory() {
+    this.history = [];
+  }
+}
+
+export const logger = new Logger(
+  // Raise to WARN in production so debug noise is suppressed
+  typeof import.meta !== 'undefined' && import.meta.env && import.meta.env.PROD
+    ? LogLevel.WARN
+    : LogLevel.INFO
+);