strom-research 1.0.0

package/dist/image/jpeg-encode.js

@@ -0,0 +1,254 @@
+// Baseline JPEG encoder (the standard tables of ITU T.81 Annex K): the views
+// strom makes of scans are written with it. 4:4:4 for colour — script and
+// thin strokes keep their colour edges — or one grey channel.
+const ZIGZAG = [
+    0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22,
+    15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63,
+];
+const LUMA_Q = [
+    16, 11, 10, 16, 24, 40, 51, 61, 12, 12, 14, 19, 26, 58, 60, 55, 14, 13, 16, 24, 40, 57, 69, 56, 14, 17, 22, 29, 51, 87, 80, 62, 18, 22, 37, 56, 68, 109, 103, 77, 24,
+    35, 55, 64, 81, 104, 113, 92, 49, 64, 78, 87, 103, 121, 120, 101, 72, 92, 95, 98, 112, 100, 103, 99,
+];
+const CHROMA_Q = [
+    17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66, 99, 99, 99, 99, 24, 26, 56, 99, 99, 99, 99, 99, 47, 66, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+];
+// Annex K.3 Huffman tables: counts of codes per length 1..16, then the values.
+const DC_LUMA = { counts: [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] };
+const DC_CHROMA = { counts: [0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0], values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] };
+const AC_LUMA = {
+    counts: [0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d],
+    values: [
+        0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42,
+        0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x34, 0x35,
+        0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67,
+        0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+        0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+        0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4,
+        0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa,
+    ],
+};
+const AC_CHROMA = {
+    counts: [0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77],
+    values: [
+        0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1,
+        0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 0x27, 0x28, 0x29, 0x2a,
+        0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66,
+        0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
+        0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+        0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4,
+        0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa,
+    ],
+};
+function codes(spec) {
+    const code = new Int32Array(256);
+    const size = new Int32Array(256);
+    let c = 0;
+    let k = 0;
+    for (let len = 1; len <= 16; len++) {
+        for (let i = 0; i < spec.counts[len - 1]; i++, k++, c++) {
+            code[spec.values[k]] = c;
+            size[spec.values[k]] = len;
+        }
+        c <<= 1;
+    }
+    return { code, size };
+}
+const TABLES = { dcL: codes(DC_LUMA), acL: codes(AC_LUMA), dcC: codes(DC_CHROMA), acC: codes(AC_CHROMA) };
+function scaledTable(base, quality) {
+    const q = Math.max(1, Math.min(100, quality));
+    const scale = q < 50 ? 5000 / q : 200 - q * 2;
+    return base.map((v) => Math.max(1, Math.min(255, Math.floor((v * scale + 50) / 100))));
+}
+class Writer {
+    chunks = [];
+    buf = 0;
+    bits = 0;
+    byte(b) {
+        this.chunks.push(b & 0xff);
+    }
+    word(w) {
+        this.byte(w >> 8);
+        this.byte(w);
+    }
+    put(code, size) {
+        for (let i = size - 1; i >= 0; i--) {
+            this.buf = (this.buf << 1) | ((code >> i) & 1);
+            if (++this.bits === 8) {
+                this.byte(this.buf);
+                if (this.buf === 0xff)
+                    this.byte(0); // stuffing
+                this.buf = 0;
+                this.bits = 0;
+            }
+        }
+    }
+    flush() {
+        if (this.bits > 0)
+            this.put((1 << (8 - this.bits)) - 1, 8 - this.bits); // pad with ones
+    }
+    bytes() {
+        return Uint8Array.from(this.chunks);
+    }
+}
+/** Forward DCT factor table: C(u) cos((2x+1)uπ/16) / 2. */
+const FCOS = (() => {
+    const t = new Float64Array(64);
+    for (let u = 0; u < 8; u++)
+        for (let x = 0; x < 8; x++)
+            t[u * 8 + x] = ((u === 0 ? Math.SQRT1_2 : 1) * Math.cos(((2 * x + 1) * u * Math.PI) / 16)) / 2;
+    return t;
+})();
+function fdct(block, tmp, out) {
+    for (let y = 0; y < 8; y++)
+        for (let u = 0; u < 8; u++) {
+            let s = 0;
+            for (let x = 0; x < 8; x++)
+                s += FCOS[u * 8 + x] * block[y * 8 + x];
+            tmp[y * 8 + u] = s;
+        }
+    for (let u = 0; u < 8; u++)
+        for (let v = 0; v < 8; v++) {
+            let s = 0;
+            for (let y = 0; y < 8; y++)
+                s += FCOS[v * 8 + y] * tmp[y * 8 + u];
+            out[v * 8 + u] = s;
+        }
+}
+function magnitude(v) {
+    const a = Math.abs(v);
+    let size = 0;
+    while (a >> size)
+        size++;
+    return { size, bits: v < 0 ? v + (1 << size) - 1 : v };
+}
+export function encodeJpeg(img, quality = 90) {
+    const { width, height, channels } = img;
+    const w = new Writer();
+    const qL = scaledTable(LUMA_Q, quality);
+    const qC = scaledTable(CHROMA_Q, quality);
+    // SOI + JFIF
+    w.word(0xffd8);
+    w.word(0xffe0);
+    w.word(16);
+    for (const c of [0x4a, 0x46, 0x49, 0x46, 0])
+        w.byte(c);
+    w.word(0x0101);
+    w.byte(0);
+    w.word(1);
+    w.word(1);
+    w.byte(0);
+    w.byte(0);
+    // DQT
+    const tables = channels === 3 ? [qL, qC] : [qL];
+    tables.forEach((t, i) => {
+        w.word(0xffdb);
+        w.word(67);
+        w.byte(i);
+        for (let k = 0; k < 64; k++)
+            w.byte(t[ZIGZAG[k]]);
+    });
+    // SOF0
+    w.word(0xffc0);
+    w.word(8 + 3 * channels);
+    w.byte(8);
+    w.word(height);
+    w.word(width);
+    w.byte(channels);
+    for (let c = 0; c < channels; c++) {
+        w.byte(c + 1);
+        w.byte(0x11);
+        w.byte(c === 0 ? 0 : 1);
+    }
+    // DHT
+    const dht = (cls, id, spec) => {
+        w.word(0xffc4);
+        w.word(3 + 16 + spec.values.length);
+        w.byte((cls << 4) | id);
+        for (const n of spec.counts)
+            w.byte(n);
+        for (const v of spec.values)
+            w.byte(v);
+    };
+    dht(0, 0, DC_LUMA);
+    dht(1, 0, AC_LUMA);
+    if (channels === 3) {
+        dht(0, 1, DC_CHROMA);
+        dht(1, 1, AC_CHROMA);
+    }
+    // SOS
+    w.word(0xffda);
+    w.word(6 + 2 * channels);
+    w.byte(channels);
+    for (let c = 0; c < channels; c++) {
+        w.byte(c + 1);
+        w.byte(c === 0 ? 0x00 : 0x11);
+    }
+    w.byte(0);
+    w.byte(63);
+    w.byte(0);
+    const block = new Float64Array(64);
+    const tmp = new Float64Array(64);
+    const coef = new Float64Array(64);
+    const pred = [0, 0, 0];
+    const encodeBlock = (comp) => {
+        fdct(block, tmp, coef);
+        const q = comp === 0 ? qL : qC;
+        const dc = comp === 0 ? TABLES.dcL : TABLES.dcC;
+        const ac = comp === 0 ? TABLES.acL : TABLES.acC;
+        const zz = new Int32Array(64);
+        for (let k = 0; k < 64; k++)
+            zz[k] = Math.round(coef[ZIGZAG[k]] / q[ZIGZAG[k]]);
+        const diff = zz[0] - pred[comp];
+        pred[comp] = zz[0];
+        const m = magnitude(diff);
+        w.put(dc.code[m.size], dc.size[m.size]);
+        if (m.size)
+            w.put(m.bits, m.size);
+        let run = 0;
+        for (let k = 1; k < 64; k++) {
+            const v = zz[k];
+            if (v === 0) {
+                run++;
+                continue;
+            }
+            while (run > 15) {
+                w.put(ac.code[0xf0], ac.size[0xf0]);
+                run -= 16;
+            }
+            const mm = magnitude(v);
+            const sym = (run << 4) | mm.size;
+            w.put(ac.code[sym], ac.size[sym]);
+            w.put(mm.bits, mm.size);
+            run = 0;
+        }
+        if (run > 0)
+            w.put(ac.code[0], ac.size[0]); // EOB
+    };
+    const data = img.data;
+    for (let by = 0; by < height; by += 8)
+        for (let bx = 0; bx < width; bx += 8)
+            for (let comp = 0; comp < channels; comp++) {
+                for (let y = 0; y < 8; y++)
+                    for (let x = 0; x < 8; x++) {
+                        // edge blocks repeat the last row/column
+                        const sx = Math.min(width - 1, bx + x);
+                        const sy = Math.min(height - 1, by + y);
+                        const p = (sy * width + sx) * channels;
+                        let v;
+                        if (channels === 1)
+                            v = data[p];
+                        else {
+                            const r = data[p];
+                            const g = data[p + 1];
+                            const b = data[p + 2];
+                            v = comp === 0 ? 0.299 * r + 0.587 * g + 0.114 * b : comp === 1 ? -0.168736 * r - 0.331264 * g + 0.5 * b + 128 : 0.5 * r - 0.418688 * g - 0.081312 * b + 128;
+                        }
+                        block[y * 8 + x] = v - 128;
+                    }
+                encodeBlock(comp);
+            }
+    w.flush();
+    w.word(0xffd9);
+    return w.bytes();
+}

package/dist/image/png.js

@@ -0,0 +1,241 @@
+// PNG decoder and encoder over node:zlib: every colour type and bit depth,
+// interlaced or not, transparency flattened onto white (a document on paper).
+import zlib from "node:zlib";
+export class PngError extends Error {
+}
+const SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[n] = c >>> 0;
+    }
+    return t;
+})();
+function crc32(bytes) {
+    let c = 0xffffffff;
+    for (let i = 0; i < bytes.length; i++)
+        c = CRC_TABLE[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+function paeth(a, b, c) {
+    const p = a + b - c;
+    const pa = Math.abs(p - a);
+    const pb = Math.abs(p - b);
+    const pc = Math.abs(p - c);
+    return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+}
+/** Undo the per-row filters of one (sub)image in place; returns the raw rows. */
+function unfilter(data, start, width, height, bpp, bitsPerPixel) {
+    const stride = Math.ceil((width * bitsPerPixel) / 8);
+    const rows = new Uint8Array(stride * height);
+    let p = start;
+    for (let y = 0; y < height; y++) {
+        const type = data[p++];
+        const row = y * stride;
+        const prev = row - stride;
+        for (let x = 0; x < stride; x++) {
+            const raw = data[p++];
+            const a = x >= bpp ? rows[row + x - bpp] : 0;
+            const b = y > 0 ? rows[prev + x] : 0;
+            const c = y > 0 && x >= bpp ? rows[prev + x - bpp] : 0;
+            let v;
+            switch (type) {
+                case 0:
+                    v = raw;
+                    break;
+                case 1:
+                    v = raw + a;
+                    break;
+                case 2:
+                    v = raw + b;
+                    break;
+                case 3:
+                    v = raw + ((a + b) >> 1);
+                    break;
+                case 4:
+                    v = raw + paeth(a, b, c);
+                    break;
+                default:
+                    throw new PngError(`unknown PNG filter ${type}`);
+            }
+            rows[row + x] = v & 0xff;
+        }
+    }
+    return { rows, used: p - start };
+}
+export function decodePng(bytes) {
+    for (let i = 0; i < 8; i++)
+        if (bytes[i] !== SIGNATURE[i])
+            throw new PngError("not a PNG file");
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let pos = 8;
+    let width = 0;
+    let height = 0;
+    let depth = 8;
+    let colour = 0;
+    let interlace = 0;
+    let palette;
+    let trns;
+    const idat = [];
+    while (pos + 8 <= bytes.length) {
+        const len = view.getUint32(pos);
+        const type = String.fromCharCode(...bytes.subarray(pos + 4, pos + 8));
+        const body = bytes.subarray(pos + 8, pos + 8 + len);
+        if (type === "IHDR") {
+            width = view.getUint32(pos + 8);
+            height = view.getUint32(pos + 12);
+            depth = body[8];
+            colour = body[9];
+            interlace = body[12];
+        }
+        else if (type === "PLTE")
+            palette = body;
+        else if (type === "tRNS")
+            trns = body;
+        else if (type === "IDAT")
+            idat.push(body);
+        else if (type === "IEND")
+            break;
+        pos += 12 + len;
+    }
+    if (!width || !height)
+        throw new PngError("PNG without IHDR");
+    const samples = colour === 0 ? 1 : colour === 2 ? 3 : colour === 3 ? 1 : colour === 4 ? 2 : colour === 6 ? 4 : 0;
+    if (!samples)
+        throw new PngError(`unknown PNG colour type ${colour}`);
+    const bitsPerPixel = samples * depth;
+    const bpp = Math.max(1, bitsPerPixel >> 3);
+    const inflated = new Uint8Array(zlib.inflateSync(Buffer.concat(idat)));
+    const grey = colour === 0 || colour === 4;
+    const out = { width, height, channels: grey ? 1 : 3, data: new Uint8Array(width * height * (grey ? 1 : 3)) };
+    const maxv = (1 << depth) - 1;
+    const read = (rows, stride, x, y, s) => {
+        if (depth === 8)
+            return rows[y * stride + x * samples + s];
+        if (depth === 16) {
+            const p = y * stride + (x * samples + s) * 2;
+            return rows[p]; // high byte
+        }
+        const bit = (x * samples + s) * depth;
+        const byte = rows[y * stride + (bit >> 3)];
+        return (byte >> (8 - depth - (bit & 7))) & maxv;
+    };
+    const scale = (v) => (depth === 8 || depth === 16 ? v : Math.round((v * 255) / maxv));
+    const place = (rows, w, h, x0, y0, dx, dy) => {
+        const stride = Math.ceil((w * bitsPerPixel) / 8);
+        for (let y = 0; y < h; y++)
+            for (let x = 0; x < w; x++) {
+                const tx = x0 + x * dx;
+                const ty = y0 + y * dy;
+                const o = (ty * width + tx) * out.channels;
+                let r;
+                let g;
+                let b;
+                let alpha = 255;
+                if (colour === 3) {
+                    const idx = read(rows, stride, x, y, 0);
+                    r = palette?.[idx * 3] ?? 0;
+                    g = palette?.[idx * 3 + 1] ?? 0;
+                    b = palette?.[idx * 3 + 2] ?? 0;
+                    if (trns && idx < trns.length)
+                        alpha = trns[idx];
+                }
+                else if (grey) {
+                    r = g = b = scale(read(rows, stride, x, y, 0));
+                    if (colour === 4)
+                        alpha = scale(read(rows, stride, x, y, 1));
+                }
+                else {
+                    r = scale(read(rows, stride, x, y, 0));
+                    g = scale(read(rows, stride, x, y, 1));
+                    b = scale(read(rows, stride, x, y, 2));
+                    if (colour === 6)
+                        alpha = scale(read(rows, stride, x, y, 3));
+                }
+                // flatten transparency onto white paper
+                const f = (v) => Math.round((v * alpha + 255 * (255 - alpha)) / 255);
+                if (out.channels === 1)
+                    out.data[o] = f(r);
+                else {
+                    out.data[o] = f(r);
+                    out.data[o + 1] = f(g);
+                    out.data[o + 2] = f(b);
+                }
+            }
+    };
+    if (interlace === 0) {
+        place(unfilter(inflated, 0, width, height, bpp, bitsPerPixel).rows, width, height, 0, 0, 1, 1);
+    }
+    else {
+        // Adam7: seven passes, each a small filtered image
+        const passes = [
+            [0, 0, 8, 8],
+            [4, 0, 8, 8],
+            [0, 4, 4, 8],
+            [2, 0, 4, 4],
+            [0, 2, 2, 4],
+            [1, 0, 2, 2],
+            [0, 1, 1, 2],
+        ];
+        let p = 0;
+        for (const [x0, y0, dx, dy] of passes) {
+            const w = Math.ceil((width - x0) / dx);
+            const h = Math.ceil((height - y0) / dy);
+            if (w <= 0 || h <= 0)
+                continue;
+            const { rows, used } = unfilter(inflated, p, w, h, bpp, bitsPerPixel);
+            place(rows, w, h, x0, y0, dx, dy);
+            p += used;
+        }
+    }
+    return out;
+}
+function chunk(type, body) {
+    const head = Buffer.alloc(8);
+    head.writeUInt32BE(body.length, 0);
+    head.write(type, 4, "latin1");
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(crc32(Buffer.concat([head.subarray(4), body])), 0);
+    return Buffer.concat([head, body, crc]);
+}
+/** Encode 8-bit grey or RGB; each row gets the filter that compresses it best (minimum sum). */
+export function encodePng(img) {
+    const { width, height, channels } = img;
+    const stride = width * channels;
+    const raw = new Uint8Array((stride + 1) * height);
+    const candidate = new Uint8Array(stride);
+    for (let y = 0; y < height; y++) {
+        const row = y * stride;
+        let best = 0;
+        let bestSum = Infinity;
+        let bestRow = new Uint8Array(stride);
+        for (let type = 0; type <= 4; type++) {
+            let sum = 0;
+            for (let x = 0; x < stride; x++) {
+                const v = img.data[row + x];
+                const a = x >= channels ? img.data[row + x - channels] : 0;
+                const b = y > 0 ? img.data[row - stride + x] : 0;
+                const c = y > 0 && x >= channels ? img.data[row - stride + x - channels] : 0;
+                const f = type === 0 ? v : type === 1 ? v - a : type === 2 ? v - b : type === 3 ? v - ((a + b) >> 1) : v - paeth(a, b, c);
+                candidate[x] = f & 0xff;
+                sum += Math.abs((f << 24) >> 24);
+            }
+            if (sum < bestSum) {
+                bestSum = sum;
+                best = type;
+                bestRow = candidate.slice();
+            }
+        }
+        raw[y * (stride + 1)] = best;
+        raw.set(bestRow, y * (stride + 1) + 1);
+    }
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(width, 0);
+    ihdr.writeUInt32BE(height, 4);
+    ihdr[8] = 8;
+    ihdr[9] = channels === 1 ? 0 : 2;
+    return new Uint8Array(Buffer.concat([Buffer.from(SIGNATURE), chunk("IHDR", ihdr), chunk("IDAT", zlib.deflateSync(raw, { level: 6 })), chunk("IEND", new Uint8Array(0))]));
+}

package/dist/runners/antigravity.js

@@ -0,0 +1,70 @@
+// Antigravity CLI runner (`agy`, Google's agent CLI after Gemini CLI).
+// Headless: `agy -p "<run strom brief …>" --output-format stream-json` in the
+// tree folder — the agent reads its brief with `strom brief` (how agy takes
+// stdin in print mode is not settled); events are {"event": …} lines, the last one the result
+// with status, response, turns and usage. Its permissions are rules in the
+// user's settings (strom agents install adds `command(strom)` there); under
+// ask and auto a headless run gets nothing else (what would ask is refused, or
+// stalls — strom's time limit ends it); full skips the permissions.
+// Interactive conversations are started by strom chat (agents/launch.ts).
+import { runJsonLines } from "./jsonl.js";
+/** Command-line arguments of a headless run (exported for tests). */
+export function antigravityArgs(opts) {
+    return [
+        "--print",
+        opts.kickoff,
+        "--output-format",
+        "stream-json",
+        ...(opts.permissions === "full" ? ["--dangerously-skip-permissions"] : []),
+        ...(opts.shared ? ["--add-dir", opts.shared] : []),
+        ...(opts.model ? ["--model", opts.model] : []),
+        ...(opts.timeoutMs ? ["--print-timeout", `${Math.round(opts.timeoutMs / 1000)}s`] : []),
+        ...(opts.extraArgs ?? []),
+    ];
+}
+export const antigravityRunner = {
+    id: "antigravity",
+    command: "agy",
+    run(opts) {
+        return runJsonLines("agy", antigravityArgs(opts), opts.env, opts, (msg, heard) => {
+            const kind = String(msg.event ?? msg.type ?? "");
+            if (kind === "result") {
+                const r = (msg.result ?? {});
+                if (r.response)
+                    heard.text = r.response;
+                if (r.status && r.status !== "SUCCESS" && r.status !== "OK") {
+                    heard.isError = true;
+                    if (r.error)
+                        heard.text = r.error;
+                }
+                const u = r.usage ?? {};
+                const m = heard.metrics;
+                if (typeof u.input_tokens === "number")
+                    m.inputTokens = u.input_tokens;
+                if (typeof u.output_tokens === "number")
+                    m.outputTokens = u.output_tokens + (u.thinking_tokens ?? 0);
+                if (typeof u.cache_read_tokens === "number")
+                    m.cacheReadTokens = u.cache_read_tokens;
+                if (typeof r.num_turns === "number")
+                    m.turns = r.num_turns;
+                if (typeof r.duration_seconds === "number")
+                    m.durationMs = r.duration_seconds * 1000;
+                return;
+            }
+            // Other events: a line of progress from whatever names a tool, a command or a text.
+            const body = (msg[kind] ?? msg);
+            const command = body.command ?? body.input?.command ?? body.args?.command;
+            if (typeof command === "string")
+                opts.onProgress?.(`$ ${command.split("\n")[0].slice(0, 140)}`);
+            else if (/tool/i.test(kind) && typeof (body.name ?? body.tool) === "string")
+                opts.onProgress?.(String(body.name ?? body.tool));
+            else if (/message|text|response/i.test(kind) && typeof (body.text ?? body.content) === "string") {
+                const text = String(body.text ?? body.content).trim();
+                if (text)
+                    opts.onProgress?.(text.split("\n")[0].slice(0, 160));
+            }
+            if (/denied|permission/i.test(kind))
+                heard.denied.push(`tool: ${JSON.stringify(body).slice(0, 120)}`);
+        });
+    },
+};