@flighthq/surface 0.1.0

package/src/surfaceMorphological.test.ts

@@ -0,0 +1,75 @@
+import { createSurface } from './surface';
+import { dilateSurface, erodeSurface } from './surfaceMorphological';
+
+function region(
+  surface: ReturnType<typeof createSurface>,
+  x = 0,
+  y = 0,
+  width = surface.width,
+  height = surface.height,
+) {
+  return { surface, x, y, width, height };
+}
+
+describe('dilateSurface', () => {
+  it('expands a single bright pixel into its neighborhood', () => {
+    const source = createSurface(3, 1);
+    source.data[1 * 4 + 3] = 255; // center pixel fully opaque
+    const out = new Uint8ClampedArray(3 * 4);
+    dilateSurface(out, region(source), 1);
+    expect(out[0 * 4 + 3]).toBe(255);
+    expect(out[1 * 4 + 3]).toBe(255);
+    expect(out[2 * 4 + 3]).toBe(255);
+  });
+
+  it('with radius 0 is an identity copy', () => {
+    const source = createSurface(3, 1);
+    source.data.set([10, 20, 30, 100], 0);
+    source.data.set([50, 60, 70, 200], 4);
+    const out = new Uint8ClampedArray(3 * 4);
+    dilateSurface(out, region(source), 0);
+    expect(out[0]).toBe(10);
+    expect(out[4]).toBe(50);
+  });
+
+  it('is dual to erodeSurface (dilate after erode has no-smaller effect)', () => {
+    const source = createSurface(5, 1);
+    for (let i = 1; i < 4; i++) source.data[i * 4 + 3] = 255; // pixels 1-3 opaque
+    const eroded = new Uint8ClampedArray(5 * 4);
+    const dilated = new Uint8ClampedArray(5 * 4);
+    erodeSurface(eroded, region(source), 1);
+    dilateSurface(dilated, region(source), 1);
+    // Dilation always >= source, erosion always <= source for alpha
+    expect(dilated[1 * 4 + 3]).toBeGreaterThanOrEqual(source.data[1 * 4 + 3]);
+    expect(eroded[1 * 4 + 3]).toBeLessThanOrEqual(source.data[1 * 4 + 3]);
+  });
+});
+
+describe('erodeSurface', () => {
+  it('shrinks an isolated bright pixel to dark when radius covers neighbors', () => {
+    const source = createSurface(3, 1);
+    source.data[1 * 4 + 3] = 255; // only center opaque
+    const out = new Uint8ClampedArray(3 * 4);
+    erodeSurface(out, region(source), 1);
+    // Center eroded to 0 because transparent neighbors dominate the min
+    expect(out[1 * 4 + 3]).toBe(0);
+  });
+
+  it('with radius 0 is an identity copy', () => {
+    const source = createSurface(3, 1);
+    source.data.set([10, 20, 30, 100], 4);
+    const out = new Uint8ClampedArray(3 * 4);
+    erodeSurface(out, region(source), 0);
+    expect(out[4]).toBe(10);
+    expect(out[7]).toBe(100);
+  });
+
+  it('preserves a fully opaque field', () => {
+    const source = createSurface(5, 1, 0xffffffff);
+    const out = new Uint8ClampedArray(5 * 4);
+    erodeSurface(out, region(source), 2);
+    for (let i = 0; i < 5; i++) {
+      expect(out[i * 4 + 3]).toBe(255);
+    }
+  });
+});

package/src/surfaceNoise.test.ts

@@ -0,0 +1,169 @@
+import { createSurface } from './surface';
+import {
+  fillSurfaceNoise,
+  fillSurfacePerlinNoise,
+  fillSurfaceTurbulence,
+  SURFACE_NOISE_CHANNEL_A,
+  SURFACE_NOISE_CHANNEL_R,
+} from './surfaceNoise';
+
+function region(
+  surface: ReturnType<typeof createSurface>,
+  x = 0,
+  y = 0,
+  width = surface.width,
+  height = surface.height,
+) {
+  return { surface, x, y, width, height };
+}
+
+describe('fillSurfaceNoise', () => {
+  it('is deterministic for the same seed', () => {
+    const a = createSurface(4, 4);
+    const b = createSurface(4, 4);
+    fillSurfaceNoise(region(a), 12345);
+    fillSurfaceNoise(region(b), 12345);
+    expect(Array.from(a.data)).toEqual(Array.from(b.data));
+  });
+
+  it('produces different output for different seeds', () => {
+    const a = createSurface(8, 8);
+    const b = createSurface(8, 8);
+    fillSurfaceNoise(region(a), 1);
+    fillSurfaceNoise(region(b), 2);
+    expect(Array.from(a.data)).not.toEqual(Array.from(b.data));
+  });
+
+  it('grayscale gives every pixel equal R, G, B', () => {
+    const surface = createSurface(4, 4);
+    fillSurfaceNoise(region(surface), 99, 0, 255, true);
+    for (let i = 0; i < surface.data.length; i += 4) {
+      expect(surface.data[i]).toBe(surface.data[i + 1]);
+      expect(surface.data[i + 1]).toBe(surface.data[i + 2]);
+    }
+  });
+
+  it('respects the low/high range and sets alpha opaque', () => {
+    const surface = createSurface(8, 8);
+    fillSurfaceNoise(region(surface), 7, 100, 110);
+    for (let i = 0; i < surface.data.length; i += 4) {
+      expect(surface.data[i]).toBeGreaterThanOrEqual(100);
+      expect(surface.data[i]).toBeLessThanOrEqual(110);
+      expect(surface.data[i + 3]).toBe(255);
+    }
+  });
+
+  it('fills only the given sub-region', () => {
+    const surface = createSurface(2, 1, 0x000000ff);
+    fillSurfaceNoise(region(surface, 1, 0, 1, 1), 5, 200, 255);
+    expect(surface.data[0]).toBe(0); // left pixel untouched
+    expect(surface.data[4]).toBeGreaterThanOrEqual(200);
+  });
+});
+
+describe('fillSurfacePerlinNoise', () => {
+  it('is deterministic for the same seed', () => {
+    const a = createSurface(8, 8);
+    const b = createSurface(8, 8);
+    fillSurfacePerlinNoise(region(a), 16, 16, 3, 42);
+    fillSurfacePerlinNoise(region(b), 16, 16, 3, 42);
+    expect(Array.from(a.data)).toEqual(Array.from(b.data));
+  });
+
+  it('keeps values in range and alpha opaque', () => {
+    const surface = createSurface(8, 8);
+    fillSurfacePerlinNoise(region(surface), 8, 8, 2, 5);
+    for (let i = 0; i < surface.data.length; i += 4) {
+      expect(surface.data[i]).toBeGreaterThanOrEqual(0);
+      expect(surface.data[i]).toBeLessThanOrEqual(255);
+      expect(surface.data[i + 3]).toBe(255);
+    }
+  });
+
+  it('grayscale gives every pixel equal R, G, B', () => {
+    const surface = createSurface(8, 8);
+    fillSurfacePerlinNoise(region(surface), 8, 8, 2, 5, true);
+    for (let i = 0; i < surface.data.length; i += 4) {
+      expect(surface.data[i]).toBe(surface.data[i + 1]);
+      expect(surface.data[i + 1]).toBe(surface.data[i + 2]);
+    }
+  });
+
+  it('produces smooth low-frequency fields (neighbors stay close)', () => {
+    const surface = createSurface(16, 1);
+    fillSurfacePerlinNoise(region(surface), 32, 32, 1, 3, true);
+    let maxStep = 0;
+    for (let x = 1; x < 16; x++) {
+      maxStep = Math.max(maxStep, Math.abs(surface.data[x * 4] - surface.data[(x - 1) * 4]));
+    }
+    expect(maxStep).toBeLessThan(64);
+  });
+
+  it('fills selected channels only and leaves alpha opaque by default', () => {
+    const surface = createSurface(8, 8, 0x000000ff);
+    fillSurfacePerlinNoise(region(surface), 8, 8, 2, 5, false, false, SURFACE_NOISE_CHANNEL_R);
+    for (let i = 0; i < surface.data.length; i += 4) {
+      // G and B were not selected, so they stay at their initial 0.
+      expect(surface.data[i + 1]).toBe(0);
+      expect(surface.data[i + 2]).toBe(0);
+      // Alpha not selected -> forced opaque.
+      expect(surface.data[i + 3]).toBe(255);
+    }
+  });
+});
+
+describe('fillSurfaceTurbulence', () => {
+  it('is deterministic for the same seed', () => {
+    const a = createSurface(8, 8);
+    const b = createSurface(8, 8);
+    fillSurfaceTurbulence(region(a), 16, 16, 3, 42);
+    fillSurfaceTurbulence(region(b), 16, 16, 3, 42);
+    expect(Array.from(a.data)).toEqual(Array.from(b.data));
+  });
+
+  it('keeps values in range and alpha opaque', () => {
+    const surface = createSurface(8, 8);
+    fillSurfaceTurbulence(region(surface), 8, 8, 2, 5);
+    for (let i = 0; i < surface.data.length; i += 4) {
+      expect(surface.data[i]).toBeGreaterThanOrEqual(0);
+      expect(surface.data[i]).toBeLessThanOrEqual(255);
+      expect(surface.data[i + 3]).toBe(255);
+    }
+  });
+
+  it('grayscale gives every pixel equal R, G, B', () => {
+    const surface = createSurface(8, 8);
+    fillSurfaceTurbulence(region(surface), 8, 8, 2, 5, true);
+    for (let i = 0; i < surface.data.length; i += 4) {
+      expect(surface.data[i]).toBe(surface.data[i + 1]);
+      expect(surface.data[i + 1]).toBe(surface.data[i + 2]);
+    }
+  });
+
+  it('writes noise into alpha when the A channel is selected', () => {
+    const surface = createSurface(8, 8, 0x000000ff);
+    fillSurfaceTurbulence(region(surface), 4, 4, 3, 9, false, false, SURFACE_NOISE_CHANNEL_A);
+    let sawNonOpaque = false;
+    for (let i = 0; i < surface.data.length; i += 4) {
+      if (surface.data[i + 3] !== 255) sawNonOpaque = true;
+    }
+    expect(sawNonOpaque).toBe(true);
+  });
+
+  it('differs from the smooth fractal sum for the same parameters', () => {
+    const turbulent = createSurface(8, 8);
+    const fractal = createSurface(8, 8);
+    fillSurfaceTurbulence(region(turbulent), 8, 8, 3, 7, true);
+    fillSurfacePerlinNoise(region(fractal), 8, 8, 3, 7, true);
+    expect(Array.from(turbulent.data)).not.toEqual(Array.from(fractal.data));
+  });
+
+  it('fills only the given sub-region', () => {
+    const surface = createSurface(2, 1, 0x010203ff);
+    fillSurfaceTurbulence(region(surface, 1, 0, 1, 1), 8, 8, 2, 3);
+    // Left pixel untouched.
+    expect(surface.data[0]).toBe(1);
+    expect(surface.data[1]).toBe(2);
+    expect(surface.data[2]).toBe(3);
+  });
+});

package/src/surfacePaletteMap.test.ts

@@ -0,0 +1,55 @@
+import { createSurface } from './surface';
+import { applySurfacePaletteMap } from './surfacePaletteMap';
+
+function region(
+  surface: ReturnType<typeof createSurface>,
+  x = 0,
+  y = 0,
+  width = surface.width,
+  height = surface.height,
+) {
+  return { surface, x, y, width, height };
+}
+
+function invertTable(): number[] {
+  const table = new Array<number>(256);
+  for (let i = 0; i < 256; i++) table[i] = 255 - i;
+  return table;
+}
+
+describe('applySurfacePaletteMap', () => {
+  it('remaps a channel through its lookup table', () => {
+    const source = createSurface(1, 1, 0x10203040);
+    const out = createSurface(1, 1);
+    applySurfacePaletteMap(region(out), region(source), invertTable(), null, null, null);
+    expect(out.data[0]).toBe(255 - 0x10);
+    expect(out.data[1]).toBe(0x20);
+    expect(out.data[2]).toBe(0x30);
+    expect(out.data[3]).toBe(0x40);
+  });
+
+  it('null maps leave every channel unchanged', () => {
+    const source = createSurface(1, 1, 0x11223344);
+    const out = createSurface(1, 1);
+    applySurfacePaletteMap(region(out), region(source), null, null, null, null);
+    expect(out.data[0]).toBe(0x11);
+    expect(out.data[3]).toBe(0x44);
+  });
+
+  it('is safe in place', () => {
+    const img = createSurface(1, 1, 0x00ff00ff);
+    applySurfacePaletteMap(region(img), region(img), invertTable(), invertTable(), invertTable(), null);
+    expect(img.data[0]).toBe(255);
+    expect(img.data[1]).toBe(0);
+    expect(img.data[2]).toBe(255);
+    expect(img.data[3]).toBe(0xff);
+  });
+
+  it('maps only the given sub-region', () => {
+    const source = createSurface(2, 1, 0x80808080);
+    const out = createSurface(2, 1);
+    applySurfacePaletteMap(region(out, 1, 0, 1, 1), region(source, 1, 0, 1, 1), invertTable(), null, null, null);
+    expect(out.data[4]).toBe(255 - 0x80);
+    expect(out.data[0]).toBe(0); // untouched left pixel
+  });
+});

package/src/surfacePixel.test.ts

@@ -0,0 +1,99 @@
+import { createSurface } from './surface';
+import { ImageChannel } from './surfaceImageChannel';
+import {
+  getSurfacePixel,
+  getSurfacePixelChannel,
+  getSurfacePixelLuminance,
+  getSurfacePixelRgb,
+  setSurfacePixel,
+  setSurfacePixelRgb,
+} from './surfacePixel';
+
+describe('getSurfacePixel', () => {
+  it('reads back a full 0xRRGGBBAA value written by setSurfacePixel', () => {
+    const img = createSurface(2, 2);
+    setSurfacePixel(img, 0, 0, 0xaabbcc80);
+    expect(getSurfacePixel(img, 0, 0)).toBe(0xaabbcc80);
+  });
+
+  it('round-trips an RGBA value', () => {
+    const img = createSurface(4, 4);
+    setSurfacePixel(img, 1, 2, 0x11223380);
+    expect(getSurfacePixel(img, 1, 2)).toBe(0x11223380);
+  });
+
+  it('stores alpha in the fourth byte', () => {
+    const img = createSurface(2, 2);
+    setSurfacePixel(img, 0, 0, 0x112233de);
+    expect(img.data[3]).toBe(0xde);
+  });
+});
+
+describe('getSurfacePixelChannel', () => {
+  it('reads a single channel by index', () => {
+    const img = createSurface(2, 2);
+    setSurfacePixel(img, 0, 0, 0xaabbccdd);
+    expect(getSurfacePixelChannel(img, 0, 0, ImageChannel.Red)).toBe(0xaa);
+    expect(getSurfacePixelChannel(img, 0, 0, ImageChannel.Green)).toBe(0xbb);
+    expect(getSurfacePixelChannel(img, 0, 0, ImageChannel.Blue)).toBe(0xcc);
+    expect(getSurfacePixelChannel(img, 0, 0, ImageChannel.Alpha)).toBe(0xdd);
+  });
+});
+
+describe('getSurfacePixelLuminance', () => {
+  it('returns 0 for black', () => {
+    const img = createSurface(1, 1, 0x000000ff);
+    expect(getSurfacePixelLuminance(img, 0, 0)).toBe(0);
+  });
+
+  it('returns 255 for white', () => {
+    const img = createSurface(1, 1, 0xffffffff);
+    expect(getSurfacePixelLuminance(img, 0, 0)).toBe(255);
+  });
+
+  it('uses W3C luma weighting (green is heaviest)', () => {
+    const red = createSurface(1, 1, 0xff0000ff);
+    const green = createSurface(1, 1, 0x00ff00ff);
+    const blue = createSurface(1, 1, 0x0000ffff);
+    expect(getSurfacePixelLuminance(green, 0, 0)).toBeGreaterThan(getSurfacePixelLuminance(red, 0, 0));
+    expect(getSurfacePixelLuminance(red, 0, 0)).toBeGreaterThan(getSurfacePixelLuminance(blue, 0, 0));
+  });
+});
+
+describe('getSurfacePixelRgb', () => {
+  it('reads back a 0xRRGGBB value without alpha', () => {
+    const img = createSurface(2, 2);
+    setSurfacePixelRgb(img, 0, 0, 0xaabbcc);
+    expect(getSurfacePixelRgb(img, 0, 0)).toBe(0xaabbcc);
+  });
+
+  it('round-trips an RGB value', () => {
+    const img = createSurface(4, 4);
+    setSurfacePixelRgb(img, 1, 2, 0x112233);
+    expect(getSurfacePixelRgb(img, 1, 2)).toBe(0x112233);
+  });
+});
+
+describe('setSurfacePixel', () => {
+  it('writes all four RGBA channels', () => {
+    const img = createSurface(2, 2);
+    setSurfacePixel(img, 1, 0, 0xadbeefde);
+    expect(getSurfacePixel(img, 1, 0)).toBe(0xadbeefde);
+  });
+
+  it('bumps the surface version (self-invalidation)', () => {
+    const img = createSurface(2, 2);
+    const before = img.version;
+    setSurfacePixel(img, 1, 0, 0xadbeefde);
+    expect(img.version).toBe(before + 1);
+  });
+});
+
+describe('setSurfacePixelRgb', () => {
+  it('writes RGB channels without touching alpha', () => {
+    const img = createSurface(2, 2, 0x000000ff);
+    setSurfacePixelRgb(img, 0, 0, 0x112233);
+    expect(img.data[3]).toBe(0xff);
+    expect(getSurfacePixelRgb(img, 0, 0)).toBe(0x112233);
+  });
+});

package/src/surfacePixelate.test.ts

@@ -0,0 +1,46 @@
+import { createSurface } from './surface';
+import { pixelateSurface } from './surfacePixelate';
+
+function region(
+  surface: ReturnType<typeof createSurface>,
+  x = 0,
+  y = 0,
+  width = surface.width,
+  height = surface.height,
+) {
+  return { surface, x, y, width, height };
+}
+
+describe('pixelateSurface', () => {
+  it('averages a block to a single uniform color', () => {
+    // 2x1 row: R=0 and R=100; a block of 2 averages both to 50.
+    const source = createSurface(2, 1);
+    source.data[0] = 0;
+    source.data[4] = 100;
+    source.data[3] = 255;
+    source.data[7] = 255;
+    const out = new Uint8ClampedArray(2 * 4);
+    pixelateSurface(out, region(source), 2);
+    expect(out[0]).toBe(50);
+    expect(out[4]).toBe(50);
+  });
+
+  it('keeps each block independent', () => {
+    const source = createSurface(2, 1);
+    source.data[0] = 10;
+    source.data[4] = 200;
+    const out = new Uint8ClampedArray(2 * 4);
+    pixelateSurface(out, region(source), 1);
+    expect(out[0]).toBe(10);
+    expect(out[4]).toBe(200);
+  });
+
+  it('can use source.surface.data as out for a full-surface region', () => {
+    const surface = createSurface(2, 1);
+    surface.data[0] = 0;
+    surface.data[4] = 80;
+    pixelateSurface(surface.data, region(surface), 2);
+    expect(surface.data[0]).toBe(40);
+    expect(surface.data[4]).toBe(40);
+  });
+});

package/src/surfaceQuery.test.ts

@@ -0,0 +1,48 @@
+import { createSurface } from './surface';
+import { fillSurfaceRectangle } from './surfaceFill';
+import { getSurfaceColorBoundsRectangle } from './surfaceQuery';
+
+function region(
+  surface: ReturnType<typeof createSurface>,
+  x = 0,
+  y = 0,
+  width = surface.width,
+  height = surface.height,
+) {
+  return { surface, x, y, width, height };
+}
+
+describe('getSurfaceColorBoundsRectangle', () => {
+  it('returns null when no pixels match', () => {
+    const img = createSurface(4, 4);
+    expect(getSurfaceColorBoundsRectangle(region(img), 0xffffffff, 0xffffffff)).toBeNull();
+  });
+
+  it('finds the bounding rect of matching pixels', () => {
+    const img = createSurface(8, 8);
+    fillSurfaceRectangle(region(img, 2, 3, 3, 2), 0xff0000ff);
+    const rect = getSurfaceColorBoundsRectangle(region(img), 0xffffffff, 0xff0000ff);
+    expect(rect).toEqual({ x: 2, y: 3, width: 3, height: 2 });
+  });
+
+  it('finds non-matching pixels when findColor is false', () => {
+    const img = createSurface(4, 4, 0xffffffff);
+    fillSurfaceRectangle(region(img, 1, 1, 2, 2), 0x000000ff);
+    const rect = getSurfaceColorBoundsRectangle(region(img), 0xffffffff, 0xffffffff, false);
+    expect(rect).toEqual({ x: 1, y: 1, width: 2, height: 2 });
+  });
+
+  it('respects the mask', () => {
+    const img = createSurface(2, 2);
+    fillSurfaceRectangle(region(img), 0x112233ff);
+    const rect = getSurfaceColorBoundsRectangle(region(img), 0xff0000ff, 0x110000ff);
+    expect(rect).not.toBeNull();
+  });
+
+  it('reports surface-absolute coordinates when scanning a sub-region', () => {
+    const img = createSurface(8, 8);
+    fillSurfaceRectangle(region(img, 5, 5, 2, 2), 0xff0000ff);
+    const rect = getSurfaceColorBoundsRectangle(region(img, 4, 4, 4, 4), 0xffffffff, 0xff0000ff);
+    expect(rect).toEqual({ x: 5, y: 5, width: 2, height: 2 });
+  });
+});

package/src/surfaceRegion.test.ts

@@ -0,0 +1,34 @@
+import { createSurface } from './surface';
+import { createSurfaceRegion, setSurfaceRegion } from './surfaceRegion';
+
+describe('createSurfaceRegion', () => {
+  it('covers the whole surface when no bounds are given', () => {
+    const surface = createSurface(7, 5);
+    const r = createSurfaceRegion(surface);
+    expect(r).toEqual({ surface, x: 0, y: 0, width: 7, height: 5 });
+  });
+
+  it('uses the supplied bounds', () => {
+    const surface = createSurface(8, 8);
+    const r = createSurfaceRegion(surface, 1, 2, 3, 4);
+    expect(r).toEqual({ surface, x: 1, y: 2, width: 3, height: 4 });
+  });
+});
+
+describe('setSurfaceRegion', () => {
+  it('mutates the existing region without allocating a new object', () => {
+    const surface = createSurface(8, 8);
+    const r = createSurfaceRegion(surface);
+    const returned = setSurfaceRegion(r, surface, 2, 3, 4, 5);
+    expect(returned).toBe(r);
+    expect(r).toEqual({ surface, x: 2, y: 3, width: 4, height: 5 });
+  });
+
+  it('covers the whole surface when no bounds are given', () => {
+    const a = createSurface(2, 2);
+    const b = createSurface(6, 9);
+    const r = createSurfaceRegion(a);
+    setSurfaceRegion(r, b);
+    expect(r).toEqual({ surface: b, x: 0, y: 0, width: 6, height: 9 });
+  });
+});

package/src/surfaceResize.test.ts

@@ -0,0 +1,112 @@
+import { createSurface } from './surface';
+import { getSurfacePixel } from './surfacePixel';
+import { resizeSurface } from './surfaceResize';
+
+function region(
+  surface: ReturnType<typeof createSurface>,
+  x = 0,
+  y = 0,
+  width = surface.width,
+  height = surface.height,
+) {
+  return { surface, x, y, width, height };
+}
+
+describe('resizeSurface', () => {
+  it('nearest upscales by pixel duplication', () => {
+    const source = createSurface(2, 1);
+    source.data.set([10, 20, 30, 255], 0);
+    source.data.set([40, 50, 60, 255], 4);
+    const out = createSurface(4, 1);
+    resizeSurface(region(out), region(source), 'nearest');
+    expect(getSurfacePixel(out, 0, 0)).toBe(getSurfacePixel(source, 0, 0));
+    expect(getSurfacePixel(out, 1, 0)).toBe(getSurfacePixel(source, 0, 0));
+    expect(getSurfacePixel(out, 2, 0)).toBe(getSurfacePixel(source, 1, 0));
+    expect(getSurfacePixel(out, 3, 0)).toBe(getSurfacePixel(source, 1, 0));
+  });
+
+  it('bilinear interpolates between source pixels', () => {
+    const source = createSurface(2, 1);
+    source.data.set([0, 0, 0, 255], 0);
+    source.data.set([100, 100, 100, 255], 4);
+    const out = createSurface(4, 1);
+    resizeSurface(region(out), region(source), 'bilinear');
+    expect(out.data[0]).toBe(0);
+    expect(out.data[4]).toBeGreaterThanOrEqual(out.data[0]);
+    expect(out.data[8]).toBeGreaterThan(out.data[4]);
+    expect(out.data[12]).toBe(100);
+  });
+
+  it('bicubic produces a smoother interpolation than bilinear', () => {
+    const source = createSurface(2, 1);
+    source.data.set([0, 0, 0, 255], 0);
+    source.data.set([200, 200, 200, 255], 4);
+    const out = createSurface(4, 1);
+    resizeSurface(region(out), region(source), 'bicubic');
+    // Bicubic should produce a monotonically increasing sequence
+    expect(out.data[4]).toBeGreaterThanOrEqual(out.data[0]);
+    expect(out.data[8]).toBeGreaterThanOrEqual(out.data[4]);
+    expect(out.data[12]).toBeGreaterThanOrEqual(out.data[8]);
+  });
+
+  it('premultiplied option prevents dark-halo bleed at transparent edges', () => {
+    // Red pixel adjacent to fully transparent. Straight-alpha blend mixes the
+    // hidden black of the transparent pixel into the output. Premultiplied
+    // blending keeps the red pure on the opaque side.
+    const source = createSurface(2, 1);
+    source.data.set([255, 0, 0, 255], 0); // opaque red
+    source.data.set([0, 0, 0, 0], 4); // transparent
+    const straight = createSurface(4, 1);
+    resizeSurface(region(straight), region(source), 'bilinear');
+    const premul = createSurface(4, 1);
+    resizeSurface(region(premul), region(source), { mode: 'bilinear', premultiplied: true });
+    // At the boundary (pixel 1), premultiplied keeps red higher than straight
+    expect(premul.data[4]).toBeGreaterThanOrEqual(straight.data[4]);
+  });
+
+  it('downscales by averaging toward the source values', () => {
+    const source = createSurface(4, 1, 0x40608000);
+    const out = createSurface(2, 1);
+    resizeSurface(region(out), region(source), 'bilinear');
+    expect(out.data[0]).toBe(0x40);
+    expect(out.data[1]).toBe(0x60);
+    expect(out.data[2]).toBe(0x80);
+  });
+
+  it('resamples a source sub-region into a dest sub-region', () => {
+    const source = createSurface(4, 1);
+    source.data.set([10, 0, 0, 255], 2 * 4); // source pixel (2,0)
+    const out = createSurface(4, 1);
+    resizeSurface(region(out, 0, 0, 2, 1), region(source, 2, 0, 1, 1), 'nearest');
+    expect(out.data[0]).toBe(10);
+    expect(out.data[4]).toBe(10);
+    expect(out.data[8]).toBe(0); // outside the dest sub-region
+  });
+
+  it("edgeMode 'wrap' wraps boundary interpolation", () => {
+    // 2px source [black, white]. With wrap, the right boundary wraps to the left.
+    const source = createSurface(2, 1);
+    source.data.set([0, 0, 0, 255], 0);
+    source.data.set([200, 200, 200, 255], 4);
+    const outClamp = createSurface(4, 1);
+    resizeSurface(region(outClamp), region(source), { mode: 'bilinear', edgeMode: 'clamp' });
+    const outWrap = createSurface(4, 1);
+    resizeSurface(region(outWrap), region(source), { mode: 'bilinear', edgeMode: 'wrap' });
+    // The rightmost pixel should differ: clamp repeats edge, wrap uses the other side.
+    expect(outClamp.data[12]).not.toBe(outWrap.data[12]);
+  });
+
+  it("edgeMode 'transparent' fades boundary pixels to transparent", () => {
+    const source = createSurface(2, 1, 0xff0000ff);
+    const out = createSurface(4, 1);
+    resizeSurface(region(out), region(source), { mode: 'bilinear', edgeMode: 'transparent' });
+    // The rightmost pixel samples partially out-of-bounds → alpha drops
+    expect(out.data[12 + 3]).toBeLessThan(255);
+  });
+
+  it('is a no-op when a dimension is zero', () => {
+    const source = createSurface(2, 2, 0xffffffff);
+    const out = createSurface(0, 0);
+    expect(() => resizeSurface(region(out), region(source))).not.toThrow();
+  });
+});