@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/native/render/draw-kernel.js

@@ -0,0 +1,204 @@
+// BitmapData.draw of a bitmap in the normal blend mode, in the render
+// module (draw.zig), one call a draw. Each draw copies into the module's
+// input the rows of the source it reads and the destination's area, and
+// the area back out after: no source is kept between draws, which costs no
+// more than keeping them did for a game drawing hundreds of small bitmaps
+// a frame, and holds nothing for them. Its own instance, so that the
+// filters' calls (BitmapKernel) do not reset its input, let go of when its
+// owner says it went idle, and after a draw that grew it past KEEP_BYTES.
+import { renderInstance } from "./module.js";
+/** draw.zig's flags. */
+export const DRAW_SMOOTH = 1;
+export const DRAW_TRANSFORM = 2;
+export const DRAW_OPAQUE = 4;
+export const DRAW_SKIP_ZERO_ALPHA = 8;
+// draw.zig's results.
+const INVALID = 0;
+const WRITTEN = 2;
+/** draw.zig's DrawParams: 14 doubles, then 14 words. */
+const PARAMS = 168;
+/** The most a draw copies in, its source's rows and its area; a larger one is drawn by the caller. */
+const DRAWN_BYTES = 32 << 20;
+/** The input a new instance takes first. */
+const FIRST_BYTES = 1 << 20;
+/** The memory an instance keeps after a draw; past it, the instance is let go of. */
+const KEEP_BYTES = 16 << 20;
+export class DrawKernel {
+    wasm = null;
+    /** Whether making an instance failed once, after which the module is never tried again. */
+    broken = false;
+    /** The input resetArena gave, and its bytes. */
+    input = 0;
+    inputBytes = 0;
+    buffer = null;
+    words = new Uint32Array(0);
+    doubles = new Float64Array(0);
+    ints = new Int32Array(0);
+    /** Where the last draw's area lies in the input. */
+    area = 0;
+    /** Whether the module drew since `idle` last asked. */
+    busy = false;
+    /** How many draws the module took. */
+    drawn = 0;
+    /** A job to fill for each draw. */
+    static job() {
+        return {
+            source: new Uint32Array(0),
+            sourceWidth: 0,
+            sourceHeight: 0,
+            sourceTop: 0,
+            sourceRows: 0,
+            into: new Uint32Array(0),
+            intoWidth: 0,
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            moved: false,
+            inverse: new Float64Array(6),
+            transform: new Float64Array(8),
+            tx: 0,
+            ty: 0,
+            flags: 0,
+        };
+    }
+    /** Whether an instance is held, with its memory. */
+    get held() {
+        return this.wasm !== null;
+    }
+    /** The job drawn in the module; never a write to the destination, which `writeBack` makes. */
+    draw(job) {
+        try {
+            return this.run(job);
+        }
+        catch {
+            // A trap: never resume that instance.
+            this.release();
+            return "refused";
+        }
+    }
+    /** The area the last draw wrote, copied into `into`. */
+    writeBack(job, into) {
+        const { x, y, width: w, height: h, intoWidth } = job;
+        const base = this.area >> 2;
+        this.refresh();
+        const words = this.words;
+        for (let row = 0; row < h; row++) {
+            const at = base + row * w;
+            into.set(words.subarray(at, at + w), (y + row) * intoWidth + x);
+        }
+    }
+    /** Whether the module drew nothing since this was last asked. */
+    idle() {
+        const idle = !this.busy;
+        this.busy = false;
+        return idle;
+    }
+    /** The instance let go of, and its memory with it; the next draw makes another. */
+    release() {
+        this.wasm = null;
+        this.buffer = null;
+        this.words = new Uint32Array(0);
+        this.doubles = new Float64Array(0);
+        this.ints = new Int32Array(0);
+        this.input = 0;
+        this.inputBytes = 0;
+    }
+    run(job) {
+        const { sourceWidth: sw, sourceRows: rows, width: w, height: h } = job;
+        const sourceBytes = sw * rows * 4;
+        const areaBytes = w * h * 4;
+        if (job.source.length !== sw * job.sourceHeight ||
+            sourceBytes + areaBytes > DRAWN_BYTES ||
+            !this.room(PARAMS + sourceBytes + areaBytes)) {
+            return "refused";
+        }
+        const wasm = this.wasm;
+        this.refresh();
+        const { words, doubles, ints } = this;
+        const p = this.input;
+        const src = p + PARAMS;
+        this.area = src + sourceBytes;
+        const top = job.sourceTop * sw;
+        words.set(job.source.subarray(top, top + rows * sw), src >> 2);
+        const base = this.area >> 2;
+        const { into, intoWidth, x, y } = job;
+        for (let row = 0; row < h; row++) {
+            const at = (y + row) * intoWidth + x;
+            words.set(into.subarray(at, at + w), base + row * w);
+        }
+        const d = p >> 3;
+        doubles.set(job.inverse, d);
+        doubles.set(job.transform, d + 6);
+        const i = (p + 112) >> 2;
+        words[i] = src;
+        words[i + 1] = sw;
+        words[i + 2] = job.sourceHeight;
+        words[i + 3] = this.area;
+        ints[i + 4] = x;
+        ints[i + 5] = y;
+        words[i + 6] = w;
+        words[i + 7] = h;
+        words[i + 8] = job.flags;
+        ints[i + 9] = job.tx;
+        ints[i + 10] = job.ty;
+        words[i + 11] = job.sourceTop;
+        words[i + 12] = rows;
+        words[i + 13] = 0;
+        const result = job.moved ? wasm.compositePixels(p) : wasm.drawPixels(p);
+        if (result === INVALID) {
+            return "refused";
+        }
+        this.drawn++;
+        this.busy = true;
+        return result === WRITTEN ? "written" : "untouched";
+    }
+    /**
+     * Whether the input holds `bytes`: an instance made where there is none,
+     * one grown past KEEP_BYTES made anew, and the input taken anew where it
+     * is smaller.
+     */
+    room(bytes) {
+        if (this.broken) {
+            return false;
+        }
+        // Grown past what it keeps by a large draw before, it goes, and its memory with it.
+        if (this.wasm && this.wasm.memory.buffer.byteLength > KEEP_BYTES) {
+            this.release();
+        }
+        if (this.wasm && this.inputBytes >= bytes) {
+            return true;
+        }
+        if (!this.wasm) {
+            try {
+                this.wasm = renderInstance(() => {
+                    throw new Error("the draw kernel takes no tessellator");
+                });
+            }
+            catch {
+                this.broken = true;
+                return false;
+            }
+        }
+        // Half again what is asked, so that a few larger draws do not each take it anew.
+        const want = Math.max(FIRST_BYTES, bytes + (bytes >> 1));
+        this.input = this.wasm.resetArena(want);
+        if (!this.input) {
+            // Out of memory: the instance goes, and the next draw that fits makes another.
+            this.release();
+            return false;
+        }
+        this.inputBytes = want;
+        return true;
+    }
+    /** The views of the memory made again where it grew, which detached them. */
+    refresh() {
+        const buffer = this.wasm.memory.buffer;
+        if (buffer !== this.buffer) {
+            this.buffer = buffer;
+            this.words = new Uint32Array(buffer);
+            this.doubles = new Float64Array(buffer);
+            this.ints = new Int32Array(buffer);
+        }
+    }
+}

package/dist/thread/native/render/dxt-encoder.js

@@ -0,0 +1,94 @@
+// Compressed texture uploads, one whole level at a time in dxt.zig. The
+// input is kept between levels and grown only as needed; the result is a
+// view to consume before the next call, as context3d's TS encoder gives.
+import { renderInstance } from "./module.js";
+/** Enough to keep a 2048² DXT5 upload's input and output, including growth slack. */
+const KEEP_BYTES = 32 << 20;
+const FIRST_BYTES = 64 << 10;
+export class DxtEncoder {
+    wasm = null;
+    broken = false;
+    input = 0;
+    inputBytes = 0;
+    /** Successful native encodes, so a reference comparison can rule out falling back. */
+    encoded = 0;
+    /** The memory kept now: a larger level's instance goes before the next call. */
+    get capacity() {
+        return this.wasm?.memory.buffer.byteLength ?? 0;
+    }
+    /** Release the instance and its memory; the next level makes another. */
+    release() {
+        this.wasm = null;
+        this.input = 0;
+        this.inputBytes = 0;
+    }
+    /**
+     * Top-down RGBA to DXT1 or DXT5, matching the TS encoder's blocks. The
+     * result stays valid until the next call; null leaves the level to TS.
+     */
+    encode = (rgba, dxt5, width, height) => {
+        if (!Number.isInteger(width) ||
+            !Number.isInteger(height) ||
+            width <= 0 ||
+            height <= 0 ||
+            width > 4096 ||
+            height > 4096 ||
+            rgba.length !== width * height * 4) {
+            return null;
+        }
+        try {
+            // A caller may use an earlier result as a smaller level's input. Preserve it if growth
+            // detaches that view, or a large earlier level causes its instance to be replaced.
+            if (this.wasm && rgba.buffer === this.wasm.memory.buffer) {
+                rgba = rgba.slice();
+            }
+            const length = Math.ceil(width / 4) * Math.ceil(height / 4) * (dxt5 ? 16 : 8);
+            if (!this.room(rgba.length + length)) {
+                return null;
+            }
+            const wasm = this.wasm;
+            const destination = this.input + rgba.length;
+            new Uint8Array(wasm.memory.buffer, this.input, rgba.length).set(rgba);
+            if (!wasm.encodeDxt(this.input, destination, width, height, dxt5 ? 1 : 0)) {
+                return null;
+            }
+            this.encoded++;
+            return new Uint8Array(wasm.memory.buffer, destination, length);
+        }
+        catch {
+            // A trapped instance is never resumed, and a refused module leaves the TS path available.
+            this.release();
+            return null;
+        }
+    };
+    room(bytes) {
+        if (this.broken) {
+            return false;
+        }
+        if (this.wasm && this.wasm.memory.buffer.byteLength > KEEP_BYTES) {
+            this.release();
+        }
+        if (this.wasm && this.inputBytes >= bytes) {
+            return true;
+        }
+        if (!this.wasm) {
+            try {
+                this.wasm = renderInstance(() => {
+                    throw new Error("the DXT encoder takes no tessellator");
+                });
+            }
+            catch {
+                this.broken = true;
+                return false;
+            }
+        }
+        const want = Math.max(FIRST_BYTES, bytes + Math.floor(bytes / 2));
+        this.input = this.wasm.resetArena(want);
+        if (!this.input) {
+            this.release();
+            return false;
+        }
+        this.inputBytes = want;
+        return true;
+    }
+}

package/dist/thread/native/render/index.js

@@ -0,0 +1,10 @@
+// The render module's wrappers, each over an instance of its own: fills
+// (Tessellator), a layer's lines (LineBuilder, also a Tessellator's
+// `tessellate.lines`) and BitmapData's CPU filters and pixel operations
+// (BitmapKernel), BitmapData.draw of a bitmap (DrawKernel), and DXT1/DXT5
+// texture encoding (DxtEncoder).
+export { BitmapKernel, } from "./bitmap-kernel.js";
+export { DRAW_OPAQUE, DRAW_SKIP_ZERO_ALPHA, DRAW_SMOOTH, DRAW_TRANSFORM, DrawKernel, } from "./draw-kernel.js";
+export { DxtEncoder } from "./dxt-encoder.js";
+export { LineBuilder } from "./lines.js";
+export { PATH_CUBIC, PATH_CURVE, PATH_LINE, PATH_MOVE, Tessellator, } from "./tessellator.js";

package/dist/thread/native/render/lines.js

@@ -0,0 +1,122 @@
+import { renderInstance, renderModule } from "./module.js";
+/**
+ * A shape layer's lines built in one call by the render module's
+ * strokes.zig, its outlines filled by the module's libtess2, or its bands
+ * where libtess2 fails: the caller writes the layer into input() as
+ * strokes.zig reads it (the player's scene/strokes.ts) and calls build()
+ * with its length. Its instance is its own, apart from any Tessellator's,
+ * and held to the same limits as a Tessellator's (TessellatorOptions),
+ * which pass them on: where a fill would have run out of memory, so do the
+ * lines, and none are drawn.
+ */
+export class LineBuilder {
+    instance = null;
+    view = new Float64Array(0);
+    layout = new Uint32Array(0);
+    /** libtess2 trapped the last instance: the next fills its outlines by the bands alone. */
+    trapped = false;
+    lastUnwound = false;
+    limit;
+    keep;
+    bands;
+    constructor(options = {}) {
+        this.limit = options.memoryLimit ?? 128 << 20;
+        this.keep = options.retainMemory ?? 8 << 20;
+        this.bands = options.bands ?? false;
+        renderModule();
+    }
+    /** Whether the last build() unwound, which the next, in a new instance by the bands, may not. */
+    get unwound() {
+        return this.lastUnwound;
+    }
+    /** Current retained Wasm capacity. */
+    get capacity() {
+        return this.instance?.memory.buffer.byteLength ?? 0;
+    }
+    /** A view of at least `n` f64s of input, valid until build(); null where no instance could be made. */
+    input(n) {
+        if (!this.instance) {
+            try {
+                this.instance = renderInstance(() => {
+                    throw new Error("line tessellation allocation failed");
+                });
+            }
+            catch {
+                return null;
+            }
+            this.instance.setLimit(this.limit);
+            this.instance.bandsOnly(Number(this.bands || this.trapped));
+        }
+        const x = this.instance;
+        if (n > this.view.length || this.view.buffer !== x.memory.buffer) {
+            const size = Math.max(n, this.view.length * 2, 1024);
+            const at = x.lineInput(size);
+            if (!at) {
+                this.dispose();
+                return null;
+            }
+            this.view = new Float64Array(x.memory.buffer, at, size);
+        }
+        return this.view;
+    }
+    /**
+     * The layer in the input's first `length` f64s, copied out in one
+     * block: null for none, undefined where the module refused it (a
+     * position not a number) or failed. Where libtess2 trapped, the next
+     * instance fills the layer's outlines by the bands alone, for the
+     * caller's next input() and build().
+     */
+    build(length) {
+        this.lastUnwound = false;
+        const x = this.instance;
+        if (!x) {
+            return undefined;
+        }
+        try {
+            const status = x.lineBuild(length);
+            // Built without unwinding: libtess2 again for the next.
+            if (this.trapped) {
+                this.trapped = false;
+                x.bandsOnly(Number(this.bands));
+            }
+            if (status !== 0) {
+                return undefined;
+            }
+            const [at, vertices, count] = this.header(x);
+            if (count === 0) {
+                return null;
+            }
+            const copy = x.memory.buffer.slice(at, at + (vertices * 3 + count) * 4);
+            return {
+                positions: new Float32Array(copy, 0, vertices * 2),
+                colors: new Uint32Array(copy, vertices * 8, vertices),
+                indices: new Uint32Array(copy, vertices * 12, count),
+            };
+        }
+        catch {
+            // libtess2 unwound through the failure import: never resume that instance.
+            this.dispose();
+            this.trapped = true;
+            this.lastUnwound = true;
+            return undefined;
+        }
+        finally {
+            if (this.capacity > this.keep) {
+                this.dispose();
+            }
+        }
+    }
+    /** strokes.zig's layout, read again where memory grew. */
+    header(x) {
+        if (this.layout.buffer !== x.memory.buffer) {
+            this.layout = new Uint32Array(x.memory.buffer, x.lineHeader(), 3);
+        }
+        return this.layout;
+    }
+    /** The instance let go, its memory with it; the next input() makes another. */
+    dispose() {
+        this.instance = null;
+        this.view = new Float64Array(0);
+        this.layout = new Uint32Array(0);
+    }
+}

package/dist/thread/native/render/module.js

@@ -0,0 +1,26 @@
+import { decodeBase64 } from "../base64.js";
+import { binary } from "./binary.js";
+let module = null;
+/**
+ * The render module (root.zig), compiled once and shared: the bitmap
+ * kernels, DXT encoder, tessellator and lines each make an instance of their
+ * own, so that each has its memory and lifecycle apart. It needs wasm
+ * SIMD throughout; this throws where the host refuses to compile it, as
+ * without SIMD or Wasm or under a CSP without 'wasm-unsafe-eval'.
+ */
+export function renderModule() {
+    module ??= new WebAssembly.Module(decodeBase64(binary));
+    return module;
+}
+/**
+ * What an instance imports: libtess2's longjmp, which `failure` must
+ * throw from, and the host's own sine and cosine, which the lines take so
+ * that theirs are the player's JS's to the last bit.
+ */
+function renderImports(failure) {
+    return { env: { failure, sine: Math.sin, cosine: Math.cos } };
+}
+/** An instance of the module, its memory its own. */
+export function renderInstance(failure) {
+    return new WebAssembly.Instance(renderModule(), renderImports(failure)).exports;
+}

package/dist/thread/native/render/pixel-ops.js

@@ -0,0 +1,235 @@
+// BitmapData's pixel operations in the render module (pixels.zig), over a
+// store's pixels a band of rows at a time, so that the scratch stays near
+// BAND_BYTES whatever the bitmap's size. Each band is copied in, worked on
+// and copied back before the next, which reads what the bands before it
+// wrote, as the one loop over the rows did: where the source is the
+// destination and a band's rows of the two overlap, they are copied in as
+// one block, so that a pixel reads what the pixels before it wrote.
+// A band that traps is copied back never, and `Progress` lets the call made
+// again in a new instance (BitmapKernel) take up at that band.
+/** The rows of a band's work: about this much of the pixels it copies in. */
+const BAND_BYTES = 1 << 20;
+/** The params' room at the input's start, before tables and blocks. */
+const HEAD = 256;
+/** paletteMap's four tables of 256 entries, after the params. */
+const TABLES = 4096;
+/**
+ * `region` of `into` (`intoWidth` wide) made by the copy `op` of the rows of
+ * `from` (`fromWidth` wide) starting at (sx, sy), band by band; false where
+ * the module refused a band.
+ */
+export function copyRows(wasm, into, intoWidth, from, fromWidth, region, sx, sy, transparent, op, progress) {
+    const { x: dx, y: dy, width: w, height: h } = region;
+    const same = into === from;
+    // A band's blocks: where the source is the destination, both in one block as wide as their union.
+    const wide = same ? w + Math.abs(sx - dx) : w;
+    const band = Math.max(1, Math.floor(BAND_BYTES / (wide * 8)));
+    for (; progress.row < h; progress.row += band) {
+        const r0 = progress.row;
+        const rows = Math.min(band, h - r0);
+        const dy0 = dy + r0;
+        const sy0 = sy + r0;
+        const joined = same && dy0 < sy0 + rows && sy0 < dy0 + rows;
+        const ux = joined ? Math.min(dx, sx) : 0;
+        const uy = joined ? Math.min(dy0, sy0) : 0;
+        const uw = joined ? Math.max(dx, sx) + w - ux : w;
+        const uh = joined ? Math.max(dy0, sy0) + rows - uy : rows;
+        const blocks = joined ? uw * uh : 2 * rows * w;
+        const at = wasm.resetArena(HEAD + TABLES + blocks * 4);
+        if (!at) {
+            return false;
+        }
+        const memory = new Uint32Array(wasm.memory.buffer);
+        const base = (at + HEAD + TABLES) >> 2;
+        let dst;
+        let src;
+        let stride;
+        if (joined) {
+            for (let row = 0; row < uh; row++) {
+                const start = (uy + row) * intoWidth + ux;
+                memory.set(into.subarray(start, start + uw), base + row * uw);
+            }
+            dst = base + (dy0 - uy) * uw + (dx - ux);
+            src = base + (sy0 - uy) * uw + (sx - ux);
+            stride = uw;
+        }
+        else {
+            dst = base;
+            src = base + rows * w;
+            stride = w;
+            // paletteMap's and a colour matrix's pixels are the source's alone: the destination's are not read.
+            const reads = op.op === "channel" || op.op === "merge";
+            for (let row = 0; row < rows; row++) {
+                if (reads) {
+                    const to = (dy0 + row) * intoWidth + dx;
+                    memory.set(into.subarray(to, to + w), dst + row * w);
+                }
+                const fromAt = (sy0 + row) * fromWidth + sx;
+                memory.set(from.subarray(fromAt, fromAt + w), src + row * w);
+            }
+        }
+        const params = new DataView(wasm.memory.buffer, at, HEAD);
+        const words = [w, rows, dst * 4, stride, src * 4, stride, Number(transparent), 0];
+        for (let k = 0; k < 8; k++) {
+            params.setUint32(k * 4, words[k], true);
+        }
+        let ok = 0;
+        switch (op.op) {
+            case "channel":
+                params.setInt32(32, op.from, true);
+                params.setUint32(36, op.to, true);
+                ok = wasm.channelPixels(at);
+                break;
+            case "merge":
+                for (let k = 0; k < 4; k++) {
+                    params.setUint32(32 + k * 4, op.muls[k] >>> 0, true);
+                }
+                ok = wasm.mergePixels(at);
+                break;
+            case "palette": {
+                params.setUint32(32, at + HEAD, true);
+                params.setUint32(36, 0, true);
+                const tables = new Uint32Array(wasm.memory.buffer, at + HEAD, 1024);
+                for (let k = 0; k < 4; k++) {
+                    tables.set(op.tables[k], k * 256);
+                }
+                ok = wasm.palettePixels(at);
+                break;
+            }
+            case "matrix": {
+                const near = op.near;
+                params.setInt32(32, sx, true);
+                params.setInt32(36, sy0, true);
+                params.setInt32(40, near?.x ?? 0, true);
+                params.setInt32(44, near?.y ?? 0, true);
+                params.setUint32(48, near?.width ?? 0, true);
+                params.setUint32(52, near?.height ?? 0, true);
+                params.setUint32(56, op.empty >>> 0, true);
+                params.setUint32(60, 0, true);
+                for (let k = 0; k < 20; k++) {
+                    params.setFloat64(64 + k * 8, op.matrix[k], true);
+                }
+                ok = wasm.matrixPixels(at);
+                break;
+            }
+        }
+        if (!ok) {
+            return false;
+        }
+        // Read again: the call may have grown the memory.
+        const out = new Uint32Array(wasm.memory.buffer);
+        for (let row = 0; row < rows; row++) {
+            const to = (dy0 + row) * intoWidth + dx;
+            into.set(out.subarray(dst + row * stride, dst + row * stride + w), to);
+        }
+    }
+    return true;
+}
+/**
+ * colorTransform over `region` of `pixels` (`width` wide), in place, band by
+ * band: each channel's multiplier in 256ths and offset, red, green, blue,
+ * alpha; false where the module refused a band.
+ */
+export function transformRows(wasm, pixels, width, region, muls, adds, progress) {
+    const { x, y, width: w, height: h } = region;
+    const band = Math.max(1, Math.floor(BAND_BYTES / (w * 4)));
+    for (; progress.row < h; progress.row += band) {
+        const rows = Math.min(band, h - progress.row);
+        const at = wasm.resetArena(HEAD + rows * w * 4);
+        if (!at) {
+            return false;
+        }
+        const block = (at + HEAD) >> 2;
+        const memory = new Uint32Array(wasm.memory.buffer);
+        for (let row = 0; row < rows; row++) {
+            const from = (y + progress.row + row) * width + x;
+            memory.set(pixels.subarray(from, from + w), block + row * w);
+        }
+        const params = new DataView(wasm.memory.buffer, at, HEAD);
+        const words = [w, rows, block * 4, w];
+        for (let k = 0; k < words.length; k++) {
+            params.setUint32(k * 4, words[k], true);
+        }
+        for (let k = 0; k < 4; k++) {
+            params.setFloat64(16 + k * 8, muls[k], true);
+            params.setFloat64(48 + k * 8, adds[k], true);
+        }
+        if (!wasm.transformPixels(at)) {
+            return false;
+        }
+        const out = new Uint32Array(wasm.memory.buffer);
+        for (let row = 0; row < rows; row++) {
+            const to = (y + progress.row + row) * width + x;
+            pixels.set(out.subarray(block + row * w, block + (row + 1) * w), to);
+        }
+    }
+    return true;
+}
+/**
+ * noise over every pixel, `count` a band: Park-Miller's generator from
+ * `progress.state`, which it moves on; false where the module refused a band.
+ */
+export function noiseRows(wasm, pixels, lo, span, channels, gray, transparent, progress) {
+    const band = BAND_BYTES >> 2;
+    for (; progress.row < pixels.length; progress.row += band) {
+        const count = Math.min(band, pixels.length - progress.row);
+        const at = wasm.resetArena(HEAD + count * 4);
+        if (!at) {
+            return false;
+        }
+        const params = new DataView(wasm.memory.buffer, at, HEAD);
+        const words = [count, at + HEAD, progress.state, lo, span, channels, Number(gray)];
+        words.push(Number(transparent));
+        for (let k = 0; k < words.length; k++) {
+            params.setUint32(k * 4, words[k] >>> 0, true);
+        }
+        const state = wasm.noisePixels(at);
+        if (!state) {
+            return false;
+        }
+        pixels.set(new Uint32Array(wasm.memory.buffer, at + HEAD, count), progress.row);
+        progress.state = state;
+    }
+    return true;
+}
+/** perlinNoise over every pixel of a `width`-wide store, band by band; false where the module refused one. */
+export function perlinRows(wasm, pixels, width, setup, progress) {
+    const height = pixels.length / width;
+    const octaves = setup.offsets.length;
+    const band = Math.max(1, Math.floor(BAND_BYTES / (width * 4)));
+    // The tables once, and a band's block, which each band uses again.
+    const at = wasm.resetArena(HEAD + 2056 + 8 + 32896 + octaves * 16 + band * width * 4);
+    if (!at) {
+        return false;
+    }
+    const lattice = at + HEAD;
+    const gradients = lattice + 2056 + 8 - ((lattice + 2056) & 7);
+    const offsets = gradients + 32896;
+    const block = offsets + octaves * 16;
+    new Int32Array(wasm.memory.buffer, lattice, 514).set(setup.lattice);
+    new Float64Array(wasm.memory.buffer, gradients, 4112).set(setup.gradients);
+    const list = new Float64Array(wasm.memory.buffer, offsets, octaves * 2);
+    for (let k = 0; k < octaves; k++) {
+        list[k * 2] = setup.offsets[k][0];
+        list[k * 2 + 1] = setup.offsets[k][1];
+    }
+    for (; progress.row < height; progress.row += band) {
+        const rows = Math.min(band, height - progress.row);
+        const params = new DataView(wasm.memory.buffer, at, HEAD);
+        const words = [width, rows, progress.row, block, lattice, gradients, offsets, octaves];
+        words.push(setup.channels, Number(setup.gray), Number(setup.fractal), Number(setup.stitch));
+        words.push(Number(setup.transparent), 0);
+        for (let k = 0; k < words.length; k++) {
+            params.setUint32(k * 4, words[k] >>> 0, true);
+        }
+        params.setFloat64(56, setup.fx, true);
+        params.setFloat64(64, setup.fy, true);
+        params.setFloat64(72, setup.stitchWidth, true);
+        params.setFloat64(80, setup.stitchHeight, true);
+        if (!wasm.perlinPixels(at)) {
+            return false;
+        }
+        pixels.set(new Uint32Array(wasm.memory.buffer, block, rows * width), progress.row * width);
+    }
+    return true;
+}