@enmaq/mdgl 0.2.0 → 0.3.0

package/dist/eval.js

@@ -0,0 +1,496 @@
+"use strict";
+// MDGL 0.1 evaluator + terminal-cell renderer. Pure and seekable: compile() a checked
+// document once, then frameNs()/fallbackFrame() are functions of (scene, time) only.
+// Implemented from SPEC.md alone. Choices SPEC leaves open are marked IMPL-DEFINED.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileDocument = compileDocument;
+exports.compile = compile;
+exports.frameNs = frameNs;
+exports.fallbackFrame = fallbackFrame;
+const check_1 = require("./check");
+const parse_1 = require("./parse");
+const unicode_1 = require("./unicode");
+const I4 = () => [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+const mul = (a, b) => {
+    const o = new Array(16).fill(0);
+    for (let c = 0; c < 4; c++)
+        for (let r = 0; r < 4; r++)
+            for (let k = 0; k < 4; k++)
+                o[c * 4 + r] += a[k * 4 + r] * b[c * 4 + k];
+    return o;
+};
+const trans = (x, y, z) => { const m = I4(); m[12] = x; m[13] = y; m[14] = z; return m; };
+const scaleM = (s) => { const m = I4(); m[0] = s; m[5] = s; m[10] = s; return m; };
+const rotM = (xd, yd, zd) => {
+    const [x, y, z] = [xd, yd, zd].map((d) => (d * Math.PI) / 180);
+    const [cx, sx, cy, sy, cz, sz] = [Math.cos(x), Math.sin(x), Math.cos(y), Math.sin(y), Math.cos(z), Math.sin(z)];
+    // SPEC rows (intrinsic XYZ, R = Rx*Ry*Rz)
+    const rows = [
+        [cy * cz, -cy * sz, sy, 0],
+        [cx * sz + sx * sy * cz, cx * cz - sx * sy * sz, -sx * cy, 0],
+        [sx * sz - cx * sy * cz, sx * cz + cx * sy * sz, cx * cy, 0],
+        [0, 0, 0, 1],
+    ];
+    const m = new Array(16);
+    for (let r = 0; r < 4; r++)
+        for (let c = 0; c < 4; c++)
+            m[c * 4 + r] = rows[r][c];
+    return m;
+};
+const xf = (m, v) => {
+    const o = [0, 0, 0, 0];
+    for (let r = 0; r < 4; r++)
+        o[r] = m[r] * v[0] + m[4 + r] * v[1] + m[8 + r] * v[2] + m[12 + r];
+    return o;
+};
+/** half away from zero */
+const rnd = (v) => (v < 0 ? -Math.floor(-v + 0.5) : Math.floor(v + 0.5));
+// ---- easing (SPEC: CSS cubic-bezier controls with numeric X solve; bounce = standard ease-out-bounce) ----
+function bezier(x1, y1, x2, y2) {
+    const cx = (s) => 3 * (1 - s) * (1 - s) * s * x1 + 3 * (1 - s) * s * s * x2 + s * s * s;
+    const cy = (s) => 3 * (1 - s) * (1 - s) * s * y1 + 3 * (1 - s) * s * s * y2 + s * s * s;
+    return (u) => {
+        if (u <= 0)
+            return 0;
+        if (u >= 1)
+            return 1;
+        let lo = 0, hi = 1;
+        for (let i = 0; i < 80; i++) {
+            const m = (lo + hi) / 2;
+            if (cx(m) < u)
+                lo = m;
+            else
+                hi = m;
+        }
+        return cy((lo + hi) / 2);
+    };
+}
+const bounce = (u) => {
+    const n1 = 7.5625, d1 = 2.75;
+    if (u < 1 / d1)
+        return n1 * u * u;
+    if (u < 2 / d1) {
+        u -= 1.5 / d1;
+        return n1 * u * u + 0.75;
+    }
+    if (u < 2.5 / d1) {
+        u -= 2.25 / d1;
+        return n1 * u * u + 0.9375;
+    }
+    u -= 2.625 / d1;
+    return n1 * u * u + 0.984375;
+};
+const EASE = {
+    linear: (u) => u,
+    ease: bezier(0.25, 0.1, 0.25, 1),
+    'ease-in': bezier(0.42, 0, 1, 1),
+    'ease-out': bezier(0, 0, 0.58, 1),
+    'ease-in-out': bezier(0.42, 0, 0.58, 1),
+    bounce,
+};
+// ---- colours ----
+const RGB = {
+    normal: [255, 255, 255], white: [255, 255, 255], black: [0, 0, 0], red: [255, 0, 0], green: [0, 255, 0], yellow: [255, 255, 0],
+    blue: [0, 0, 255], magenta: [255, 0, 255], cyan: [0, 255, 255], accent: [0, 255, 255],
+};
+const hex2 = (n) => n.toString(16).padStart(2, '0');
+/** IMPL-DEFINED rounding: nearest, ties up (SPEC gives only the source-over formula). */
+function blend(fg, alpha, bg) {
+    if (alpha >= 1)
+        return fg;
+    const s = RGB[fg] ?? RGB.normal;
+    let d = [0, 0, 0];
+    if (bg !== '') {
+        if (bg[0] === '#')
+            d = [1, 3, 5].map((i) => parseInt(bg.slice(i, i + 2), 16));
+        else
+            d = RGB[bg] ?? [0, 0, 0];
+    }
+    return '#' + [0, 1, 2].map((i) => hex2(Math.max(0, Math.min(255, Math.floor(s[i] * alpha + d[i] * (1 - alpha) + 0.5))))).join('');
+}
+function sizeOf(sh) {
+    if (sh.kind === 'text') {
+        const g = (0, unicode_1.graphemes)(sh.text);
+        return [g.length, 1, g];
+    }
+    if (sh.kind === 'rect')
+        return [sh.width, sh.height, []];
+    if (sh.kind === 'circle')
+        return [2 * sh.radius, 2 * sh.radius, []];
+    return [sh.size, sh.size, []];
+}
+function compileDocument(doc) {
+    const by = new Map();
+    const actors = doc.actors.map((a, index) => {
+        const [w, h, clusters] = sizeOf(a.shape);
+        const act = { name: a.name, index, z: a.z ?? 0, parent: null, shape: a.shape, w, h, clusters, atPoint: a.at, anchorPoint: a.anchor, color: a.color ?? 'normal', acts: [] };
+        by.set(a.name, act);
+        return act;
+    });
+    doc.actors.forEach((a, i) => { if (a.parent !== undefined)
+        actors[i].parent = by.get(a.parent); });
+    const sorted = [...doc.actions].sort((p, q) => p.beginNs - q.beginNs); // stable: source order breaks ties
+    for (const a of sorted)
+        by.get(a.actor).acts.push(a);
+    const s = doc.scene;
+    const order = [...actors].sort((p, q) => p.z - q.z || p.index - q.index);
+    return { width: s.width, height: s.height, fps: s.fps, durationNs: s.duration, periodNs: s.period, repeat: s.repeat, fallback: s.fallback, actors, order };
+}
+function compile(source) {
+    const r = (0, check_1.parseChecked)(source);
+    return r.ok ? { ok: true, scene: compileDocument(r.doc) } : { ok: false, diagnostics: r.diagnostics };
+}
+// ---- argument helpers ----
+const arg = (a, k) => a.args.find((g) => g.key === k)?.value;
+const has = (a, k) => a.args.some((g) => g.key === k);
+const secs = (v) => (0, parse_1.decimalToNs)(v.raw.replace(/^\+/, '').replace(/s$/, ''));
+const num = (v) => v.value;
+const deg = (v) => { const n = v; return n.suffix === 'rad' ? (n.value * 180) / Math.PI : n.value; };
+function coord(c, size, box, anchorNames) {
+    if (c.kind === 'num')
+        return c.percent ? (c.value / 100) * (box - size) : c.value;
+    const rem = box - size;
+    const base = c.name === anchorNames[0] ? 0 : c.name === anchorNames[1] ? rem : rem / 2;
+    return base + c.offset;
+}
+const resolve = (p, w, h, bw, bh) => [coord(p.x, w, bw, ['left', 'right']), coord(p.y, h, bh, ['top', 'bottom'])];
+function evalActor(sc, a, T) {
+    const box = a.parent ? [a.parent.w, a.parent.h] : [sc.width, sc.height];
+    const [x0, y0] = resolve(a.atPoint, a.w, a.h, box[0], box[1]);
+    const st = { opacity: 1, x: x0, y: y0, scale: 1, color: a.color, reveal: 1, count: null, rot: [0, 0, 0] };
+    const done = {};
+    for (const ac of a.acts) {
+        const b = ac.beginNs, e = ac.endNs, dur = ac.durNs;
+        const started = T >= b, over = T >= e;
+        const ease = EASE[arg(ac, 'ease')?.value ?? 'linear'];
+        const p = started && !over && dur > 0 ? ease((T - b) / dur) : over ? 1 : 0;
+        const prop = ac.property;
+        if (done[prop])
+            continue;
+        if (T < b && !(ac.verb === 'fade' || ac.verb === 'wipe' || ac.verb === 'type' || ac.verb === 'slide')) {
+            done[prop] = true;
+            continue;
+        }
+        switch (ac.verb) {
+            case 'fade': {
+                const inn = has(ac, 'in');
+                st.opacity = over ? (inn ? 1 : 0) : !started ? (inn ? 0 : st.opacity) : inn ? p : 1 - p;
+                break;
+            }
+            case 'blink': {
+                if (started && !over) {
+                    const half = dur / (2 * num(arg(ac, 'times')));
+                    if (Math.floor((T - b) / half) % 2 === 1)
+                        st.opacity = 0;
+                }
+                break;
+            }
+            case 'wipe': {
+                const inn = has(ac, 'in');
+                st.count = null;
+                st.reveal = over ? (inn ? 1 : 0) : !started ? (inn ? 0 : st.reveal) : inn ? p : st.reveal * (1 - p);
+                break;
+            }
+            case 'type': {
+                const per = secs(arg(ac, 'per_char'));
+                st.count = over ? a.clusters.length : !started ? 0 : Math.min(a.clusters.length, Math.floor((T - b) / per));
+                st.reveal = 1;
+                break;
+            }
+            case 'move': {
+                const [tx, ty] = resolve(arg(ac, 'to').value, a.w, a.h, box[0], box[1]);
+                if (over) {
+                    st.x = tx;
+                    st.y = ty;
+                }
+                else {
+                    st.x += (tx - st.x) * p;
+                    st.y += (ty - st.y) * p;
+                }
+                break;
+            }
+            case 'slide': {
+                const edge = arg(ac, 'to').value;
+                const inn = has(ac, 'in');
+                let ex = st.x, ey = st.y;
+                if (edge === 'left')
+                    ex = -a.w;
+                else if (edge === 'right')
+                    ex = box[0];
+                else if (edge === 'top')
+                    ey = -a.h;
+                else
+                    ey = box[1];
+                if (inn) {
+                    if (over) { /* ends at current origin */ }
+                    else {
+                        st.x = ex + (st.x - ex) * p;
+                        st.y = ey + (st.y - ey) * p;
+                    }
+                }
+                else if (over) {
+                    st.x = ex;
+                    st.y = ey;
+                }
+                else if (started) {
+                    st.x += (ex - st.x) * p;
+                    st.y += (ey - st.y) * p;
+                }
+                break;
+            }
+            case 'scale': {
+                const t = num(arg(ac, 'to'));
+                st.scale = over ? t : st.scale + (t - st.scale) * p;
+                break;
+            }
+            case 'color': {
+                const t = arg(ac, 'to').value;
+                if (over || p >= 0.5)
+                    st.color = t;
+                break;
+            }
+            case 'rotate': {
+                ['x', 'y', 'z'].forEach((k, i) => { if (has(ac, k)) {
+                    const t = deg(arg(ac, k));
+                    st.rot[i] = over ? t : st.rot[i] + (t - st.rot[i]) * p;
+                } });
+                break;
+            }
+        }
+        if (T < b)
+            done[prop] = true;
+    }
+    return st;
+}
+// ---- raster ----
+const BIT = [[1, 8], [2, 16], [4, 32], [64, 128]]; // [row][col]
+class Grid {
+    constructor(w, h) {
+        this.w = w;
+        this.h = h;
+        this.cells = Array.from({ length: h }, () => Array.from({ length: w }, () => ({ r: ' ', fg: 'normal', bg: '' })));
+    }
+    put(col, row, r, color, alpha) {
+        if (col < 0 || row < 0 || col >= this.w || row >= this.h || r === ' ' || alpha <= 0)
+            return;
+        const c = this.cells[row][col];
+        c.r = r;
+        c.fg = alpha >= 1 ? color : blend(color, alpha, c.bg);
+    }
+}
+const q9 = (v) => Math.round(v * 1e9) / 1e9;
+function worldMatrices(sc, T) {
+    const out = new Map();
+    const get = (a) => {
+        const hit = out.get(a);
+        if (hit)
+            return hit;
+        const st = evalActor(sc, a, T);
+        const par = a.parent ? get(a.parent) : null;
+        let ax = a.w / 2, ay = a.h / 2;
+        if (a.anchorPoint) {
+            ax = coord(a.anchorPoint.x, 0, a.w, ['left', 'right']);
+            ay = coord(a.anchorPoint.y, 0, a.h, ['top', 'bottom']);
+        }
+        let local = mul(trans(st.x + ax, -2 * (st.y + ay), 0), mul(rotM(st.rot[0], st.rot[1], st.rot[2]), mul(scaleM(st.scale), trans(-ax, 2 * ay, 0))));
+        if (par)
+            local = mul(par.m, local);
+        const fr = st.count !== null ? (a.clusters.length ? st.count / a.clusters.length : 1) : st.reveal;
+        const r = { m: local, st, alpha: st.opacity * (par ? par.alpha : 1), frac: fr * (par ? par.frac : 1), ax, ay };
+        out.set(a, r);
+        return r;
+    };
+    for (const a of sc.actors)
+        get(a);
+    return out;
+}
+/** cell-space point (col,row) of a local cell-space point through the model matrix */
+function toCell(m, cx, cy) {
+    const p = xf(m, [cx, -2 * cy, 0]);
+    return [p[0], -p[1] / 2];
+}
+const dotOf = (col, row) => [2 * col - 0.5, 4 * row - 0.5];
+function line(dots, W, H, a, b) {
+    let x0 = q9(a[0]), y0 = q9(a[1]), x1 = q9(b[0]), y1 = q9(b[1]);
+    // clip the quantized segment to the stage dot box [0,2W-1]x[0,4H-1] before stepping (Liang-Barsky)
+    let t0 = 0, t1 = 1;
+    const dx0 = x1 - x0, dy0 = y1 - y0;
+    for (const [p, qd] of [[-dx0, x0], [dx0, 2 * W - 1 - x0], [-dy0, y0], [dy0, 4 * H - 1 - y0]]) {
+        if (p === 0) {
+            if (qd < 0)
+                return;
+            continue;
+        }
+        const r = qd / p;
+        if (p < 0) {
+            if (r > t1)
+                return;
+            if (r > t0)
+                t0 = r;
+        }
+        else {
+            if (r < t0)
+                return;
+            if (r < t1)
+                t1 = r;
+        }
+    }
+    [x0, y0, x1, y1] = [x0 + dx0 * t0, y0 + dy0 * t0, x0 + dx0 * t1, y0 + dy0 * t1];
+    const n = Math.min(800, Math.max(1, Math.ceil(Math.max(Math.abs(x1 - x0), Math.abs(y1 - y0))))); // reference profile: capped 800, min 1
+    for (let i = 0; i <= n; i++) {
+        const t = i / n;
+        const dx = Math.round(x0 + (x1 - x0) * t), dy = Math.round(y0 + (y1 - y0) * t);
+        if (dx >= 0 && dy >= 0 && dx < W * 2 && dy < H * 4)
+            dots.add(dy * W * 2 + dx);
+    }
+}
+function paintDots(g, dots, color, alpha) {
+    const bits = new Map();
+    for (const d of dots) {
+        const dy = Math.floor(d / (g.w * 2)), dx = d % (g.w * 2);
+        const key = Math.floor(dy / 4) * g.w + Math.floor(dx / 2);
+        bits.set(key, (bits.get(key) ?? 0) | BIT[dy % 4][dx % 2]);
+    }
+    for (const [key, b] of bits)
+        g.put(key % g.w, Math.floor(key / g.w), String.fromCodePoint(0x2800 + b), color, alpha);
+}
+function clipLine(p0, p1) {
+    let t0 = 0, t1 = 1;
+    for (let axis = 0; axis < 3; axis++) {
+        for (const sgn of [1, -1]) {
+            const d0 = p0[3] - sgn * p0[axis], d1 = p1[3] - sgn * p1[axis]; // >= 0 inside: w - s*c
+            if (d0 < 0 && d1 < 0)
+                return null;
+            if (d0 < 0)
+                t0 = Math.max(t0, d0 / (d0 - d1));
+            else if (d1 < 0)
+                t1 = Math.min(t1, d0 / (d0 - d1));
+        }
+    }
+    if (t0 > t1)
+        return null;
+    const at = (t) => p0.map((v, i) => v + (p1[i] - v) * t);
+    return [at(t0), at(t1)];
+}
+function renderActor(sc, g, a, w) {
+    const color = w.st.color, alpha = w.alpha;
+    if (alpha <= 0 || w.frac <= 0 && a.shape.kind !== 'text')
+        return;
+    const sh = a.shape;
+    if (sh.kind === 'text') {
+        const n = a.clusters.length;
+        const shown = w.st.count !== null ? Math.min(w.st.count, Math.floor(w.frac * n + 1e-9) === n ? n : Math.floor(w.frac * n + 1e-9)) : Math.floor(w.frac * n + 1e-9);
+        const cnt = w.st.count !== null && w.frac >= 1 ? w.st.count : shown;
+        for (let i = 0; i < Math.min(cnt, n); i++) {
+            const [c, r] = toCell(w.m, i, 0);
+            g.put(rnd(c), rnd(r), (0, unicode_1.cellRune)(a.clusters[i]), color, alpha);
+        }
+        return;
+    }
+    const dots = new Set();
+    const cellToDot = (cx, cy) => { const [c, r] = toCell(w.m, cx, cy); return dotOf(c, r); };
+    // local dot (dx,dy) -> local cell-space centre -> model -> dot
+    const dotThrough = (dx, dy) => cellToDot((dx + 0.5) / 2, (dy + 0.5) / 4);
+    const clipX = w.frac < 1 ? w.frac * 2 * a.w : Infinity; // IMPL-DEFINED left-to-right reveal on local dot columns
+    if (sh.kind === 'rect') {
+        const W = 2 * sh.width - 1, H = 4 * sh.height - 1;
+        const corners = [[0, 0], [W, 0], [W, H], [0, H]];
+        for (let i = 0; i < 4; i++)
+            line(dots, g.w, g.h, dotThrough(...corners[i]), dotThrough(...corners[(i + 1) % 4]));
+    }
+    else if (sh.kind === 'circle') {
+        const rx = 2 * sh.radius - 0.5, ry = 4 * sh.radius - 0.5; // dot radii of the 2N x 2N cell bounding box
+        // 720 chords, k=1..720, angle k*pi/360, starting at the rightmost point (reference profile, not SPEC)
+        let prev = dotThrough(2 * rx, ry);
+        for (let k = 1; k <= 720; k++) {
+            const t = (k * Math.PI) / 360;
+            const lx = rx + rx * Math.cos(t), ly = ry + ry * Math.sin(t);
+            const cur = dotThrough(lx, ly);
+            if (lx <= clipX)
+                line(dots, g.w, g.h, prev, cur);
+            prev = cur;
+        }
+    }
+    else {
+        cubeDots(dots, g, a, sh.size, w.m);
+    }
+    paintDots(g, dots, color, alpha);
+    if (sh.kind === 'rect' && sh.title) {
+        const t = (0, unicode_1.graphemes)(sh.title);
+        for (let i = 0; i < Math.min(t.length, sh.width - 2); i++) {
+            const [c, r] = toCell(w.m, 1 + i, 0);
+            g.put(rnd(c), rnd(r), (0, unicode_1.cellRune)(t[i]), color, alpha);
+        }
+    }
+}
+function cubeDots(dots, g, a, size, M) {
+    const n = size;
+    const verts = [];
+    for (const dx of [0, 1])
+        for (const dy of [0, 1])
+            for (const dz of [0, 1])
+                verts.push([n / 2 + (dx ? n / 2 : -n / 2), -n + (dy ? n / 2 : -n / 2), dz ? n / 2 : -n / 2]);
+    const centre = xf(M, [n / 2, -n, 0]);
+    const tm = trans(-centre[0], -centre[1], -(centre[2] + 3 * n));
+    const fov = (50 * Math.PI) / 180, qq = 1 / Math.tan(fov / 2), asp = n / (2 * n), near = 0.1, far = 1000;
+    const P = [qq / asp, 0, 0, 0, 0, qq, 0, 0, 0, 0, -(far + near) / (far - near), -1, 0, 0, (-2 * far * near) / (far - near), 0];
+    const PV = mul(P, tm);
+    const clip = verts.map((v) => xf(PV, xf(M, v).slice(0, 3)));
+    // viewport: n x n cells centred on the transformed cube centre (cell space)
+    const [ccol, crow] = (() => { const p = centre; return [p[0], -p[1] / 2]; })();
+    const left = ccol - n / 2, top = crow - n / 2;
+    const edges = [];
+    for (let i = 0; i < 8; i++)
+        for (const bit of [1, 2, 4])
+            if (!(i & bit))
+                edges.push([i, i | bit]);
+    for (const [i, j] of edges) {
+        const c = clipLine(clip[i], clip[j]);
+        if (!c)
+            continue;
+        const pr = c.map((p) => {
+            const ndcX = p[0] / p[3], ndcY = p[1] / p[3];
+            const col = left + ((ndcX + 1) * n) / 2, row = top + ((1 - ndcY) * n) / 2;
+            return dotOf(col, row);
+        });
+        line(dots, g.w, g.h, pr[0], pr[1]);
+    }
+}
+function compose(sc, T, W, H) {
+    const g = new Grid(Math.min(W, sc.width), Math.min(H, sc.height));
+    // paint on the full stage then crop, so clipping/clamping stays stage-relative
+    const full = new Grid(sc.width, sc.height);
+    const wm = worldMatrices(sc, T);
+    for (const a of sc.order)
+        renderActor(sc, full, a, wm.get(a));
+    for (let r = 0; r < g.h; r++)
+        for (let c = 0; c < g.w; c++)
+            g.cells[r][c] = full.cells[r][c];
+    return g;
+}
+/** Frame at absolute time `tNs` (integer nanoseconds). `Done` per SPEC; repeat semantics included. */
+function frameNs(sc, tNs, width = sc.width, height = sc.height) {
+    const D = sc.durationNs;
+    let local = tNs, done = D === 0;
+    if (D > 0) {
+        const total = sc.repeat === Infinity ? Infinity : D * sc.repeat;
+        if (tNs >= total) {
+            local = D;
+            done = true;
+        }
+        else {
+            local = tNs % D;
+        }
+    }
+    else
+        local = 0;
+    const g = compose(sc, local, width, height);
+    return { width: g.w, height: g.h, cells: g.cells, done };
+}
+/** Fallback sample of the simple timeline (no repeat); `done` is omitted. */
+function fallbackFrame(sc, width = sc.width, height = sc.height) {
+    const f = sc.fallback;
+    const T = f.kind === 'start' ? 0 : f.kind === 'end' ? Infinity : f.ns;
+    const g = compose(sc, T, width, height);
+    return { width: g.w, height: g.h, cells: g.cells };
+}

package/dist/index.d.ts

@@ -1,16 +1,15 @@
 export declare const VERSION: string;
-/** One diagnostic. `line` is 1-based. */
-export interface Diag {
-    line: number;
-    col: number;
-    message: string;
-}
-/** Alias of {@link Diag}. */
-export type Problem = Diag;
-/** Result of {@link check}: an empty array means no limit/header problems. */
-export type CheckResult = Diag[];
-/**
- * Subset check. Returns diagnostics; [] means "no limit/header problems found"
- * (NOT "valid MDGL"). Throws TypeError for non-string input.
- */
-export declare function check(source: string): CheckResult;
+export { check, checkDocument, parseChecked } from './check';
+export type { CheckedAction, CheckedDocument, CheckedScene, Fallback, ParseResult } from './check';
+export { parse } from './parse';
+export type { ActionStmt, ActorStmt, Arg, Coord, Diag, Document, Point, SceneStmt, Shape, Stmt, Value } from './parse';
+/** Alias of Diag. */
+export type Problem = import('./parse').Diag;
+/** Result of check(): empty means valid. */
+export type CheckResult = import('./parse').Diag[];
+export { UNICODE_VERSION, cellRune, clusterWidth, graphemeCount, graphemeRanges, graphemes } from './unicode';
+export { compile, compileDocument, frameNs, fallbackFrame } from './eval';
+export type { Cell, Compiled, CompileResult, Frame } from './eval';
+export { handleLine, mathInt, MAX_REQUEST_LINE } from "./adapter";
+export { play, plainFallback, plainText, sanitizeRune, SYNC_BEGIN, SYNC_END, HIDE_CURSOR, SHOW_CURSOR, RESET } from './play';
+export type { Clock, PlayDeps, PlayEnd, PlayHandle, PlayResult } from './play';

package/dist/index.js

@@ -1,100 +1,38 @@
 "use strict";
-// MDGL 0.0.1 -- SUBSET limit/header checker. NOT a conformant MDGL implementation.
-// Checks only: input <= 256 KiB, line <= 16 KiB, scene header (width 1..200,
-// height 1..60, fallback; no unknown/duplicate keys), statement order,
-// <= 64 actors, <= 1024 actions. Does NOT parse actor/action bodies or check
-// grammar, timing, references or rendering. An empty result means
-// "no limit/header problems found", NOT "valid MDGL". Reference: the Go module.
-// Spec: https://github.com/enmaq/mdgl/blob/main/SPEC.md
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = void 0;
-exports.check = check;
-exports.VERSION = '0.2.0';
-const MAX_INPUT = 256 * 1024;
-const MAX_LINE = 16384;
-const MAX_ACTORS = 64;
-const MAX_ACTIONS = 1024;
-const KEYS = ['width', 'height', 'period', 'repeat', 'fallback', 'fps'];
-const d = (line, message) => [{ line, col: 1, message }];
-const bytes = (s) => Buffer.byteLength(s, 'utf8');
-function sceneHeader(n, rest) {
-    const seen = new Map();
-    for (const tok of rest.split(/[ \t\r]+/).filter(Boolean)) {
-        const i = tok.indexOf('=');
-        if (i <= 0 || i === tok.length - 1)
-            return d(n, `malformed scene attribute ${JSON.stringify(tok)}`);
-        const k = tok.slice(0, i);
-        if (!KEYS.includes(k))
-            return d(n, `unknown scene attribute ${JSON.stringify(k)}`);
-        if (seen.has(k))
-            return d(n, `duplicate scene attribute ${JSON.stringify(k)}`);
-        seen.set(k, tok.slice(i + 1));
-    }
-    const out = ['width', 'height', 'fallback']
-        .filter((k) => !seen.has(k))
-        .map((k) => ({ line: n, col: 1, message: `scene header missing ${k}=` }));
-    if (out.length)
-        return out;
-    for (const [k, max] of [['width', 200], ['height', 60]]) {
-        const v = seen.get(k);
-        if (!/^[0-9]{1,9}$/.test(v) || Number(v) < 1 || Number(v) > max) {
-            return d(n, `${k} must be an integer 1..${max}`);
-        }
-    }
-    return [];
-}
-/**
- * Subset check. Returns diagnostics; [] means "no limit/header problems found"
- * (NOT "valid MDGL"). Throws TypeError for non-string input.
- */
-function check(source) {
-    if (typeof source !== 'string')
-        throw new TypeError('mdgl.check: source must be a string');
-    if (bytes(source) > MAX_INPUT)
-        return d(1, 'input exceeds 256 KiB');
-    let scene = false, action = false, version = false, actors = 0, actions = 0;
-    const lines = source.split('\n');
-    for (let i = 0; i < lines.length; i++) {
-        const n = i + 1;
-        if (bytes(lines[i]) > MAX_LINE)
-            return d(n, 'line exceeds 16 KiB');
-        const t = lines[i].replace(/^[ \t\r]+|[ \t\r]+$/g, '');
-        if (t === '' || t[0] === '#')
-            continue;
-        const head = t[0] === '@' ? '@' : t.split(/[ \t]/)[0];
-        switch (head) {
-            case 'mdgl':
-                if (scene || version || t.slice(4).trim() !== '0.1')
-                    return d(n, 'expected initial mdgl 0.1');
-                version = true;
-                break;
-            case 'scene': {
-                if (scene)
-                    return d(n, 'duplicate scene');
-                scene = true;
-                const r = sceneHeader(n, t.slice(5));
-                if (r.length)
-                    return r;
-                break;
-            }
-            case 'actor':
-                if (!scene)
-                    return d(n, 'scene must precede actors');
-                if (action)
-                    return d(n, 'actors must precede actions');
-                if (++actors > MAX_ACTORS)
-                    return d(n, 'actor limit 64 exceeded');
-                break;
-            case '@':
-                if (!scene)
-                    return d(n, 'scene must precede actions');
-                action = true;
-                if (++actions > MAX_ACTIONS)
-                    return d(n, 'action limit 1024 exceeded');
-                break;
-            default:
-                return d(n, 'unsupported statement (expected mdgl, scene, actor or @)');
-        }
-    }
-    return scene ? [] : d(1, 'missing scene');
-}
+exports.RESET = exports.SHOW_CURSOR = exports.HIDE_CURSOR = exports.SYNC_END = exports.SYNC_BEGIN = exports.sanitizeRune = exports.plainText = exports.plainFallback = exports.play = exports.MAX_REQUEST_LINE = exports.mathInt = exports.handleLine = exports.fallbackFrame = exports.frameNs = exports.compileDocument = exports.compile = exports.graphemes = exports.graphemeRanges = exports.graphemeCount = exports.clusterWidth = exports.cellRune = exports.UNICODE_VERSION = exports.parse = exports.parseChecked = exports.checkDocument = exports.check = exports.VERSION = void 0;
+// @enmaq/mdgl: MDGL 0.1 parser and checker (development tree; evaluator and
+// rendering are not implemented yet). Spec: ../SPEC.md
+exports.VERSION = '0.3.0';
+var check_1 = require("./check");
+Object.defineProperty(exports, "check", { enumerable: true, get: function () { return check_1.check; } });
+Object.defineProperty(exports, "checkDocument", { enumerable: true, get: function () { return check_1.checkDocument; } });
+Object.defineProperty(exports, "parseChecked", { enumerable: true, get: function () { return check_1.parseChecked; } });
+var parse_1 = require("./parse");
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parse_1.parse; } });
+var unicode_1 = require("./unicode");
+Object.defineProperty(exports, "UNICODE_VERSION", { enumerable: true, get: function () { return unicode_1.UNICODE_VERSION; } });
+Object.defineProperty(exports, "cellRune", { enumerable: true, get: function () { return unicode_1.cellRune; } });
+Object.defineProperty(exports, "clusterWidth", { enumerable: true, get: function () { return unicode_1.clusterWidth; } });
+Object.defineProperty(exports, "graphemeCount", { enumerable: true, get: function () { return unicode_1.graphemeCount; } });
+Object.defineProperty(exports, "graphemeRanges", { enumerable: true, get: function () { return unicode_1.graphemeRanges; } });
+Object.defineProperty(exports, "graphemes", { enumerable: true, get: function () { return unicode_1.graphemes; } });
+var eval_1 = require("./eval");
+Object.defineProperty(exports, "compile", { enumerable: true, get: function () { return eval_1.compile; } });
+Object.defineProperty(exports, "compileDocument", { enumerable: true, get: function () { return eval_1.compileDocument; } });
+Object.defineProperty(exports, "frameNs", { enumerable: true, get: function () { return eval_1.frameNs; } });
+Object.defineProperty(exports, "fallbackFrame", { enumerable: true, get: function () { return eval_1.fallbackFrame; } });
+var adapter_1 = require("./adapter");
+Object.defineProperty(exports, "handleLine", { enumerable: true, get: function () { return adapter_1.handleLine; } });
+Object.defineProperty(exports, "mathInt", { enumerable: true, get: function () { return adapter_1.mathInt; } });
+Object.defineProperty(exports, "MAX_REQUEST_LINE", { enumerable: true, get: function () { return adapter_1.MAX_REQUEST_LINE; } });
+var play_1 = require("./play");
+Object.defineProperty(exports, "play", { enumerable: true, get: function () { return play_1.play; } });
+Object.defineProperty(exports, "plainFallback", { enumerable: true, get: function () { return play_1.plainFallback; } });
+Object.defineProperty(exports, "plainText", { enumerable: true, get: function () { return play_1.plainText; } });
+Object.defineProperty(exports, "sanitizeRune", { enumerable: true, get: function () { return play_1.sanitizeRune; } });
+Object.defineProperty(exports, "SYNC_BEGIN", { enumerable: true, get: function () { return play_1.SYNC_BEGIN; } });
+Object.defineProperty(exports, "SYNC_END", { enumerable: true, get: function () { return play_1.SYNC_END; } });
+Object.defineProperty(exports, "HIDE_CURSOR", { enumerable: true, get: function () { return play_1.HIDE_CURSOR; } });
+Object.defineProperty(exports, "SHOW_CURSOR", { enumerable: true, get: function () { return play_1.SHOW_CURSOR; } });
+Object.defineProperty(exports, "RESET", { enumerable: true, get: function () { return play_1.RESET; } });