@viji-dev/core 0.3.27 → 0.3.29

package/dist/assets/{viji.worker-jTmB7qoQ.js → viji.worker-CQSJ0SiO.js}

@@ -3083,6 +3083,9 @@ ${error}`);
     for (let i = 0; i < ShaderWorkerAdapter.MAX_VIDEO_STREAMS; i++) {
       this.textureUnits.set(`u_videoStream${i}`, this.nextTextureUnit++);
     }
+    for (let i = 0; i < ShaderWorkerAdapter.MAX_DEVICE_VIDEOS; i++) {
+      this.textureUnits.set(`u_device${i}`, this.nextTextureUnit++);
+    }
     if (this.backbufferEnabled) {
       this.textureUnits.set("backbuffer", this.nextTextureUnit++);
     }
@@ -3896,7 +3899,8 @@ ${error}`);
     }
     const texture = this.deviceTextures[index];
     if (!texture) return;
-    const textureUnit = 8 + index;
+    const textureUnit = this.textureUnits.get(`u_device${index}`);
+    if (textureUnit === void 0) return;
     this.gl.activeTexture(this.gl.TEXTURE0 + textureUnit);
     this.gl.bindTexture(this.gl.TEXTURE_2D, texture);
     const shouldFlip = frame instanceof OffscreenCanvas;
@@ -3918,6 +3922,11 @@ ${error}`);
     this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.LINEAR);
     this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE);
     this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE);
+    const uniformName = `u_device${index}`;
+    const location = this.uniformLocations.get(uniformName);
+    if (location) {
+      this.gl.uniform1i(location, textureUnit);
+    }
     if (frame instanceof ImageBitmap) {
       frame.close();
     }
@@ -4068,6 +4077,394 @@ ${error}`);
     if (this.quadBuffer) gl.deleteBuffer(this.quadBuffer);
   }
 }
+const _PK = {
+  kty: "EC",
+  crv: "P-256",
+  x: "6bkPbVZXx-c08blVs6qIwm0gfSRLS2nnf2Tsz19ggtM",
+  y: "lhi486ASKQkS8TGbVee-FpdAu7qKaO3gad_4ScX8qJI"
+};
+const GRACE_SECONDS = 60;
+let _key = null;
+let _restricted = false;
+let _cache = null;
+let _expiry = 0;
+function _b64url(s) {
+  const padded = s.replace(/-/g, "+").replace(/_/g, "/");
+  const bin = atob(padded);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+  return bytes;
+}
+async function init$1() {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    _restricted = true;
+    console.warn("[Viji] _SC: secure context required — restricted mode active");
+    return;
+  }
+  try {
+    _key = await crypto.subtle.importKey(
+      "jwk",
+      _PK,
+      { name: "ECDSA", namedCurve: "P-256" },
+      false,
+      ["verify"]
+    );
+  } catch {
+    _restricted = true;
+    console.warn("[Viji] _SC: key import failed — restricted mode active");
+  }
+}
+async function update(token) {
+  if (_restricted || !_key) {
+    _cache = null;
+    _expiry = 0;
+    return;
+  }
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) throw new Error("malformed");
+    const signingInput = new TextEncoder().encode(parts[0] + "." + parts[1]);
+    const signature = _b64url(parts[2]);
+    const valid = await crypto.subtle.verify(
+      { name: "ECDSA", hash: "SHA-256" },
+      _key,
+      signature.buffer,
+      signingInput.buffer
+    );
+    if (!valid) throw new Error("invalid signature");
+    const payload = JSON.parse(new TextDecoder().decode(_b64url(parts[1])));
+    _cache = payload.c ?? {};
+    _expiry = payload.e ?? 0;
+  } catch {
+    _cache = null;
+    _expiry = 0;
+  }
+}
+function get$1(key, defaultValue) {
+  if (_restricted || !_cache) return defaultValue;
+  const now = Math.floor(Date.now() / 1e3);
+  if (_expiry > 0 && _expiry + GRACE_SECONDS < now) {
+    _cache = null;
+    _expiry = 0;
+    return defaultValue;
+  }
+  return typeof _cache[key] === "number" ? _cache[key] : defaultValue;
+}
+const FULL_W = 44, FULL_H = 74;
+const MINI_W = 44, MINI_H = 23;
+const STROKE_COLOR = "#F1F1F1";
+let _bufferFull = null;
+let _bufferMini = null;
+let _glTexFull = null;
+let _glTexMini = null;
+let _glProgram = null;
+let _glVbo = null;
+let _glVao = null;
+let _glInitFor = null;
+let _hint = 0;
+const VERT_SRC = `
+attribute vec2 a_pos;
+attribute vec2 a_uv;
+varying vec2 v_uv;
+void main() {
+  v_uv = a_uv;
+  gl_Position = vec4(a_pos, 0.0, 1.0);
+}`;
+const FRAG_SRC = `
+precision mediump float;
+uniform sampler2D u_tex;
+uniform float u_alpha;
+varying vec2 v_uv;
+void main() {
+  gl_FragColor = texture2D(u_tex, v_uv) * u_alpha;
+}`;
+function renderFullLogo(ctx) {
+  ctx.strokeStyle = STROKE_COLOR;
+  ctx.lineCap = "round";
+  ctx.lineWidth = 2.8;
+  ctx.beginPath();
+  ctx.moveTo(21.9991, 5);
+  ctx.lineTo(5, 21.999);
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.moveTo(38.9981, 21.998);
+  ctx.lineTo(21.999, 38.9971);
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.moveTo(38.9984, 5);
+  ctx.lineTo(5, 38.9983);
+  ctx.stroke();
+  ctx.lineWidth = 3.5;
+  ctx.beginPath();
+  ctx.moveTo(5.00052, 5.00155);
+  ctx.lineTo(5.00098, 5);
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.moveTo(38.9986, 38.9996);
+  ctx.lineTo(38.999, 38.998);
+  ctx.stroke();
+  ctx.lineWidth = 2.8;
+  ctx.lineJoin = "round";
+  ctx.beginPath();
+  ctx.moveTo(5.875, 53);
+  ctx.lineTo(10.1417, 60);
+  ctx.lineTo(13.875, 53);
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.moveTo(21, 53);
+  ctx.lineTo(21, 60);
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.moveTo(38.125, 53);
+  ctx.lineTo(38.125, 60);
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.moveTo(30, 53);
+  ctx.lineTo(30, 62.1502);
+  ctx.bezierCurveTo(30, 64.2764, 28.2764, 66, 26.1502, 66);
+  ctx.lineTo(26, 66);
+  ctx.stroke();
+}
+function renderMiniLogo(ctx) {
+  ctx.strokeStyle = STROKE_COLOR;
+  ctx.lineCap = "round";
+  ctx.lineJoin = "round";
+  ctx.lineWidth = 2.8;
+  ctx.beginPath();
+  ctx.moveTo(5.875, 5);
+  ctx.lineTo(10.1417, 12);
+  ctx.lineTo(13.875, 5);
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.moveTo(21, 5);
+  ctx.lineTo(21, 12);
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.moveTo(38.125, 5);
+  ctx.lineTo(38.125, 12);
+  ctx.stroke();
+  ctx.beginPath();
+  ctx.moveTo(30, 5);
+  ctx.lineTo(30, 14.1502);
+  ctx.bezierCurveTo(30, 16.2764, 28.2764, 18, 26.1502, 18);
+  ctx.lineTo(26, 18);
+  ctx.stroke();
+}
+function init(_canvas) {
+  try {
+    _bufferFull = new OffscreenCanvas(FULL_W, FULL_H);
+    const ctxFull = _bufferFull.getContext("2d");
+    if (ctxFull) renderFullLogo(ctxFull);
+    _bufferMini = new OffscreenCanvas(MINI_W, MINI_H);
+    const ctxMini = _bufferMini.getContext("2d");
+    if (ctxMini) renderMiniLogo(ctxMini);
+  } catch (e) {
+    console.warn("[Viji] overlay: init failed", e);
+  }
+}
+function setRenderHint(h) {
+  _hint = h;
+}
+function draw(canvas, ctx, gl, brandingMode, displayScale = 1) {
+  if (brandingMode >= 2) return;
+  if (!_bufferFull && !_bufferMini) return;
+  const isMini = _hint === 1;
+  const s = displayScale || 1;
+  if (ctx) {
+    draw2D(ctx, isMini, canvas.width, s);
+  } else if (gl) {
+    drawGL(gl, canvas, isMini, s);
+  }
+}
+const GL_VERTEX_ARRAY_BINDING = 34229;
+function uploadTexture(gl, source) {
+  if (!source) return null;
+  const prevTexBinding = gl.getParameter(gl.TEXTURE_BINDING_2D);
+  const prevFlipY = gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL);
+  const prevPremultiply = gl.getParameter(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL);
+  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 1);
+  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0);
+  const tex = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, tex);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+  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.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
+  gl.bindTexture(gl.TEXTURE_2D, prevTexBinding);
+  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, prevFlipY ? 1 : 0);
+  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, prevPremultiply ? 1 : 0);
+  return tex;
+}
+function initGL(gl) {
+  if (_glInitFor === gl) return;
+  _glInitFor = gl;
+  _glTexFull = uploadTexture(gl, _bufferFull);
+  _glTexMini = uploadTexture(gl, _bufferMini);
+  const vs = gl.createShader(gl.VERTEX_SHADER);
+  gl.shaderSource(vs, VERT_SRC);
+  gl.compileShader(vs);
+  const fs = gl.createShader(gl.FRAGMENT_SHADER);
+  gl.shaderSource(fs, FRAG_SRC);
+  gl.compileShader(fs);
+  _glProgram = gl.createProgram();
+  gl.attachShader(_glProgram, vs);
+  gl.attachShader(_glProgram, fs);
+  gl.linkProgram(_glProgram);
+  gl.deleteShader(vs);
+  gl.deleteShader(fs);
+  if (!gl.getProgramParameter(_glProgram, gl.LINK_STATUS)) {
+    console.warn("[Viji] overlay: shader link failed");
+    _glProgram = null;
+    return;
+  }
+  _glVbo = gl.createBuffer();
+  const gl2 = gl;
+  if (typeof gl2.createVertexArray === "function") {
+    const prevVAO = gl.getParameter(GL_VERTEX_ARRAY_BINDING);
+    const prevBuf = gl.getParameter(gl.ARRAY_BUFFER_BINDING);
+    _glVao = gl2.createVertexArray();
+    gl2.bindVertexArray(_glVao);
+    gl.bindBuffer(gl.ARRAY_BUFFER, _glVbo);
+    const aPos = gl.getAttribLocation(_glProgram, "a_pos");
+    const aUv = gl.getAttribLocation(_glProgram, "a_uv");
+    gl.enableVertexAttribArray(aPos);
+    gl.enableVertexAttribArray(aUv);
+    gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
+    gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
+    gl2.bindVertexArray(prevVAO);
+    gl.bindBuffer(gl.ARRAY_BUFFER, prevBuf);
+  }
+}
+function draw2D(ctx, mini, canvasW, s) {
+  const buffer = mini ? _bufferMini : _bufferFull;
+  if (!buffer) return;
+  const drawW = (mini ? MINI_W : FULL_W) * s;
+  const drawH = (mini ? MINI_H : FULL_H) * s;
+  const x = mini ? Math.round((canvasW - drawW) / 2) : Math.round(48 * s);
+  const y = Math.round((mini ? 52 : 48) * s);
+  ctx.save();
+  ctx.globalAlpha = 0.85;
+  ctx.drawImage(buffer, x, y, drawW, drawH);
+  ctx.restore();
+}
+function drawGL(gl, canvas, mini, s) {
+  initGL(gl);
+  if (!_glProgram || !_glVbo) return;
+  const tex = mini ? _glTexMini : _glTexFull;
+  if (!tex) return;
+  const logoW = (mini ? MINI_W : FULL_W) * s;
+  const logoH = (mini ? MINI_H : FULL_H) * s;
+  const cw = canvas.width;
+  const ch = canvas.height;
+  const px = mini ? Math.round((cw - logoW) / 2) : Math.round(48 * s);
+  const py = Math.round((mini ? 52 : 48) * s);
+  const x0 = px / cw * 2 - 1;
+  const y0 = 1 - (py + logoH) / ch * 2;
+  const x1 = (px + logoW) / cw * 2 - 1;
+  const y1 = 1 - py / ch * 2;
+  const gl2 = gl;
+  const hasVAO = _glVao && typeof gl2.bindVertexArray === "function";
+  const prevProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+  const prevActiveTexture = gl.getParameter(gl.ACTIVE_TEXTURE);
+  gl.activeTexture(gl.TEXTURE0);
+  const prevTex0 = gl.getParameter(gl.TEXTURE_BINDING_2D);
+  const prevArrayBuffer = gl.getParameter(gl.ARRAY_BUFFER_BINDING);
+  const prevFramebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+  const prevViewport = gl.getParameter(gl.VIEWPORT);
+  const prevBlend = gl.isEnabled(gl.BLEND);
+  const prevBlendSrcRGB = gl.getParameter(gl.BLEND_SRC_RGB);
+  const prevBlendDstRGB = gl.getParameter(gl.BLEND_DST_RGB);
+  const prevBlendSrcAlpha = gl.getParameter(gl.BLEND_SRC_ALPHA);
+  const prevBlendDstAlpha = gl.getParameter(gl.BLEND_DST_ALPHA);
+  const prevBlendEqRGB = gl.getParameter(gl.BLEND_EQUATION_RGB);
+  const prevBlendEqAlpha = gl.getParameter(gl.BLEND_EQUATION_ALPHA);
+  const prevDepthTest = gl.isEnabled(gl.DEPTH_TEST);
+  const prevScissorTest = gl.isEnabled(gl.SCISSOR_TEST);
+  const prevStencilTest = gl.isEnabled(gl.STENCIL_TEST);
+  const prevCullFace = gl.isEnabled(gl.CULL_FACE);
+  const prevColorMask = gl.getParameter(gl.COLOR_WRITEMASK);
+  const prevUnpackFlipY = gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL);
+  const prevVAO = hasVAO ? gl.getParameter(GL_VERTEX_ARRAY_BINDING) : null;
+  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+  gl.viewport(0, 0, cw, ch);
+  gl.useProgram(_glProgram);
+  gl.enable(gl.BLEND);
+  gl.blendEquation(gl.FUNC_ADD);
+  gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+  gl.disable(gl.DEPTH_TEST);
+  gl.disable(gl.SCISSOR_TEST);
+  gl.disable(gl.STENCIL_TEST);
+  gl.disable(gl.CULL_FACE);
+  gl.colorMask(true, true, true, true);
+  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 0);
+  gl.bindTexture(gl.TEXTURE_2D, tex);
+  gl.uniform1i(gl.getUniformLocation(_glProgram, "u_tex"), 0);
+  gl.uniform1f(gl.getUniformLocation(_glProgram, "u_alpha"), 0.85);
+  const verts = new Float32Array([
+    x0,
+    y0,
+    0,
+    0,
+    x1,
+    y0,
+    1,
+    0,
+    x0,
+    y1,
+    0,
+    1,
+    x0,
+    y1,
+    0,
+    1,
+    x1,
+    y0,
+    1,
+    0,
+    x1,
+    y1,
+    1,
+    1
+  ]);
+  if (hasVAO) {
+    gl2.bindVertexArray(_glVao);
+    gl.bindBuffer(gl.ARRAY_BUFFER, _glVbo);
+    gl.bufferData(gl.ARRAY_BUFFER, verts, gl.DYNAMIC_DRAW);
+  } else {
+    gl.bindBuffer(gl.ARRAY_BUFFER, _glVbo);
+    gl.bufferData(gl.ARRAY_BUFFER, verts, gl.DYNAMIC_DRAW);
+    const aPos = gl.getAttribLocation(_glProgram, "a_pos");
+    const aUv = gl.getAttribLocation(_glProgram, "a_uv");
+    gl.enableVertexAttribArray(aPos);
+    gl.enableVertexAttribArray(aUv);
+    gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
+    gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
+  }
+  gl.drawArrays(gl.TRIANGLES, 0, 6);
+  if (hasVAO) gl2.bindVertexArray(prevVAO);
+  gl.bindFramebuffer(gl.FRAMEBUFFER, prevFramebuffer);
+  gl.viewport(prevViewport[0], prevViewport[1], prevViewport[2], prevViewport[3]);
+  gl.bindBuffer(gl.ARRAY_BUFFER, prevArrayBuffer);
+  gl.colorMask(prevColorMask[0], prevColorMask[1], prevColorMask[2], prevColorMask[3]);
+  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, prevUnpackFlipY ? 1 : 0);
+  if (prevScissorTest) gl.enable(gl.SCISSOR_TEST);
+  else gl.disable(gl.SCISSOR_TEST);
+  if (prevStencilTest) gl.enable(gl.STENCIL_TEST);
+  else gl.disable(gl.STENCIL_TEST);
+  if (prevCullFace) gl.enable(gl.CULL_FACE);
+  else gl.disable(gl.CULL_FACE);
+  if (prevDepthTest) gl.enable(gl.DEPTH_TEST);
+  else gl.disable(gl.DEPTH_TEST);
+  if (prevBlend) gl.enable(gl.BLEND);
+  else gl.disable(gl.BLEND);
+  gl.blendFuncSeparate(prevBlendSrcRGB, prevBlendDstRGB, prevBlendSrcAlpha, prevBlendDstAlpha);
+  gl.blendEquationSeparate(prevBlendEqRGB, prevBlendEqAlpha);
+  gl.activeTexture(gl.TEXTURE0);
+  gl.bindTexture(gl.TEXTURE_2D, prevTex0);
+  gl.activeTexture(prevActiveTexture);
+  gl.useProgram(prevProgram);
+}
 class VijiWorkerRuntime {
   canvas = null;
   ctx = null;
@@ -4087,6 +4484,8 @@ class VijiWorkerRuntime {
   // Shader adapter for shader mode
   shaderAdapter = null;
   rendererType = "native";
+  _isHeadless = false;
+  _displayScale = 1;
   // Pending capture requests (queue to handle multiple simultaneous requests)
   pendingCaptures = [];
   /**
@@ -4471,7 +4870,7 @@ class VijiWorkerRuntime {
       const message = event.data;
       switch (message.type) {
         case "init":
-          this.handleInit(message);
+          this.handleInit(message).catch((e) => console.error("[Viji] handleInit failed:", e));
           break;
         case "frame-rate-update":
           this.handleFrameRateUpdate(message);
@@ -4551,15 +4950,40 @@ class VijiWorkerRuntime {
         case "capture-frame":
           this.handleCaptureFrame(message);
           break;
+        case "sc-update":
+          update(message.data.t);
+          break;
+        case "rh-update":
+          setRenderHint(message.data.h);
+          break;
       }
     };
   }
-  handleInit(message) {
+  async handleInit(message) {
     try {
       this.canvas = message.data.canvas;
       this.viji.canvas = this.canvas;
+      this._isHeadless = !!message.data.isHeadless;
+      const origGetContext = this.canvas.getContext.bind(this.canvas);
+      this.canvas.getContext = (type, attrs) => {
+        const result = origGetContext(type, attrs);
+        if (result) {
+          if (type === "2d") {
+            this.ctx = result;
+            this.viji.ctx = this.ctx;
+          } else if (type === "webgl" || type === "webgl2") {
+            this.gl = result;
+            this.viji.gl = this.gl;
+          }
+        }
+        return result;
+      };
       this.viji.width = this.canvas.width;
       this.viji.height = this.canvas.height;
+      await init$1();
+      if (message.data.sc) await update(message.data.sc);
+      init(this.canvas);
+      if (message.data.rh !== void 0) setRenderHint(message.data.rh);
       this.startRenderLoop();
       this.postMessage("init-response", {
         id: message.id
@@ -4644,6 +5068,7 @@ class VijiWorkerRuntime {
       }
       this.viji.width = Math.round(message.data.effectiveWidth);
       this.viji.height = Math.round(message.data.effectiveHeight);
+      this._displayScale = message.data.displayScale ?? 1;
       if (this.gl) {
         this.gl.viewport(0, 0, this.viji.width, this.viji.height);
       }
@@ -4663,8 +5088,8 @@ class VijiWorkerRuntime {
   }
   handleParameterBatchUpdate(message) {
     if (message.data && message.data.updates) {
-      for (const update of message.data.updates) {
-        this.parameterSystem.updateParameterValue(update.name, update.value);
+      for (const update2 of message.data.updates) {
+        this.parameterSystem.updateParameterValue(update2.name, update2.value);
       }
       this.parameterSystem.markInitialValuesSynced();
       this.debugLog("Parameter system initialized successfully");
@@ -5133,6 +5558,10 @@ class VijiWorkerRuntime {
           console.warn("[AutoCapture] Failed:", error);
         }
       }
+      if (!this._isHeadless && this.canvas) {
+        const brandingMode = get$1("b", 0);
+        draw(this.canvas, this.ctx, this.gl, brandingMode, this._displayScale);
+      }
     }
     this.reportPerformanceStats(currentTime);
     this.interactionSystem.frameStart();
@@ -26586,4 +27015,4 @@ async function setSceneCode(sceneCode) {
   }
 }
 self.setSceneCode = setSceneCode;
-//# sourceMappingURL=viji.worker-jTmB7qoQ.js.map
+//# sourceMappingURL=viji.worker-CQSJ0SiO.js.map