/*

 * model-viewer.js — a tiny, dependency-free 3D viewer for NestEggCode.

 *

 * Renders STL (binary + ASCII), 3MF, OBJ, PLY, and G-code files directly in the

 * browser with raw WebGL — no external 3D library, no build step. Each

 * <div class="model-view" data-src data-format> on the page is fetched, parsed

 * client-side, and drawn on a <canvas> with orbit / zoom / pan controls.

 *

 * On any failure (unsupported format, parse error, no WebGL) it shows a short

 * message and a download link rather than a blank canvas.

 */

(function () {

    'use strict';

    /* ------------------------------------------------------------------ *

     * Small mat4 / vec3 helpers (column-major, WebGL convention).

     * Just enough linear algebra for a camera — not a math library.

     * ------------------------------------------------------------------ */

    function mIdentity() {

        return new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);

    }

    function mMultiply(a, b) {

        // Returns a * b.

        var o = new Float32Array(16);

        for (var c = 0; c < 4; c++) {

            for (var r = 0; r < 4; r++) {

                o[c * 4 + r] = a[r] * b[c * 4] + a[4 + r] * b[c * 4 + 1] +

                               a[8 + r] * b[c * 4 + 2] + a[12 + r] * b[c * 4 + 3];

            }

        }

        return o;

    }

    function mPerspective(fovy, aspect, near, far) {

        var f = 1.0 / Math.tan(fovy / 2);

        var nf = 1 / (near - far);

        return new Float32Array([

            f / aspect, 0, 0, 0,

            0, f, 0, 0,

            0, 0, (far + near) * nf, -1,

            0, 0, 2 * far * near * nf, 0

        ]);

    }

    function mLookAt(eye, center, up) {

        var z = vNorm(vSub(eye, center));

        var x = vNorm(vCross(up, z));

        var y = vCross(z, x);

        return new Float32Array([

            x[0], y[0], z[0], 0,

            x[1], y[1], z[1], 0,

            x[2], y[2], z[2], 0,

            -vDot(x, eye), -vDot(y, eye), -vDot(z, eye), 1

        ]);

    }

    function mRotateX(rad) {

        var c = Math.cos(rad), s = Math.sin(rad);

        return new Float32Array([1, 0, 0, 0, 0, c, s, 0, 0, -s, c, 0, 0, 0, 0, 1]);

    }

    // Normal matrix (mat3, as 9 floats) = inverse-transpose of a mat4's 3x3.

    function normalMatrix(m) {

        var a00 = m[0], a01 = m[1], a02 = m[2];

        var a10 = m[4], a11 = m[5], a12 = m[6];

        var a20 = m[8], a21 = m[9], a22 = m[10];

        var b01 = a22 * a11 - a12 * a21;

        var b11 = -a22 * a10 + a12 * a20;

        var b21 = a21 * a10 - a11 * a20;

        var det = a00 * b01 + a01 * b11 + a02 * b21;

        if (!det) { return new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]); }

        det = 1.0 / det;

        // inverse (of 3x3) then transpose, folded together.

        return new Float32Array([

            b01 * det,

            (-a22 * a01 + a02 * a21) * det,

            (a12 * a01 - a02 * a11) * det,

            b11 * det,

            (a22 * a00 - a02 * a20) * det,

            (-a12 * a00 + a02 * a10) * det,

            b21 * det,

            (-a21 * a00 + a01 * a20) * det,

            (a11 * a00 - a01 * a10) * det

        ]);

    }

    function vSub(a, b) { return [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; }

    function vAdd(a, b) { return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; }

    function vScale(a, s) { return [a[0] * s, a[1] * s, a[2] * s]; }

    function vDot(a, b) { return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; }

    function vCross(a, b) {

        return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];

    }

    function vNorm(a) {

        var l = Math.hypot(a[0], a[1], a[2]) || 1;

        return [a[0] / l, a[1] / l, a[2] / l];

    }

    function vTransform(m, p) {

        // Apply a mat4 to a point (w = 1).

        return [

            m[0] * p[0] + m[4] * p[1] + m[8] * p[2] + m[12],

            m[1] * p[0] + m[5] * p[1] + m[9] * p[2] + m[13],

            m[2] * p[0] + m[6] * p[1] + m[10] * p[2] + m[14]

        ];

    }

    /* ------------------------------------------------------------------ *

     * Geometry helpers.

     * ------------------------------------------------------------------ */

    // Expand an indexed triangle list into a flat "triangle soup" (9 floats/tri).

    function indexedToSoup(verts, indices) {

        var positions = new Float32Array(indices.length * 3);

        for (var i = 0; i < indices.length; i++) {

            var vi = indices[i] * 3;

            positions[i * 3] = verts[vi];

            positions[i * 3 + 1] = verts[vi + 1];

            positions[i * 3 + 2] = verts[vi + 2];

        }

        return positions;

    }

    // Flat (per-face) normals for a triangle soup — gives a clean faceted look.

    function computeFlatNormals(positions) {

        var normals = new Float32Array(positions.length);

        for (var i = 0; i < positions.length; i += 9) {

            var ux = positions[i + 3] - positions[i];

            var uy = positions[i + 4] - positions[i + 1];

            var uz = positions[i + 5] - positions[i + 2];

            var vx = positions[i + 6] - positions[i];

            var vy = positions[i + 7] - positions[i + 1];

            var vz = positions[i + 8] - positions[i + 2];

            var nx = uy * vz - uz * vy;

            var ny = uz * vx - ux * vz;

            var nz = ux * vy - uy * vx;

            var len = Math.hypot(nx, ny, nz) || 1;

            nx /= len; ny /= len; nz /= len;

            for (var k = 0; k < 3; k++) {

                normals[i + k * 3] = nx;

                normals[i + k * 3 + 1] = ny;

                normals[i + k * 3 + 2] = nz;

            }

        }

        return normals;

    }

    function meshFromSoup(positions) {

        if (!positions.length) { throw new Error('Model contains no geometry.'); }

        return { kind: 'mesh', positions: positions, normals: computeFlatNormals(positions) };

    }

    // Bounding box of a flat position array -> {min, max, center, radius}.

    function bounds(positions) {

        var min = [Infinity, Infinity, Infinity];

        var max = [-Infinity, -Infinity, -Infinity];

        for (var i = 0; i < positions.length; i += 3) {

            for (var a = 0; a < 3; a++) {

                var v = positions[i + a];

                if (v < min[a]) { min[a] = v; }

                if (v > max[a]) { max[a] = v; }

            }

        }

        var center = [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2];

        var radius = Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) / 2 || 1;

        return { min: min, max: max, center: center, radius: radius };

    }

    /* ------------------------------------------------------------------ *

     * Parsers. Each returns a geometry object:

     *   { kind:'mesh',   positions, normals }

     *   { kind:'lines',  positions, colors }

     *   { kind:'points', positions, colors }

     * ------------------------------------------------------------------ */

    function isBinarySTL(buf) {

        if (buf.byteLength < 84) { return false; }

        var n = new DataView(buf).getUint32(80, true);

        return 84 + n * 50 === buf.byteLength;

    }

    function parseStlBinary(buf) {

        var dv = new DataView(buf);

        var n = dv.getUint32(80, true);

        var positions = new Float32Array(n * 9);

        var o = 84, p = 0;

        for (var i = 0; i < n; i++) {

            o += 12; // skip the per-face normal; we recompute flat normals.

            for (var v = 0; v < 9; v++) { positions[p++] = dv.getFloat32(o, true); o += 4; }

            o += 2;  // attribute byte count

        }

        return positions;

    }

    function parseStlAscii(text) {

        var nums = [];

        var re = /vertex\s+(-?[\d.eE+]+)\s+(-?[\d.eE+]+)\s+(-?[\d.eE+]+)/g;

        var m;

        while ((m = re.exec(text))) { nums.push(+m[1], +m[2], +m[3]); }

        return new Float32Array(nums);

    }

    function parseSTL(buf) {

        if (isBinarySTL(buf)) { return meshFromSoup(parseStlBinary(buf)); }

        var text = new TextDecoder().decode(buf);

        if (/facet/i.test(text)) { return meshFromSoup(parseStlAscii(text)); }

        return meshFromSoup(parseStlBinary(buf)); // last resort

    }

    function parseOBJ(text) {

        var verts = [], idx = [];

        var lines = text.split('\n');

        for (var i = 0; i < lines.length; i++) {

            var t = lines[i].trim();

            if (t.charCodeAt(0) === 118 /* v */ && t[1] === ' ') {

                var vp = t.split(/\s+/);

                verts.push(+vp[1], +vp[2], +vp[3]);

            } else if (t.charCodeAt(0) === 102 /* f */ && t[1] === ' ') {

                var fp = t.split(/\s+/);

                var face = [];

                for (var j = 1; j < fp.length; j++) {

                    var s = fp[j].split('/')[0];

                    var n = parseInt(s, 10);

                    if (n < 0) { n = verts.length / 3 + n + 1; }

                    face.push(n - 1);

                }

                for (var k = 1; k < face.length - 1; k++) {

                    idx.push(face[0], face[k], face[k + 1]);

                }

            }

        }

        return meshFromSoup(indexedToSoup(verts, idx));

    }

    function parsePLY(buf) {

        var bytes = new Uint8Array(buf);

        var dec = new TextDecoder('ascii');

        // Read the header line-by-line to find its byte length precisely.

        var pos = 0, headerEnd = -1, headerLines = [];

        while (pos < bytes.length) {

            var e = pos;

            while (e < bytes.length && bytes[e] !== 10) { e++; }

            var line = dec.decode(bytes.subarray(pos, e)).replace(/\r$/, '');

            headerLines.push(line);

            pos = e + 1;

            if (line.trim() === 'end_header') { headerEnd = pos; break; }

            if (headerLines.length > 5000) { break; }

        }

        if (headerEnd < 0) { throw new Error('Not a valid PLY file.'); }

        var format = 'ascii', elements = [], cur = null;

        for (var h = 0; h < headerLines.length; h++) {

            var p = headerLines[h].trim().split(/\s+/);

            if (p[0] === 'format') {

                format = p[1];

            } else if (p[0] === 'element') {

                cur = { name: p[1], count: +p[2], props: [] };

                elements.push(cur);

            } else if (p[0] === 'property' && cur) {

                if (p[1] === 'list') {

                    cur.props.push({ name: p[4], list: true, countType: p[2], itemType: p[3] });

                } else {

                    cur.props.push({ name: p[2], type: p[1] });

                }

            }

        }

        var vertEl = elements.filter(function (x) { return x.name === 'vertex'; })[0];

        var faceEl = elements.filter(function (x) { return x.name === 'face'; })[0];

        if (!vertEl) { throw new Error('PLY file has no vertices.'); }

        var verts = [], idx = [];

        if (format === 'ascii') {

            var toks = dec.decode(bytes.subarray(headerEnd)).split(/\s+/).filter(function (s) { return s.length; });

            var ti = 0;

            var xi = propIndex(vertEl, 'x'), yi = propIndex(vertEl, 'y'), zi = propIndex(vertEl, 'z');

            var np = vertEl.props.length;

            for (var vi = 0; vi < vertEl.count; vi++) {

                verts.push(+toks[ti + xi], +toks[ti + yi], +toks[ti + zi]);

                ti += np;

            }

            if (faceEl) {

                for (var fi = 0; fi < faceEl.count; fi++) {

                    var cnt = +toks[ti++], f = [];

                    for (var c = 0; c < cnt; c++) { f.push(+toks[ti++]); }

                    for (var kk = 1; kk < cnt - 1; kk++) { idx.push(f[0], f[kk], f[kk + 1]); }

                }

            }

        } else {

            var le = format === 'binary_little_endian';

            var dv = new DataView(buf, headerEnd);

            var off = { v: 0 };

            for (var bi = 0; bi < vertEl.count; bi++) {

                var x = 0, y = 0, z = 0;

                for (var pp = 0; pp < vertEl.props.length; pp++) {

                    var val = readPlyType(dv, off, vertEl.props[pp].type, le);

                    if (vertEl.props[pp].name === 'x') { x = val; }

                    else if (vertEl.props[pp].name === 'y') { y = val; }

                    else if (vertEl.props[pp].name === 'z') { z = val; }

                }

                verts.push(x, y, z);

            }

            if (faceEl) {

                for (var bf = 0; bf < faceEl.count; bf++) {

                    for (var fp = 0; fp < faceEl.props.length; fp++) {

                        var prop = faceEl.props[fp];

                        if (prop.list) {

                            var n = readPlyType(dv, off, prop.countType, le);

                            var fa = [];

                            for (var q = 0; q < n; q++) { fa.push(readPlyType(dv, off, prop.itemType, le)); }

                            for (var t2 = 1; t2 < n - 1; t2++) { idx.push(fa[0], fa[t2], fa[t2 + 1]); }

                        } else {

                            readPlyType(dv, off, prop.type, le);

                        }

                    }

                }

            }

        }

        if (idx.length) { return meshFromSoup(indexedToSoup(verts, idx)); }

        // No faces: render as a point cloud.

        var positions = new Float32Array(verts);

        var colors = new Float32Array(verts.length);

        for (var ci = 0; ci < colors.length; ci += 3) { colors[ci] = 0.6; colors[ci + 1] = 0.7; colors[ci + 2] = 0.85; }

        return { kind: 'points', positions: positions, colors: colors };

    }

    function propIndex(el, name) {

        for (var i = 0; i < el.props.length; i++) { if (el.props[i].name === name) { return i; } }

        return -1;

    }

    function readPlyType(dv, off, type, le) {

        var v;

        switch (type) {

            case 'char': case 'int8': v = dv.getInt8(off.v); off.v += 1; return v;

            case 'uchar': case 'uint8': v = dv.getUint8(off.v); off.v += 1; return v;

            case 'short': case 'int16': v = dv.getInt16(off.v, le); off.v += 2; return v;

            case 'ushort': case 'uint16': v = dv.getUint16(off.v, le); off.v += 2; return v;

            case 'int': case 'int32': v = dv.getInt32(off.v, le); off.v += 4; return v;

            case 'uint': case 'uint32': v = dv.getUint32(off.v, le); off.v += 4; return v;

            case 'double': case 'float64': v = dv.getFloat64(off.v, le); off.v += 8; return v;

            default: v = dv.getFloat32(off.v, le); off.v += 4; return v; // float / float32

        }

    }

    /* ---- 3MF (a ZIP of XML) ------------------------------------------- */

    async function parse3MF(buf) {

        var xml = await extractModelXml(buf);

        var doc = new DOMParser().parseFromString(xml, 'application/xml');

        if (doc.getElementsByTagName('parsererror').length) {

            throw new Error('Could not parse the 3MF model XML.');

        }

        var meshes = doc.getElementsByTagNameNS('*', 'mesh');

        if (!meshes.length) { throw new Error('3MF file contains no mesh.'); }

        var verts = [], idx = [];

        for (var m = 0; m < meshes.length; m++) {

            var base = verts.length / 3;

            var vs = meshes[m].getElementsByTagNameNS('*', 'vertex');

            for (var i = 0; i < vs.length; i++) {

                verts.push(+vs[i].getAttribute('x'), +vs[i].getAttribute('y'), +vs[i].getAttribute('z'));

            }

            var ts = meshes[m].getElementsByTagNameNS('*', 'triangle');

            for (var j = 0; j < ts.length; j++) {

                idx.push(base + +ts[j].getAttribute('v1'),

                         base + +ts[j].getAttribute('v2'),

                         base + +ts[j].getAttribute('v3'));

            }

        }

        return meshFromSoup(indexedToSoup(verts, idx));

    }

    // Minimal ZIP reader: locate the first "*.model" entry and return its text.

    async function extractModelXml(buf) {

        var dv = new DataView(buf);

        // Find the End Of Central Directory record (scan back for 0x06054b50).

        var eocd = -1;

        for (var i = buf.byteLength - 22; i >= 0; i--) {

            if (dv.getUint32(i, true) === 0x06054b50) { eocd = i; break; }

        }

        if (eocd < 0) { throw new Error('3MF is not a valid ZIP archive.'); }

        var count = dv.getUint16(eocd + 10, true);

        var cdOffset = dv.getUint32(eocd + 16, true);

        var best = null, p = cdOffset;

        for (var c = 0; c < count; c++) {

            if (dv.getUint32(p, true) !== 0x02014b50) { break; }

            var method = dv.getUint16(p + 10, true);

            var compSize = dv.getUint32(p + 20, true);

            var nameLen = dv.getUint16(p + 28, true);

            var extraLen = dv.getUint16(p + 30, true);

            var commentLen = dv.getUint16(p + 32, true);

            var localOffset = dv.getUint32(p + 42, true);

            var name = new TextDecoder().decode(new Uint8Array(buf, p + 46, nameLen));

            var lower = name.toLowerCase();

            if (lower.indexOf('.model') === lower.length - 6) {

                var entry = { method: method, compSize: compSize, localOffset: localOffset };

                if (lower === '3d/3dmodel.model') { best = entry; break; }

                if (!best) { best = entry; }

            }

            p += 46 + nameLen + extraLen + commentLen;

        }

        if (!best) { throw new Error('No 3D model found inside the 3MF archive.'); }

        // Read the local file header to find where the compressed data starts.

        var lo = best.localOffset;

        if (dv.getUint32(lo, true) !== 0x04034b50) { throw new Error('Corrupt 3MF archive.'); }

        var lNameLen = dv.getUint16(lo + 26, true);

        var lExtraLen = dv.getUint16(lo + 28, true);

        var dataStart = lo + 30 + lNameLen + lExtraLen;

        var comp = new Uint8Array(buf, dataStart, best.compSize);

        if (best.method === 0) { return new TextDecoder().decode(comp); }

        if (best.method === 8) {

            if (typeof DecompressionStream === 'undefined') {

                throw new Error('This browser cannot decompress the 3MF (no DecompressionStream).');

            }

            var ds = new DecompressionStream('deflate-raw');

            var stream = new Blob([comp]).stream().pipeThrough(ds);

            var out = await new Response(stream).arrayBuffer();

            return new TextDecoder().decode(out);

        }

        throw new Error('Unsupported compression inside the 3MF archive.');

    }

    /* ---- G-code ------------------------------------------------------- */

    function gcodeColor(t) {

        // Layer-height gradient: blue -> green -> yellow -> red.

        t = t < 0 ? 0 : (t > 1 ? 1 : t);

        var r = Math.min(1, Math.max(0, 1.4 * t - 0.2));

        var g = Math.max(0, Math.sin(Math.PI * t) * 0.85 + 0.15);

        var b = Math.max(0, 1.0 - 1.35 * t);

        return [r, g, b];

    }

    function parseGcode(text) {

        var lines = text.split('\n');

        var abs = true, eAbs = true;

        var x = 0, y = 0, z = 0, e = 0;

        var hasPrev = false, px = 0, py = 0, pz = 0;

        var segs = [];

        var zmin = Infinity, zmax = -Infinity;

        for (var li = 0; li < lines.length; li++) {

            var line = lines[li];

            var sc = line.indexOf(';');

            if (sc >= 0) { line = line.slice(0, sc); }

            line = line.trim();

            if (!line) { continue; }

            var parts = line.split(/\s+/);

            var cmd = parts[0].toUpperCase();

            if (cmd === 'G90') { abs = true; continue; }

            if (cmd === 'G91') { abs = false; continue; }

            if (cmd === 'M82') { eAbs = true; continue; }

            if (cmd === 'M83') { eAbs = false; continue; }

            if (cmd === 'G92') {

                for (var g = 1; g < parts.length; g++) {

                    var ga = parts[g][0].toUpperCase(), gv = parseFloat(parts[g].slice(1));

                    if (isNaN(gv)) { continue; }

                    if (ga === 'X') { x = gv; } else if (ga === 'Y') { y = gv; }

                    else if (ga === 'Z') { z = gv; } else if (ga === 'E') { e = gv; }

                }

                continue;

            }

            if (cmd === 'G0' || cmd === 'G1' || cmd === 'G00' || cmd === 'G01') {

                var nx = x, ny = y, nz = z, eVal = null;

                for (var pi = 1; pi < parts.length; pi++) {

                    var a = parts[pi][0].toUpperCase(), val = parseFloat(parts[pi].slice(1));

                    if (isNaN(val)) { continue; }

                    if (a === 'X') { nx = abs ? val : x + val; }

                    else if (a === 'Y') { ny = abs ? val : y + val; }

                    else if (a === 'Z') { nz = abs ? val : z + val; }

                    else if (a === 'E') { eVal = val; }

                }

                var extruding = false;

                if (eVal !== null) {

                    if (eAbs) { extruding = eVal > e + 1e-6; e = eVal; }

                    else { extruding = eVal > 1e-6; e += eVal; }

                }

                if (extruding && hasPrev) {

                    segs.push([px, py, pz, nx, ny, nz, (pz + nz) * 0.5]);

                    if (nz < zmin) { zmin = nz; }

                    if (nz > zmax) { zmax = nz; }

                }

                x = nx; y = ny; z = nz;

                px = x; py = y; pz = z; hasPrev = true;

            }

        }

        if (!segs.length) { throw new Error('No extrusion moves found in this G-code.'); }

        var positions = new Float32Array(segs.length * 6);

        var colors = new Float32Array(segs.length * 6);

        var span = (zmax - zmin) || 1;

        for (var s = 0; s < segs.length; s++) {

            var seg = segs[s];

            positions.set([seg[0], seg[1], seg[2], seg[3], seg[4], seg[5]], s * 6);

            var col = gcodeColor((seg[6] - zmin) / span);

            colors.set([col[0], col[1], col[2], col[0], col[1], col[2]], s * 6);

        }

        return { kind: 'lines', positions: positions, colors: colors };

    }

    /* ------------------------------------------------------------------ *

     * Format dispatch.

     * ------------------------------------------------------------------ */

    // Formats that are "Z-up" (3D-printing convention): rotate so Z points up.

    var Z_UP = { stl: true, '3mf': true, gcode: true };

    async function parseModel(format, buf) {

        switch (format) {

            case 'stl': return parseSTL(buf);

            case '3mf': return await parse3MF(buf);

            case 'obj': return parseOBJ(new TextDecoder().decode(buf));

            case 'ply': return parsePLY(buf);

            case 'gcode': return parseGcode(new TextDecoder().decode(buf));

            default: throw new Error('Unsupported model format: ' + format);

        }

    }

    /* ------------------------------------------------------------------ *

     * WebGL renderer + orbit camera.

     * ------------------------------------------------------------------ */

    var MESH_VS =

        'attribute vec3 aPos; attribute vec3 aNormal;' +

        'uniform mat4 uProj; uniform mat4 uView; uniform mat4 uModel; uniform mat3 uNormal;' +

        'varying vec3 vNormal;' +

        'void main(){ vNormal = uNormal * aNormal; gl_Position = uProj*uView*uModel*vec4(aPos,1.0); }';

    var MESH_FS =

        'precision mediump float; varying vec3 vNormal; uniform vec3 uColor;' +

        'void main(){' +

        '  vec3 n = normalize(vNormal);' +

        '  float d = abs(dot(n, vec3(0.0,0.0,1.0)));' + // headlight (view space)

        '  float shade = 0.28 + 0.72*d;' +

        '  gl_FragColor = vec4(uColor*shade, 1.0);' +

        '}';

    var LINE_VS =

        'attribute vec3 aPos; attribute vec3 aColor;' +

        'uniform mat4 uProj; uniform mat4 uView; uniform mat4 uModel;' +

        'varying vec3 vColor;' +

        'void main(){ vColor = aColor; gl_PointSize = 2.0; gl_Position = uProj*uView*uModel*vec4(aPos,1.0); }';

    var LINE_FS =

        'precision mediump float; varying vec3 vColor;' +

        'void main(){ gl_FragColor = vec4(vColor, 1.0); }';

    function compile(gl, type, src) {

        var sh = gl.createShader(type);

        gl.shaderSource(sh, src);

        gl.compileShader(sh);

        if (!gl.getShaderParameter(sh, gl.COMPILE_STATUS)) {

            throw new Error('Shader error: ' + gl.getShaderInfoLog(sh));

        }

        return sh;

    }

    function program(gl, vs, fs) {

        var p = gl.createProgram();

        gl.attachShader(p, compile(gl, gl.VERTEX_SHADER, vs));

        gl.attachShader(p, compile(gl, gl.FRAGMENT_SHADER, fs));

        gl.linkProgram(p);

        if (!gl.getProgramParameter(p, gl.LINK_STATUS)) {

            throw new Error('Program link error: ' + gl.getProgramInfoLog(p));

        }

        return p;

    }

    function buffer(gl, data) {

        var b = gl.createBuffer();

        gl.bindBuffer(gl.ARRAY_BUFFER, b);

        gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);

        return b;

    }

    function setupRenderer(canvas, geom) {

        var gl = canvas.getContext('webgl', { antialias: true, alpha: true }) ||

                 canvas.getContext('experimental-webgl', { antialias: true, alpha: true });

        if (!gl) { throw new Error('WebGL is not available in this browser.'); }

        var isMesh = geom.kind === 'mesh';

        var prog = isMesh ? program(gl, MESH_VS, MESH_FS) : program(gl, LINE_VS, LINE_FS);

        gl.useProgram(prog);

        var posBuf = buffer(gl, geom.positions);

        var secondBuf = buffer(gl, isMesh ? geom.normals : geom.colors);

        var vertexCount = geom.positions.length / 3;

        var aPos = gl.getAttribLocation(prog, 'aPos');

        var aSecond = gl.getAttribLocation(prog, isMesh ? 'aNormal' : 'aColor');

        var uProj = gl.getUniformLocation(prog, 'uProj');

        var uView = gl.getUniformLocation(prog, 'uView');

        var uModel = gl.getUniformLocation(prog, 'uModel');

        var uNormal = isMesh ? gl.getUniformLocation(prog, 'uNormal') : null;

        var uColor = isMesh ? gl.getUniformLocation(prog, 'uColor') : null;

        gl.enable(gl.DEPTH_TEST);

        gl.clearColor(0, 0, 0, 0);

        return {

            gl: gl, draw: function (proj, view, model) {

                gl.useProgram(prog);

                gl.bindBuffer(gl.ARRAY_BUFFER, posBuf);

                gl.enableVertexAttribArray(aPos);

                gl.vertexAttribPointer(aPos, 3, gl.FLOAT, false, 0, 0);

                gl.bindBuffer(gl.ARRAY_BUFFER, secondBuf);

                gl.enableVertexAttribArray(aSecond);

                gl.vertexAttribPointer(aSecond, 3, gl.FLOAT, false, 0, 0);

                gl.uniformMatrix4fv(uProj, false, proj);

                gl.uniformMatrix4fv(uView, false, view);

                gl.uniformMatrix4fv(uModel, false, model);

                if (isMesh) {

                    gl.uniformMatrix3fv(uNormal, false, normalMatrix(mMultiply(view, model)));

                    gl.uniform3f(uColor, 0.55, 0.62, 0.72);

                }

                gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);

                var mode = geom.kind === 'mesh' ? gl.TRIANGLES

                         : (geom.kind === 'lines' ? gl.LINES : gl.POINTS);

                gl.drawArrays(mode, 0, vertexCount);

            }

        };

    }

    /* ------------------------------------------------------------------ *

     * Per-element viewer wiring (camera state, controls, render loop).

     * ------------------------------------------------------------------ */

    var FOV = 45 * Math.PI / 180;

    function initViewer(container, geom, format) {

        var canvas = document.createElement('canvas');

        canvas.className = 'model-canvas';

        container.innerHTML = '';

        container.appendChild(canvas);

        var hint = document.createElement('div');

        hint.className = 'model-hint';

        hint.textContent = 'drag to rotate · scroll to zoom · shift-drag to pan';

        container.appendChild(hint);

        var renderer = setupRenderer(canvas, geom);

        var gl = renderer.gl;

        // Model matrix: rotate Z-up formats so Z points up on screen.

        var model = Z_UP[format] ? mRotateX(-Math.PI / 2) : mIdentity();

        // World-space bounds (transform the 8 local-bbox corners by the model).

        var b = bounds(geom.positions);

        var wmin = [Infinity, Infinity, Infinity], wmax = [-Infinity, -Infinity, -Infinity];

        for (var cx = 0; cx < 2; cx++) {

            for (var cy = 0; cy < 2; cy++) {

                for (var cz = 0; cz < 2; cz++) {

                    var corner = vTransform(model, [

                        cx ? b.max[0] : b.min[0],

                        cy ? b.max[1] : b.min[1],

                        cz ? b.max[2] : b.min[2]

                    ]);

                    for (var a = 0; a < 3; a++) {

                        if (corner[a] < wmin[a]) { wmin[a] = corner[a]; }

                        if (corner[a] > wmax[a]) { wmax[a] = corner[a]; }

                    }

                }

            }

        }

        var target = [(wmin[0] + wmax[0]) / 2, (wmin[1] + wmax[1]) / 2, (wmin[2] + wmax[2]) / 2];

        var radius = Math.hypot(wmax[0] - wmin[0], wmax[1] - wmin[1], wmax[2] - wmin[2]) / 2 || 1;

        // Camera state: turntable (yaw/pitch) at `distance` around `target`.

        var yaw = -0.6, pitch = 0.5;

        var distance = radius / Math.sin(FOV / 2) * 1.15;

        var minPitch = -1.5533, maxPitch = 1.5533;

        function eye() {

            var cp = Math.cos(pitch), sp = Math.sin(pitch);

            var dir = [cp * Math.sin(yaw), sp, cp * Math.cos(yaw)];

            return vAdd(target, vScale(dir, distance));

        }

        var pending = false;

        function requestRender() {

            if (pending) { return; }

            pending = true;

            requestAnimationFrame(render);

        }

        function render() {

            pending = false;

            var w = canvas.width, h = canvas.height;

            gl.viewport(0, 0, w, h);

            var proj = mPerspective(FOV, w / h || 1, Math.max(0.01, distance - radius) * 0.5, distance + radius * 4);

            var view = mLookAt(eye(), target, [0, 1, 0]);

            renderer.draw(proj, view, model);

        }

        function resize() {

            var dpr = window.devicePixelRatio || 1;

            var w = Math.max(1, Math.round(container.clientWidth * dpr));

            var h = Math.max(1, Math.round(container.clientHeight * dpr));

            if (canvas.width !== w || canvas.height !== h) {

                canvas.width = w; canvas.height = h;

            }

            requestRender();

        }

        // ---- Orbit / zoom / pan controls ----

        var dragging = false, panning = false, lastX = 0, lastY = 0;

        canvas.addEventListener('pointerdown', function (ev) {

            dragging = true;

            panning = ev.shiftKey || ev.button === 2;

            lastX = ev.clientX; lastY = ev.clientY;

            canvas.setPointerCapture(ev.pointerId);

        });

        canvas.addEventListener('pointermove', function (ev) {

            if (!dragging) { return; }

            var dx = ev.clientX - lastX, dy = ev.clientY - lastY;

            lastX = ev.clientX; lastY = ev.clientY;

            if (panning) {

                var e = eye();

                var forward = vNorm(vSub(target, e));

                var right = vNorm(vCross(forward, [0, 1, 0]));

                var up = vCross(right, forward);

                var scale = distance / Math.max(1, container.clientHeight);

                target = vAdd(target, vScale(right, -dx * scale));

                target = vAdd(target, vScale(up, dy * scale));

            } else {

                yaw -= dx * 0.01;

                pitch += dy * 0.01;

                if (pitch < minPitch) { pitch = minPitch; }

                if (pitch > maxPitch) { pitch = maxPitch; }

            }

            requestRender();

        });

        function endDrag(ev) { dragging = false; if (ev.pointerId != null) { try { canvas.releasePointerCapture(ev.pointerId); } catch (x) {} } }

        canvas.addEventListener('pointerup', endDrag);

        canvas.addEventListener('pointercancel', endDrag);

        canvas.addEventListener('contextmenu', function (ev) { ev.preventDefault(); });

        canvas.addEventListener('wheel', function (ev) {

            ev.preventDefault();

            distance *= Math.exp(ev.deltaY * 0.0015);

            distance = Math.max(radius * 0.05, Math.min(radius * 50, distance));

            requestRender();

        }, { passive: false });

        if (typeof ResizeObserver !== 'undefined') {

            new ResizeObserver(resize).observe(container);

        } else {

            window.addEventListener('resize', resize);

        }

        resize();

    }

    /* ------------------------------------------------------------------ *

     * Bootstrap: load & render every .model-view on the page.

     * ------------------------------------------------------------------ */

    function fail(container, message) {

        var dl = container.getAttribute('data-download') || '';

        container.classList.add('model-error');

        container.innerHTML = '';

        var box = document.createElement('div');

        box.className = 'model-status';

        box.textContent = message || 'Could not display this 3D file.';

        container.appendChild(box);

        if (dl) {

            var a = document.createElement('a');

            a.className = 'btn-secondary';

            a.href = dl;

            a.textContent = 'Download file';

            container.appendChild(a);

        }

    }

    async function load(container) {

        var src = container.getAttribute('data-src');

        var format = container.getAttribute('data-format');

        try {

            var resp = await fetch(src);

            if (!resp.ok) { throw new Error('Could not fetch the file (HTTP ' + resp.status + ').'); }

            var buf = await resp.arrayBuffer();

            var geom = await parseModel(format, buf);

            initViewer(container, geom, format);

        } catch (err) {

            fail(container, (err && err.message) ? err.message : String(err));

        }

    }

    function start() {

        var nodes = document.querySelectorAll('.model-view[data-src]');

        for (var i = 0; i < nodes.length; i++) { load(nodes[i]); }

    }

    // Expose parsers for debugging / testing without touching browser behaviour.

    var api = {

        parseSTL: parseSTL, parseOBJ: parseOBJ, parsePLY: parsePLY,

        parseGcode: parseGcode, parse3MF: parse3MF, extractModelXml: extractModelXml

    };

    if (typeof module !== 'undefined' && module.exports) { module.exports = api; }

    if (typeof document !== 'undefined') {

        if (document.readyState === 'loading') {

            document.addEventListener('DOMContentLoaded', start);

        } else {

            start();

        }

    }

})();