@agent-native/core 0.121.2 → 0.122.0

package/corpus/templates/design/.generated/bridge/shader-runtime.generated.ts

@@ -0,0 +1,518 @@
+// AUTO-GENERATED by bridge/codegen.ts — do not edit manually.
+// Run: pnpm exec tsx app/components/design/bridge/codegen.ts
+
+/** Compiled IIFE string for shader-runtime.bridge.ts — inject into an iframe via srcdoc or a <script> tag. */
+export const shaderRuntimeBridgeScript: string = `"use strict";
+(() => {
+  // app/components/design/bridge/shader-runtime.bridge.ts
+  (function() {
+    const W = window;
+    if (W.__anShaders && W.__anShaders.version >= 1) {
+      try {
+        W.__anShaders.scan();
+      } catch (_err) {
+      }
+      return;
+    }
+    const SCRIPT_TYPE = "application/x-agent-native-shader";
+    const FILL_ATTR = "data-an-shader-fill";
+    const EFFECT_ATTR = "data-an-shader-effect";
+    const VALUES_ATTR = "data-an-shader-uniforms";
+    const EFFECT_VALUES_ATTR = "data-an-shader-effect-uniforms";
+    const ERROR_ATTR = "data-an-shader-error";
+    const CANVAS_ATTR = "data-an-shader-canvas";
+    const PREVIEW_DEF_ID = "__an-shader-preview";
+    const MAX_MOUNTS = 8;
+    const VERT_SRC = "attribute vec2 a_pos;void main(){gl_Position=vec4(a_pos,0.0,1.0);}";
+    const registry = {};
+    const mounts = [];
+    let rafId = null;
+    let needsRender = false;
+    let scanTimer = null;
+    function nowMs() {
+      return W.performance && W.performance.now ? W.performance.now() : Date.now();
+    }
+    const t0 = nowMs();
+    let reducedMotion = false;
+    try {
+      reducedMotion = !!(W.matchMedia && W.matchMedia("(prefers-reduced-motion: reduce)").matches);
+      if (W.matchMedia) {
+        const mq = W.matchMedia("(prefers-reduced-motion: reduce)");
+        const onChange = function() {
+          reducedMotion = mq.matches;
+          requestRender();
+        };
+        if (mq.addEventListener) mq.addEventListener("change", onChange);
+      }
+    } catch (_err) {
+    }
+    function parseBlock(text) {
+      const m = /^\\s*\\/\\*!\\s*an-shader\\s+v\\d+\\s*([\\s\\S]*?)\\*\\//.exec(text);
+      let uniforms = {};
+      let glsl = text;
+      if (m) {
+        glsl = text.slice((m.index || 0) + m[0].length);
+        try {
+          const meta = JSON.parse(m[1]);
+          if (meta && meta.uniforms && typeof meta.uniforms === "object") {
+            uniforms = meta.uniforms;
+          }
+        } catch (_err) {
+        }
+      }
+      return { uniforms, glsl: glsl.replace(/^[ \\t]*\\r?\\n/, "") };
+    }
+    function hexToRgb(hex) {
+      let h = String(hex || "").replace("#", "");
+      if (h.length === 3 || h.length === 4) {
+        h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+      }
+      const n = parseInt(h.slice(0, 6), 16);
+      if (isNaN(n)) return [0.5, 0.5, 0.5];
+      return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
+    }
+    function invalidateMountsFor(defId) {
+      for (let i = mounts.length - 1; i >= 0; i--) {
+        if (mounts[i].defId === defId) unmount(mounts[i]);
+      }
+    }
+    function collectDefs() {
+      const scripts = document.querySelectorAll(
+        'script[type="' + SCRIPT_TYPE + '"]'
+      );
+      for (let i = 0; i < scripts.length; i++) {
+        const s = scripts[i];
+        const id = s.getAttribute("data-shader-id");
+        if (!id) continue;
+        const text = s.textContent || "";
+        const prev = registry[id];
+        if (prev && prev.domText === text) continue;
+        if (prev && prev.volatile && prev.domText === void 0) continue;
+        const parsed = parseBlock(text);
+        registry[id] = {
+          name: s.getAttribute("data-shader-name") || id,
+          mode: s.getAttribute("data-shader-mode") === "effect" ? "effect" : "fill",
+          glsl: parsed.glsl,
+          uniforms: parsed.uniforms,
+          domText: text
+        };
+        if (prev && prev.glsl !== parsed.glsl) invalidateMountsFor(id);
+      }
+    }
+    function compileProgram(gl, fragSrc) {
+      function sh(type, src) {
+        const shader = gl.createShader(type);
+        if (!shader) throw new Error("createShader failed");
+        gl.shaderSource(shader, src);
+        gl.compileShader(shader);
+        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+          const log = gl.getShaderInfoLog(shader) || "shader compile failed";
+          gl.deleteShader(shader);
+          throw new Error(log);
+        }
+        return shader;
+      }
+      const vs = sh(gl.VERTEX_SHADER, VERT_SRC);
+      const fs = sh(gl.FRAGMENT_SHADER, fragSrc);
+      const program = gl.createProgram();
+      if (!program) throw new Error("createProgram failed");
+      gl.attachShader(program, vs);
+      gl.attachShader(program, fs);
+      gl.linkProgram(program);
+      if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+        throw new Error(gl.getProgramInfoLog(program) || "program link failed");
+      }
+      return program;
+    }
+    function resolveValues(def, overrides) {
+      const out = {};
+      for (const k in def.uniforms) {
+        if (!Object.prototype.hasOwnProperty.call(def.uniforms, k)) continue;
+        out[k] = def.uniforms[k].value;
+      }
+      if (overrides) {
+        for (const k2 in overrides) {
+          if (!Object.prototype.hasOwnProperty.call(overrides, k2)) continue;
+          if (Object.prototype.hasOwnProperty.call(out, k2)) {
+            out[k2] = overrides[k2];
+          }
+        }
+      }
+      return out;
+    }
+    let io = null;
+    try {
+      io = new IntersectionObserver(function(entries) {
+        for (let i = 0; i < entries.length; i++) {
+          for (let j = 0; j < mounts.length; j++) {
+            if (mounts[j].canvas === entries[i].target) {
+              mounts[j].visible = entries[i].isIntersecting;
+            }
+          }
+        }
+        startLoop();
+      });
+    } catch (_err) {
+      io = null;
+    }
+    function unmount(mount) {
+      const idx = mounts.indexOf(mount);
+      if (idx !== -1) mounts.splice(idx, 1);
+      try {
+        if (io) io.unobserve(mount.canvas);
+      } catch (_err) {
+      }
+      try {
+        const lose = mount.gl.getExtension("WEBGL_lose_context");
+        if (lose) lose.loseContext();
+      } catch (_err) {
+      }
+      if (mount.canvas.parentNode) {
+        mount.canvas.parentNode.removeChild(mount.canvas);
+      }
+    }
+    function ensureMount(el, defId, mode, overrides, preview) {
+      const def = registry[defId];
+      if (!def || !def.glsl) return null;
+      for (let i = 0; i < mounts.length; i++) {
+        const existing = mounts[i];
+        if (existing.el === el && existing.preview === preview && existing.mode === mode) {
+          if (existing.defId === defId) {
+            existing.values = resolveValues(def, overrides);
+            requestRender();
+            return existing;
+          }
+          unmount(existing);
+          break;
+        }
+      }
+      if (mounts.length >= MAX_MOUNTS) {
+        el.setAttribute(ERROR_ATTR, "too-many-shaders");
+        return null;
+      }
+      const canvas = document.createElement("canvas");
+      canvas.setAttribute(CANVAS_ATTR, defId);
+      canvas.setAttribute("aria-hidden", "true");
+      const cs = canvas.style;
+      cs.position = "absolute";
+      cs.left = "0";
+      cs.top = "0";
+      cs.width = "100%";
+      cs.height = "100%";
+      cs.pointerEvents = "none";
+      cs.borderRadius = "inherit";
+      cs.display = "block";
+      cs.zIndex = mode === "effect" ? "2147483646" : "-1";
+      try {
+        const computed = W.getComputedStyle(el);
+        if (computed && computed.position === "static") {
+          el.style.position = "relative";
+        }
+      } catch (_err) {
+      }
+      el.style.isolation = "isolate";
+      if (mode === "effect") el.appendChild(canvas);
+      else el.insertBefore(canvas, el.firstChild);
+      let gl = null;
+      try {
+        gl = canvas.getContext("webgl", {
+          alpha: true,
+          premultipliedAlpha: false,
+          antialias: true
+        }) || canvas.getContext(
+          "experimental-webgl"
+        );
+      } catch (_err) {
+        gl = null;
+      }
+      if (!gl) {
+        if (canvas.parentNode) canvas.parentNode.removeChild(canvas);
+        el.setAttribute(ERROR_ATTR, "webgl-unavailable");
+        return null;
+      }
+      let program;
+      try {
+        program = compileProgram(gl, def.glsl);
+      } catch (err) {
+        if (canvas.parentNode) canvas.parentNode.removeChild(canvas);
+        const msg = err instanceof Error ? err.message : String(err);
+        el.setAttribute(ERROR_ATTR, msg.slice(0, 200));
+        return null;
+      }
+      el.removeAttribute(ERROR_ATTR);
+      gl.useProgram(program);
+      const buf = gl.createBuffer();
+      gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+      gl.bufferData(
+        gl.ARRAY_BUFFER,
+        new Float32Array([-1, -1, 3, -1, -1, 3]),
+        gl.STATIC_DRAW
+      );
+      const aPos = gl.getAttribLocation(program, "a_pos");
+      gl.enableVertexAttribArray(aPos);
+      gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 0, 0);
+      const mount = {
+        el,
+        canvas,
+        gl,
+        program,
+        locs: {},
+        defId,
+        mode,
+        values: resolveValues(def, overrides),
+        preview,
+        visible: true
+      };
+      mounts.push(mount);
+      try {
+        if (io) io.observe(canvas);
+      } catch (_err) {
+      }
+      requestRender();
+      return mount;
+    }
+    function loc(mount, name) {
+      if (!(name in mount.locs)) {
+        mount.locs[name] = mount.gl.getUniformLocation(mount.program, name);
+      }
+      return mount.locs[name];
+    }
+    function drawMount(mount, timeSec) {
+      const el = mount.el;
+      const canvas = mount.canvas;
+      const gl = mount.gl;
+      if (!el.isConnected) {
+        unmount(mount);
+        return;
+      }
+      const rect = el.getBoundingClientRect();
+      const wCss = Math.max(1, Math.round(rect.width));
+      const hCss = Math.max(1, Math.round(rect.height));
+      const dpr = Math.min(2, W.devicePixelRatio || 1);
+      const wPx = Math.max(1, Math.round(wCss * dpr));
+      const hPx = Math.max(1, Math.round(hCss * dpr));
+      if (canvas.width !== wPx || canvas.height !== hPx) {
+        canvas.width = wPx;
+        canvas.height = hPx;
+        gl.viewport(0, 0, wPx, hPx);
+      }
+      gl.useProgram(mount.program);
+      const def = registry[mount.defId];
+      const uniforms = def ? def.uniforms : {};
+      const lt = loc(mount, "u_time");
+      if (lt) gl.uniform1f(lt, timeSec);
+      const lr = loc(mount, "u_resolution");
+      if (lr) gl.uniform2f(lr, wPx, hPx);
+      for (const name in mount.values) {
+        if (!Object.prototype.hasOwnProperty.call(mount.values, name)) continue;
+        const u = uniforms[name];
+        const l = loc(mount, name);
+        if (!l || !u) continue;
+        const v = mount.values[name];
+        if (u.type === "color") {
+          const rgb = hexToRgb(v);
+          gl.uniform3f(l, rgb[0], rgb[1], rgb[2]);
+        } else if (u.type === "vec2" && Array.isArray(v) && v.length >= 2) {
+          gl.uniform2f(l, Number(v[0]) || 0, Number(v[1]) || 0);
+        } else {
+          gl.uniform1f(l, Number(v) || 0);
+        }
+      }
+      gl.clearColor(0, 0, 0, 0);
+      gl.clear(gl.COLOR_BUFFER_BIT);
+      gl.drawArrays(gl.TRIANGLES, 0, 3);
+    }
+    function frame() {
+      rafId = null;
+      const t = (nowMs() - t0) / 1e3;
+      const animate = !reducedMotion && !document.hidden;
+      for (let i = mounts.length - 1; i >= 0; i--) {
+        const mount = mounts[i];
+        if (!mount.el.isConnected) {
+          unmount(mount);
+          continue;
+        }
+        if (mount.visible === false && !needsRender) continue;
+        drawMount(mount, reducedMotion ? 0 : t);
+      }
+      needsRender = false;
+      if (animate && mounts.length > 0) startLoop();
+    }
+    function startLoop() {
+      if (rafId !== null) return;
+      if (mounts.length === 0) return;
+      if (W.requestAnimationFrame) {
+        rafId = W.requestAnimationFrame(frame);
+      } else {
+        rafId = setTimeout(frame, 66);
+      }
+    }
+    function requestRender() {
+      needsRender = true;
+      startLoop();
+    }
+    function parseOverrides(el, attr) {
+      const raw = el.getAttribute(attr);
+      if (!raw) return null;
+      try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : null;
+      } catch (_err) {
+        return null;
+      }
+    }
+    function scan() {
+      collectDefs();
+      const els = document.querySelectorAll(
+        "[" + FILL_ATTR + "],[" + EFFECT_ATTR + "]"
+      );
+      const seen = [];
+      for (let i = 0; i < els.length; i++) {
+        const el = els[i];
+        const fillId = el.getAttribute(FILL_ATTR);
+        const effectId = el.getAttribute(EFFECT_ATTR);
+        if (fillId && registry[fillId]) {
+          const fillMount = ensureMount(
+            el,
+            fillId,
+            "fill",
+            parseOverrides(el, VALUES_ATTR),
+            false
+          );
+          if (fillMount) seen.push(fillMount);
+        }
+        if (effectId && registry[effectId]) {
+          const effectMount = ensureMount(
+            el,
+            effectId,
+            "effect",
+            parseOverrides(el, EFFECT_VALUES_ATTR),
+            false
+          );
+          if (effectMount) seen.push(effectMount);
+        }
+      }
+      for (let k = mounts.length - 1; k >= 0; k--) {
+        const mount = mounts[k];
+        if (mount.preview) continue;
+        if (seen.indexOf(mount) === -1) unmount(mount);
+      }
+      startLoop();
+    }
+    function scheduleScan() {
+      if (scanTimer !== null) return;
+      scanTimer = setTimeout(function() {
+        scanTimer = null;
+        scan();
+      }, 100);
+    }
+    function resolveTarget(target) {
+      if (target && target.selector) {
+        try {
+          const hit = document.querySelector(target.selector);
+          if (hit) return hit;
+        } catch (_err) {
+        }
+      }
+      if (target && target.nodeId) {
+        const byId = document.querySelector(
+          '[data-agent-native-node-id="' + String(target.nodeId).replace(/"/g, '\\\\"') + '"]'
+        );
+        if (byId) return byId;
+      }
+      return null;
+    }
+    function applyPreview(target, def, mode) {
+      clearPreview();
+      const el = resolveTarget(target || {});
+      if (!el || !def || typeof def.glsl !== "string") return false;
+      const resolvedMode = mode === "effect" ? "effect" : "fill";
+      registry[PREVIEW_DEF_ID] = {
+        name: (def.name || "Preview") + "",
+        mode: resolvedMode,
+        glsl: def.glsl,
+        uniforms: def.uniforms || {},
+        volatile: true
+      };
+      const mount = ensureMount(
+        el,
+        PREVIEW_DEF_ID,
+        resolvedMode,
+        def.values || null,
+        true
+      );
+      return !!mount;
+    }
+    function clearPreview() {
+      for (let i = mounts.length - 1; i >= 0; i--) {
+        if (mounts[i].preview) unmount(mounts[i]);
+      }
+      delete registry[PREVIEW_DEF_ID];
+    }
+    function setUniform(filter, name, value) {
+      const f = filter || {};
+      for (let i = 0; i < mounts.length; i++) {
+        const mount = mounts[i];
+        if (f.preview !== void 0 && mount.preview !== !!f.preview) continue;
+        if (f.shaderId && mount.defId !== f.shaderId) continue;
+        if (f.nodeId) {
+          const nid = mount.el.getAttribute("data-agent-native-node-id");
+          if (nid !== f.nodeId) continue;
+        }
+        mount.values[name] = value;
+      }
+      requestRender();
+    }
+    function updateShader(id, patch) {
+      const def = registry[id];
+      if (!def || !patch) return;
+      let recompile = false;
+      if (typeof patch.glsl === "string" && patch.glsl !== def.glsl) {
+        def.glsl = patch.glsl;
+        recompile = true;
+      }
+      if (patch.uniforms && typeof patch.uniforms === "object") {
+        def.uniforms = patch.uniforms;
+      }
+      def.volatile = true;
+      if (recompile) invalidateMountsFor(id);
+      scan();
+      requestRender();
+    }
+    W.__anShaders = {
+      version: 1,
+      scan,
+      applyPreview,
+      clearPreview,
+      setUniform,
+      updateShader
+    };
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", function() {
+        scan();
+      });
+    } else {
+      scan();
+    }
+    document.addEventListener("visibilitychange", function() {
+      if (!document.hidden) requestRender();
+    });
+    try {
+      new MutationObserver(function() {
+        scheduleScan();
+      }).observe(document.documentElement, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        attributeFilter: [
+          FILL_ATTR,
+          EFFECT_ATTR,
+          VALUES_ATTR,
+          EFFECT_VALUES_ATTR
+        ]
+      });
+    } catch (_err) {
+    }
+  })();
+})();
+`;

package/corpus/templates/design/.generated/bridge/tweak.generated.ts

@@ -0,0 +1,20 @@
+// AUTO-GENERATED by bridge/codegen.ts — do not edit manually.
+// Run: pnpm exec tsx app/components/design/bridge/codegen.ts
+
+/** Compiled IIFE string for tweak.bridge.ts — inject into an iframe via srcdoc or a <script> tag. */
+export const tweakBridgeScript: string = `"use strict";
+(() => {
+  // app/components/design/bridge/tweak.bridge.ts
+  (function() {
+    window.addEventListener("message", function(e) {
+      if (e.source !== window.parent) return;
+      if (!e.data || e.data.type !== "tweak-values") return;
+      var root = document.documentElement;
+      var vals = e.data.values || {};
+      Object.keys(vals).forEach(function(k) {
+        root.style.setProperty(k, vals[k]);
+      });
+    });
+  })();
+})();
+`;

package/corpus/templates/design/.generated/bridge/zoom.generated.ts

@@ -0,0 +1,32 @@
+// AUTO-GENERATED by bridge/codegen.ts — do not edit manually.
+// Run: pnpm exec tsx app/components/design/bridge/codegen.ts
+
+/** Compiled IIFE string for zoom.bridge.ts — inject into an iframe via srcdoc or a <script> tag. */
+export const zoomBridgeScript: string = `"use strict";
+(() => {
+  // app/components/design/bridge/zoom.bridge.ts
+  (function() {
+    var target = document.documentElement || document.body || document;
+    function onWheel(e) {
+      if (!(e.ctrlKey || e.metaKey)) return;
+      e.preventDefault();
+      try {
+        window.parent.postMessage(
+          {
+            type: "pinch-zoom-wheel",
+            deltaY: e.deltaY,
+            clientX: e.clientX,
+            clientY: e.clientY
+          },
+          "*"
+        );
+      } catch (_err) {
+      }
+    }
+    target.addEventListener("wheel", onWheel, {
+      passive: false,
+      capture: true
+    });
+  })();
+})();
+`;