privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-JJWZBY7L.mjs

@@ -0,0 +1,254 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  FUSION_SOURCE_POLICY_SCHEMA_VERSION,
+  FusionError
+} from "./c-37GM3GMU.mjs";
+import {
+  canonicalJson
+} from "./c-KIVXWBYD.mjs";
+import {
+  isJsonObject,
+  parseJsonText
+} from "./c-I3C6LBW4.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/pi-background-tasks/src/core/fusion/source-policy.ts?ext=pi-background-tasks
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { isIP } from "node:net";
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+var O_NOFOLLOW = typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
+function sha256Text(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+__name(sha256Text, "sha256Text");
+function stripIpv6Brackets(hostname) {
+  return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+}
+__name(stripIpv6Brackets, "stripIpv6Brackets");
+function isBlockedHostname(hostname) {
+  const lower = hostname.toLowerCase();
+  return lower === "localhost" || lower.endsWith(".localhost") || lower === "metadata" || lower === "metadata.local" || lower === "metadata.google.internal" || lower === "metadata.goog" || lower === "instance-data" || lower === "instance-data.ec2.internal";
+}
+__name(isBlockedHostname, "isBlockedHostname");
+function isBlockedIpv4(host) {
+  const parts = host.split(".").map((part) => Number.parseInt(part, 10));
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255))
+    return true;
+  const [a = 0, b = 0, c = 0] = parts;
+  if (a === 0 || a === 10 || a === 127) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 192 && b === 0 && c === 0) return true;
+  if (a === 192 && b === 0 && c === 2) return true;
+  if (a === 198 && (b === 18 || b === 19)) return true;
+  if (a === 198 && b === 51 && c === 100) return true;
+  if (a === 203 && b === 0 && c === 113) return true;
+  if (a >= 224) return true;
+  return host === "255.255.255.255" || host === "168.63.129.16";
+}
+__name(isBlockedIpv4, "isBlockedIpv4");
+function isBlockedIpv6(host) {
+  const lower = host.toLowerCase();
+  return lower === "::" || lower === "::1" || lower.startsWith("::ffff:") || lower.startsWith("64:ff9b::") || lower.startsWith("64:ff9b:1:") || lower.startsWith("100:") || lower.startsWith("2001:2:") || lower.startsWith("2001:db8:") || lower.startsWith("2002:") || lower.startsWith("fc") || lower.startsWith("fd") || lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb") || lower.startsWith("ff");
+}
+__name(isBlockedIpv6, "isBlockedIpv6");
+function canonicalizeFusionPublicUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch (error) {
+    throw new FusionError(
+      `fusion research declared source URL is malformed: ${error instanceof Error ? error.message : String(error)}`,
+      { code: "orchestration_failed", childCreated: false }
+    );
+  }
+  if (url.username !== "" || url.password !== "") {
+    throw new FusionError("fusion research source URL must not contain credentials", {
+      code: "orchestration_failed",
+      childCreated: false
+    });
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new FusionError("fusion research source URL must use http or https", {
+      code: "orchestration_failed",
+      childCreated: false
+    });
+  }
+  url.username = "";
+  url.password = "";
+  url.hash = "";
+  const normalizedHost = stripIpv6Brackets(url.hostname.toLowerCase().replace(/\.+$/u, ""));
+  url.hostname = normalizedHost;
+  if (isBlockedHostname(normalizedHost)) {
+    throw new FusionError("fusion research source URL must be public, not localhost/metadata", {
+      code: "orchestration_failed",
+      childCreated: false
+    });
+  }
+  const ipKind = isIP(normalizedHost);
+  if (ipKind === 4 && isBlockedIpv4(normalizedHost) || ipKind === 6 && isBlockedIpv6(normalizedHost)) {
+    throw new FusionError("fusion research source URL must be public, not private/reserved", {
+      code: "orchestration_failed",
+      childCreated: false
+    });
+  }
+  if (url.protocol === "http:" && url.port === "80" || url.protocol === "https:" && url.port === "443") {
+    url.port = "";
+  }
+  return url.toString();
+}
+__name(canonicalizeFusionPublicUrl, "canonicalizeFusionPublicUrl");
+function normalizeFusionDeclaredSources(sources = []) {
+  const seen = /* @__PURE__ */ new Map();
+  return sources.map((source, index) => {
+    if (typeof source.url !== "string" || source.url.trim().length === 0) {
+      throw new FusionError(`fusion research source ${String(index)} requires non-blank URL`, {
+        code: "orchestration_failed",
+        childCreated: false
+      });
+    }
+    if (typeof source.purpose !== "string" || source.purpose.trim().length === 0) {
+      throw new FusionError(`fusion research source ${String(index)} requires non-blank purpose`, {
+        code: "orchestration_failed",
+        childCreated: false
+      });
+    }
+    const canonicalUrl = canonicalizeFusionPublicUrl(source.url.trim());
+    const previous = seen.get(canonicalUrl);
+    if (previous !== void 0) {
+      throw new FusionError(
+        `fusion research source ${String(index)} duplicates canonical URL from source ${String(previous)}: ${canonicalUrl}`,
+        { code: "orchestration_failed", childCreated: false }
+      );
+    }
+    seen.set(canonicalUrl, index);
+    const purpose = source.purpose.trim();
+    return {
+      url: canonicalUrl,
+      canonical_url: canonicalUrl,
+      purpose,
+      sha256: sha256Text(`${canonicalUrl}\0${purpose}`)
+    };
+  });
+}
+__name(normalizeFusionDeclaredSources, "normalizeFusionDeclaredSources");
+function buildFusionSourcePolicy(cwd, sources) {
+  const body = {
+    schema_version: FUSION_SOURCE_POLICY_SCHEMA_VERSION,
+    workflow: "research",
+    cwd,
+    sources
+  };
+  return { ...body, root_sha256: sha256Text(canonicalJson(body)) };
+}
+__name(buildFusionSourcePolicy, "buildFusionSourcePolicy");
+function sourcePolicyCanonicalBytes(policy) {
+  return canonicalJson(policy);
+}
+__name(sourcePolicyCanonicalBytes, "sourcePolicyCanonicalBytes");
+function requireString(record, key, label) {
+  const value = record[key];
+  if (typeof value !== "string" || value.length === 0)
+    throw new Error(`${label}.${key} must be non-blank string`);
+  return value;
+}
+__name(requireString, "requireString");
+function parseFusionSourcePolicy(value) {
+  if (!isJsonObject(value) || Array.isArray(value))
+    throw new Error("fusion source policy must be object");
+  const keys = Object.keys(value).sort();
+  const expected = ["cwd", "root_sha256", "schema_version", "sources", "workflow"];
+  if (keys.join("\0") !== expected.join("\0"))
+    throw new Error("fusion source policy keys mismatch");
+  if (value["schema_version"] !== FUSION_SOURCE_POLICY_SCHEMA_VERSION)
+    throw new Error("fusion source policy schema_version mismatch");
+  if (value["workflow"] !== "research")
+    throw new Error("fusion source policy workflow must be research");
+  const cwd = requireString(value, "cwd", "fusion source policy");
+  const rootSha256 = requireString(value, "root_sha256", "fusion source policy");
+  if (!SHA256_HEX.test(rootSha256))
+    throw new Error("fusion source policy.root_sha256 must be sha256");
+  if (!Array.isArray(value["sources"]))
+    throw new Error("fusion source policy.sources must be array");
+  const sources = value["sources"].map((item, index) => {
+    const label = `fusion source policy.sources[${String(index)}]`;
+    if (!isJsonObject(item) || Array.isArray(item)) throw new Error(`${label} must be object`);
+    const itemKeys = Object.keys(item).sort();
+    const itemExpected = ["canonical_url", "purpose", "sha256", "url"];
+    if (itemKeys.join("\0") !== itemExpected.join("\0")) throw new Error(`${label} keys mismatch`);
+    const url = requireString(item, "url", label);
+    const purpose = requireString(item, "purpose", label);
+    const canonical_url = requireString(item, "canonical_url", label);
+    const sha256 = requireString(item, "sha256", label);
+    if (!SHA256_HEX.test(sha256)) throw new Error(`${label}.sha256 must be sha256`);
+    if (canonicalizeFusionPublicUrl(url) !== canonical_url)
+      throw new Error(`${label}.canonical_url mismatch`);
+    if (url !== canonical_url) throw new Error(`${label}.url must equal canonical_url`);
+    if (purpose.trim() !== purpose) throw new Error(`${label}.purpose must be trimmed`);
+    if (sha256Text(`${canonical_url}\0${purpose}`) !== sha256)
+      throw new Error(`${label}.sha256 mismatch`);
+    return { url, canonical_url, purpose, sha256 };
+  });
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, source] of sources.entries()) {
+    if (seen.has(source.canonical_url)) {
+      throw new Error(`fusion source policy.sources[${String(index)}].canonical_url duplicate`);
+    }
+    seen.add(source.canonical_url);
+  }
+  const body = {
+    schema_version: FUSION_SOURCE_POLICY_SCHEMA_VERSION,
+    workflow: "research",
+    cwd,
+    sources
+  };
+  if (sha256Text(canonicalJson(body)) !== rootSha256)
+    throw new Error("fusion source policy root_sha256 mismatch");
+  return { ...body, root_sha256: rootSha256 };
+}
+__name(parseFusionSourcePolicy, "parseFusionSourcePolicy");
+async function readRegularFileNoSymlink(path, label) {
+  let handle;
+  try {
+    handle = await open(path, constants.O_RDONLY | O_NOFOLLOW);
+  } catch (error) {
+    if (isJsonObject(error) && error["code"] === "ELOOP") {
+      throw new Error(`${label} at ${path} is a symlink; refusing to follow it`);
+    }
+    throw error;
+  }
+  try {
+    const stats = await handle.stat();
+    if (!stats.isFile()) throw new Error(`${label} at ${path} is not a regular file`);
+    return await handle.readFile();
+  } finally {
+    await handle.close();
+  }
+}
+__name(readRegularFileNoSymlink, "readRegularFileNoSymlink");
+async function readFusionSourcePolicyFile(path, expectedSha256) {
+  if (!SHA256_HEX.test(expectedSha256))
+    throw new Error("fusion source policy expected hash is malformed");
+  const bytes = await readRegularFileNoSymlink(path, "fusion source policy");
+  const actual = createHash("sha256").update(bytes).digest("hex");
+  if (actual !== expectedSha256) throw new Error("fusion source policy artifact hash mismatch");
+  const text = bytes.toString("utf8");
+  if (!Buffer.from(text, "utf8").equals(bytes))
+    throw new Error("fusion source policy is not UTF-8");
+  return parseFusionSourcePolicy(parseJsonText(text));
+}
+__name(readFusionSourcePolicyFile, "readFusionSourcePolicyFile");
+
+export {
+  canonicalizeFusionPublicUrl,
+  normalizeFusionDeclaredSources,
+  buildFusionSourcePolicy,
+  sourcePolicyCanonicalBytes,
+  readFusionSourcePolicyFile
+};

package/dist-boot/c-JKTFXTGF.mjs

@@ -0,0 +1,463 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  theme
+} from "./c-CRBXNKFO.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/armin.js
+var ARMIN_WIDTH = 31;
+var ARMIN_HEIGHT = 36;
+var WIDTH = ARMIN_WIDTH;
+var HEIGHT = ARMIN_HEIGHT;
+var BITS = [
+  255,
+  255,
+  255,
+  127,
+  255,
+  240,
+  255,
+  127,
+  255,
+  237,
+  255,
+  127,
+  255,
+  219,
+  255,
+  127,
+  255,
+  183,
+  255,
+  127,
+  255,
+  119,
+  254,
+  127,
+  63,
+  248,
+  254,
+  127,
+  223,
+  255,
+  254,
+  127,
+  223,
+  63,
+  252,
+  127,
+  159,
+  195,
+  251,
+  127,
+  111,
+  252,
+  244,
+  127,
+  247,
+  15,
+  247,
+  127,
+  247,
+  255,
+  247,
+  127,
+  247,
+  255,
+  227,
+  127,
+  247,
+  7,
+  232,
+  127,
+  239,
+  248,
+  103,
+  112,
+  15,
+  255,
+  187,
+  111,
+  241,
+  0,
+  208,
+  91,
+  253,
+  63,
+  236,
+  83,
+  193,
+  255,
+  239,
+  87,
+  159,
+  253,
+  238,
+  95,
+  159,
+  252,
+  174,
+  95,
+  31,
+  120,
+  172,
+  95,
+  63,
+  0,
+  80,
+  108,
+  127,
+  0,
+  220,
+  119,
+  255,
+  192,
+  63,
+  120,
+  255,
+  1,
+  248,
+  127,
+  255,
+  3,
+  156,
+  120,
+  255,
+  7,
+  140,
+  124,
+  255,
+  15,
+  206,
+  120,
+  255,
+  255,
+  207,
+  127,
+  255,
+  255,
+  207,
+  120,
+  255,
+  255,
+  223,
+  120,
+  255,
+  255,
+  223,
+  125,
+  255,
+  255,
+  63,
+  126,
+  255,
+  255,
+  255,
+  127
+];
+var BYTES_PER_ROW = Math.ceil(WIDTH / 8);
+var DISPLAY_HEIGHT = Math.ceil(HEIGHT / 2);
+var EFFECTS = ["typewriter", "scanline", "rain", "fade", "crt", "glitch", "dissolve"];
+function isArminPixel(x, y) {
+  if (y >= HEIGHT)
+    return false;
+  const byteIndex = y * BYTES_PER_ROW + Math.floor(x / 8);
+  const bitIndex = x % 8;
+  return (BITS[byteIndex] >> bitIndex & 1) === 0;
+}
+__name(isArminPixel, "isArminPixel");
+function getChar(x, row) {
+  const upper = isArminPixel(x, row * 2);
+  const lower = isArminPixel(x, row * 2 + 1);
+  if (upper && lower)
+    return "\u2588";
+  if (upper)
+    return "\u2580";
+  if (lower)
+    return "\u2584";
+  return " ";
+}
+__name(getChar, "getChar");
+function buildFinalGrid() {
+  const grid = [];
+  for (let row = 0; row < DISPLAY_HEIGHT; row++) {
+    const line = [];
+    for (let x = 0; x < WIDTH; x++) {
+      line.push(getChar(x, row));
+    }
+    grid.push(line);
+  }
+  return grid;
+}
+__name(buildFinalGrid, "buildFinalGrid");
+var ArminComponent = class {
+  static {
+    __name(this, "ArminComponent");
+  }
+  ui;
+  interval = null;
+  effect;
+  finalGrid;
+  currentGrid;
+  effectState = {};
+  cachedLines = [];
+  cachedWidth = 0;
+  gridVersion = 0;
+  cachedVersion = -1;
+  constructor(ui) {
+    this.ui = ui;
+    this.effect = EFFECTS[Math.floor(Math.random() * EFFECTS.length)];
+    this.finalGrid = buildFinalGrid();
+    this.currentGrid = this.createEmptyGrid();
+    this.initEffect();
+    this.startAnimation();
+  }
+  invalidate() {
+    this.cachedWidth = 0;
+  }
+  render(width) {
+    if (width === this.cachedWidth && this.cachedVersion === this.gridVersion) {
+      return this.cachedLines;
+    }
+    const padding = 1;
+    const availableWidth = width - padding;
+    this.cachedLines = this.currentGrid.map((row) => {
+      const clipped = row.slice(0, availableWidth).join("");
+      const padRight = Math.max(0, width - padding - clipped.length);
+      return ` ${theme.fg("accent", clipped)}${" ".repeat(padRight)}`;
+    });
+    const message = "ARMIN SAYS HI";
+    const msgPadRight = Math.max(0, width - padding - message.length);
+    this.cachedLines.push(` ${theme.fg("accent", message)}${" ".repeat(msgPadRight)}`);
+    this.cachedWidth = width;
+    this.cachedVersion = this.gridVersion;
+    return this.cachedLines;
+  }
+  createEmptyGrid() {
+    return Array.from({ length: DISPLAY_HEIGHT }, () => Array(WIDTH).fill(" "));
+  }
+  initEffect() {
+    switch (this.effect) {
+      case "typewriter":
+        this.effectState = { pos: 0 };
+        break;
+      case "scanline":
+        this.effectState = { row: 0 };
+        break;
+      case "rain":
+        this.effectState = {
+          drops: Array.from({ length: WIDTH }, () => ({
+            y: -Math.floor(Math.random() * DISPLAY_HEIGHT * 2),
+            settled: 0
+          }))
+        };
+        break;
+      case "fade": {
+        const positions = [];
+        for (let row = 0; row < DISPLAY_HEIGHT; row++) {
+          for (let x = 0; x < WIDTH; x++) {
+            positions.push([row, x]);
+          }
+        }
+        for (let i = positions.length - 1; i > 0; i--) {
+          const j = Math.floor(Math.random() * (i + 1));
+          [positions[i], positions[j]] = [positions[j], positions[i]];
+        }
+        this.effectState = { positions, idx: 0 };
+        break;
+      }
+      case "crt":
+        this.effectState = { expansion: 0 };
+        break;
+      case "glitch":
+        this.effectState = { phase: 0, glitchFrames: 8 };
+        break;
+      case "dissolve": {
+        this.currentGrid = Array.from({ length: DISPLAY_HEIGHT }, () => Array.from({ length: WIDTH }, () => {
+          const chars = [" ", "\u2591", "\u2592", "\u2593", "\u2588", "\u2580", "\u2584"];
+          return chars[Math.floor(Math.random() * chars.length)];
+        }));
+        const dissolvePositions = [];
+        for (let row = 0; row < DISPLAY_HEIGHT; row++) {
+          for (let x = 0; x < WIDTH; x++) {
+            dissolvePositions.push([row, x]);
+          }
+        }
+        for (let i = dissolvePositions.length - 1; i > 0; i--) {
+          const j = Math.floor(Math.random() * (i + 1));
+          [dissolvePositions[i], dissolvePositions[j]] = [dissolvePositions[j], dissolvePositions[i]];
+        }
+        this.effectState = { positions: dissolvePositions, idx: 0 };
+        break;
+      }
+    }
+  }
+  startAnimation() {
+    const fps = this.effect === "glitch" ? 60 : 30;
+    this.interval = setInterval(() => {
+      const done = this.tickEffect();
+      this.updateDisplay();
+      this.ui.requestRender();
+      if (done) {
+        this.stopAnimation();
+      }
+    }, 1e3 / fps);
+  }
+  stopAnimation() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+  tickEffect() {
+    switch (this.effect) {
+      case "typewriter":
+        return this.tickTypewriter();
+      case "scanline":
+        return this.tickScanline();
+      case "rain":
+        return this.tickRain();
+      case "fade":
+        return this.tickFade();
+      case "crt":
+        return this.tickCrt();
+      case "glitch":
+        return this.tickGlitch();
+      case "dissolve":
+        return this.tickDissolve();
+      default:
+        return true;
+    }
+  }
+  tickTypewriter() {
+    const state = this.effectState;
+    const pixelsPerFrame = 3;
+    for (let i = 0; i < pixelsPerFrame; i++) {
+      const row = Math.floor(state.pos / WIDTH);
+      const x = state.pos % WIDTH;
+      if (row >= DISPLAY_HEIGHT)
+        return true;
+      this.currentGrid[row][x] = this.finalGrid[row][x];
+      state.pos++;
+    }
+    return false;
+  }
+  tickScanline() {
+    const state = this.effectState;
+    if (state.row >= DISPLAY_HEIGHT)
+      return true;
+    for (let x = 0; x < WIDTH; x++) {
+      this.currentGrid[state.row][x] = this.finalGrid[state.row][x];
+    }
+    state.row++;
+    return false;
+  }
+  tickRain() {
+    const state = this.effectState;
+    let allSettled = true;
+    this.currentGrid = this.createEmptyGrid();
+    for (let x = 0; x < WIDTH; x++) {
+      const drop = state.drops[x];
+      for (let row = DISPLAY_HEIGHT - 1; row >= DISPLAY_HEIGHT - drop.settled; row--) {
+        if (row >= 0) {
+          this.currentGrid[row][x] = this.finalGrid[row][x];
+        }
+      }
+      if (drop.settled >= DISPLAY_HEIGHT)
+        continue;
+      allSettled = false;
+      let targetRow = -1;
+      for (let row = DISPLAY_HEIGHT - 1 - drop.settled; row >= 0; row--) {
+        if (this.finalGrid[row][x] !== " ") {
+          targetRow = row;
+          break;
+        }
+      }
+      drop.y++;
+      if (drop.y >= 0 && drop.y < DISPLAY_HEIGHT) {
+        if (targetRow >= 0 && drop.y >= targetRow) {
+          drop.settled = DISPLAY_HEIGHT - targetRow;
+          drop.y = -Math.floor(Math.random() * 5) - 1;
+        } else {
+          this.currentGrid[drop.y][x] = "\u2593";
+        }
+      }
+    }
+    return allSettled;
+  }
+  tickFade() {
+    const state = this.effectState;
+    const pixelsPerFrame = 15;
+    for (let i = 0; i < pixelsPerFrame; i++) {
+      if (state.idx >= state.positions.length)
+        return true;
+      const [row, x] = state.positions[state.idx];
+      this.currentGrid[row][x] = this.finalGrid[row][x];
+      state.idx++;
+    }
+    return false;
+  }
+  tickCrt() {
+    const state = this.effectState;
+    const midRow = Math.floor(DISPLAY_HEIGHT / 2);
+    this.currentGrid = this.createEmptyGrid();
+    const top = midRow - state.expansion;
+    const bottom = midRow + state.expansion;
+    for (let row = Math.max(0, top); row <= Math.min(DISPLAY_HEIGHT - 1, bottom); row++) {
+      for (let x = 0; x < WIDTH; x++) {
+        this.currentGrid[row][x] = this.finalGrid[row][x];
+      }
+    }
+    state.expansion++;
+    return state.expansion > DISPLAY_HEIGHT;
+  }
+  tickGlitch() {
+    const state = this.effectState;
+    if (state.phase < state.glitchFrames) {
+      this.currentGrid = this.finalGrid.map((row) => {
+        const offset = Math.floor(Math.random() * 7) - 3;
+        const glitchRow = [...row];
+        if (Math.random() < 0.3) {
+          const shifted = glitchRow.slice(offset).concat(glitchRow.slice(0, offset));
+          return shifted.slice(0, WIDTH);
+        }
+        if (Math.random() < 0.2) {
+          const swapRow = Math.floor(Math.random() * DISPLAY_HEIGHT);
+          return [...this.finalGrid[swapRow]];
+        }
+        return glitchRow;
+      });
+      state.phase++;
+      return false;
+    }
+    this.currentGrid = this.finalGrid.map((row) => [...row]);
+    return true;
+  }
+  tickDissolve() {
+    const state = this.effectState;
+    const pixelsPerFrame = 20;
+    for (let i = 0; i < pixelsPerFrame; i++) {
+      if (state.idx >= state.positions.length)
+        return true;
+      const [row, x] = state.positions[state.idx];
+      this.currentGrid[row][x] = this.finalGrid[row][x];
+      state.idx++;
+    }
+    return false;
+  }
+  updateDisplay() {
+    this.gridVersion++;
+  }
+  dispose() {
+    this.stopAnimation();
+  }
+};
+
+export {
+  ARMIN_WIDTH,
+  ARMIN_HEIGHT,
+  isArminPixel,
+  ArminComponent
+};