capture-flow 0.0.0-stage → 0.1.0

package/vendor/wajha/engine/types.ts

@@ -0,0 +1,190 @@
+/**
+ * Public contract of the rendering engine.
+ *
+ * The engine is pure TypeScript on top of the Canvas 2D API. It never touches
+ * the DOM, storage or the store: everything it needs comes in through
+ * `RenderInput`, so the same code draws the editor preview, thumbnails,
+ * template previews, exports, and runs in Node tests on @napi-rs/canvas.
+ *
+ * Browser-compat rules (WKWebView on macOS 11+, WebView2, WebKitGTK):
+ *  - Do not rely on `ctx.filter`; blur with shadowBlur or downscale tricks.
+ *  - Feature-detect `ctx.letterSpacing` and `ctx.roundRect`.
+ *  - Text shaping comes from `fillText` with `ctx.direction` set; lines that
+ *    mix directions are cut into one-direction pieces first (bidi.ts), since
+ *    WebKit misplaces the later direction runs of a single call vertically.
+ */
+import type {
+  Color,
+  DeviceElement,
+  DeviceFrameId,
+  FamilyId,
+  LangCode,
+  LanguageTypography,
+  Slide,
+  SlideLayout,
+  TextStyle,
+  Theme,
+} from '../model/types';
+
+export type Ctx2D = CanvasRenderingContext2D;
+
+/** Anything drawImage accepts that also reports its pixel size. */
+export type ImageLike = CanvasImageSource & { width: number; height: number };
+
+export interface RenderEnv {
+  /** Creates a scratch canvas for offscreen effects (blur, patterns, masks). */
+  createCanvas(width: number, height: number): { canvas: ImageLike; ctx: Ctx2D };
+}
+
+export interface RenderInput {
+  /** Output size in pixels. */
+  width: number;
+  height: number;
+  family: FamilyId;
+  slide: Slide;
+  /** Already resolved for `family` (see model/resolve.ts). */
+  layout: SlideLayout;
+  theme: Theme;
+  lang: LangCode;
+  /** Fallback language for missing texts and screenshots. */
+  baseLang: LangCode;
+  rtl: boolean;
+  /**
+   * Draw the slide mirrored for a right-to-left listing: elements trade
+   * sides (model/mirror.ts) and the background flips. Text, screenshots and
+   * pictures still read normally.
+   */
+  mirror?: boolean;
+  /** Font and line spacing of `lang`, over each text's own style (model/typography.ts). */
+  typography?: LanguageTypography | null;
+  /** Position of this slide, for panorama backgrounds and mock-screen seeds. */
+  slideIndex: number;
+  slideCount: number;
+  /** Decoded image for an asset id, or null while it is not loaded yet. */
+  getImage(assetId: string): ImageLike | null;
+  /** Height / width of an asset from its AssetInfo, so layout never waits on decoding. */
+  getAssetAspect(assetId: string): number | null;
+  /**
+   * What to draw in a device whose slot has no screenshot:
+   * "mock" = generated fake app screen, "empty" = neutral screen.
+   */
+  placeholder: 'mock' | 'empty';
+  env: RenderEnv;
+}
+
+/** Element bounds in output pixels, used for hit-testing and selection UI. */
+export interface ElementBox {
+  id: string;
+  /** Center */
+  cx: number;
+  cy: number;
+  /** Unrotated size */
+  w: number;
+  h: number;
+  /** degrees clockwise */
+  rotation: number;
+}
+
+export interface RenderResult {
+  boxes: ElementBox[];
+  /** Device element ids whose slot had no screenshot for `lang` (after fallback). */
+  missingShots: string[];
+  /** Text element ids that still overflow `maxLines` at the minimum size. */
+  overflowingText: string[];
+  /** Device element ids whose screenshot is resolved but not decoded yet. */
+  pendingImages: string[];
+}
+
+/* ------------------------------------------------------------------ */
+/* Devices                                                             */
+/* ------------------------------------------------------------------ */
+
+export interface ScreenRect {
+  /** Relative to the device's top-left corner, pixels. */
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  /** Screen corner radius, pixels. */
+  radius: number;
+}
+
+export interface DeviceGeometry {
+  /** Outer size of the device artwork, pixels. */
+  width: number;
+  height: number;
+  screen: ScreenRect;
+}
+
+export interface DrawDeviceOptions {
+  /** drawDevice also paints `el.shadow` (shaped like the device body) and honours `el.style`. */
+  el: DeviceElement;
+  /** Outer device width in pixels. */
+  widthPx: number;
+  /** u = min(canvas width, height) in pixels; shadow blur/offsets are fractions of it. */
+  unit: number;
+  /** Screen height / width. */
+  screenAspect: number;
+  /** Screenshot, or null to draw the placeholder. */
+  screen: ImageLike | null;
+  placeholder: 'mock' | 'empty';
+  /** Seed + palette for mock screens. */
+  mock: { seed: number; palette: Color[]; dark: boolean };
+  env: RenderEnv;
+}
+
+/* ------------------------------------------------------------------ */
+/* Text                                                                */
+/* ------------------------------------------------------------------ */
+
+export interface TextRun {
+  text: string;
+  highlighted: boolean;
+  /** Run width in pixels at the final font size. */
+  width: number;
+}
+
+export interface TextLine {
+  runs: TextRun[];
+  width: number;
+}
+
+export interface TextLayout {
+  lines: TextLine[];
+  /** Final font size in pixels after auto-fit. */
+  fontPx: number;
+  lineHeightPx: number;
+  /** Width of the box in pixels (the element width). */
+  boxWidth: number;
+  /** Total block height in pixels. */
+  height: number;
+  /** True when the text still needs more than `maxLines` at the minimum size. */
+  overflow: boolean;
+}
+
+export interface LayoutTextInput {
+  text: string;
+  style: TextStyle;
+  /** Text box width in pixels. */
+  boxWidth: number;
+  /** u = min(canvas width, height) in pixels. */
+  unit: number;
+  rtl: boolean;
+  lang: LangCode;
+}
+
+/* ------------------------------------------------------------------ */
+/* Function signatures implemented in src/engine                       */
+/* ------------------------------------------------------------------ */
+
+export type RenderSlideFn = (ctx: Ctx2D, input: RenderInput) => RenderResult;
+export type DeviceGeometryFn = (frame: DeviceFrameId, widthPx: number, screenAspect: number) => DeviceGeometry;
+/** Draws the device centered at the current origin (caller translates/rotates). */
+export type DrawDeviceFn = (ctx: Ctx2D, opts: DrawDeviceOptions) => DeviceGeometry;
+export type LayoutTextFn = (ctx: Ctx2D, input: LayoutTextInput) => TextLayout;
+export type DrawMockScreenFn = (
+  ctx: Ctx2D,
+  width: number,
+  height: number,
+  opts: { seed: number; palette: Color[]; dark: boolean; family?: FamilyId },
+) => void;

package/vendor/wajha/export/paths.ts

@@ -0,0 +1,197 @@
+/**
+ * Folder and file naming for the "stores", "fastlane" and "flat" export
+ * structures (ARCHITECTURE 6.5), plus the sanitiser applied to every path
+ * segment, so user data (language codes, names) can never escape the export
+ * folder or produce a name some file system refuses.
+ */
+import { languageInfo, sizeById } from '../model/catalog';
+import type { ExportStructure, FamilyId, StoreId } from '../model/types';
+import type { ExportJob } from './types';
+
+/** Longest segment we emit, in UTF-16 code units: at most 240 UTF-8 bytes, under every file system's 255 limit. */
+export const MAX_SEGMENT_LENGTH = 80;
+
+/** Characters Windows forbids in names; "/" and "\\" are separators everywhere else too. */
+const FORBIDDEN = new Set(['/', '\\', ':', '*', '?', '"', '<', '>', '|']);
+
+/** Device names Windows reserves regardless of extension ("nul.png" is as broken as "NUL"). */
+const WINDOWS_RESERVED = /^(con|prn|aux|nul|conin\$|conout\$|com[0-9¹²³]|lpt[0-9¹²³])$/i;
+
+/**
+ * Invisible directional formatting characters. They have no business in a
+ * file name and the overrides allow "RLO" tricks that disguise extensions.
+ * Zero-width joiners stay: Persian words and emoji sequences need them.
+ */
+function isBidiControl(cp: number): boolean {
+  return cp === 0x061c || cp === 0x200e || cp === 0x200f || (cp >= 0x202a && cp <= 0x202e) || (cp >= 0x2066 && cp <= 0x2069);
+}
+
+function isControl(cp: number): boolean {
+  return cp < 0x20 || (cp >= 0x7f && cp <= 0x9f);
+}
+
+/** Iterating by code points joins surrogate pairs, so a code point in this range is an unpaired half: no file system accepts it. */
+function isLoneSurrogate(cp: number): boolean {
+  return cp >= 0xd800 && cp <= 0xdfff;
+}
+
+let graphemes: Intl.Segmenter | null | undefined;
+
+/** Shared grapheme segmenter, or null where Intl.Segmenter is missing (older WebKit). */
+function graphemeSegmenter(): Intl.Segmenter | null {
+  if (graphemes === undefined) {
+    graphemes = typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function' ? new Intl.Segmenter(undefined, { granularity: 'grapheme' }) : null;
+  }
+  return graphemes;
+}
+
+/** Cuts `s` to at most `max` code units without splitting an emoji, a combining sequence or a surrogate pair. */
+function truncate(s: string, max: number): string {
+  if (s.length <= max) return s;
+  let out = '';
+  const seg = graphemeSegmenter();
+  if (seg) {
+    for (const { segment } of seg.segment(s)) {
+      if (out.length + segment.length > max) break;
+      out += segment;
+    }
+  }
+  // A single cluster longer than the limit (or no Segmenter): fall back to code points.
+  if (out === '') {
+    for (const ch of s) {
+      if (out.length + ch.length > max) break;
+      out += ch;
+    }
+  }
+  return out;
+}
+
+const trimDotsAndSpaces = (s: string) => s.replace(/^[. ]+|[. ]+$/g, '');
+
+/**
+ * Makes `name` safe as one path segment on macOS, Windows and Linux: strips
+ * `/ \ : * ? " < > |`, control and bidi-control characters and unpaired
+ * surrogates, collapses whitespace, trims leading/trailing dots and spaces
+ * (hidden files, Windows quirks), keeps at most 80 code units, renames
+ * Windows device names ("CON" -> "CON_") and never returns an empty string
+ * ("Untitled").
+ */
+export function sanitizeSegment(name: string): string {
+  let out = '';
+  // NFC first so a name typed on macOS (decomposed) and Windows (composed) maps to one folder.
+  for (const ch of String(name).normalize('NFC').replace(/\s+/g, ' ')) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (FORBIDDEN.has(ch) || isControl(cp) || isBidiControl(cp) || isLoneSurrogate(cp)) continue;
+    out += ch;
+  }
+  out = trimDotsAndSpaces(out.replace(/ {2,}/g, ' '));
+  const dot = out.indexOf('.');
+  const stem = (dot < 0 ? out : out.slice(0, dot)).trimEnd();
+  if (WINDOWS_RESERVED.test(stem)) out = `${stem}_${dot < 0 ? '' : out.slice(dot)}`;
+  out = trimDotsAndSpaces(truncate(out, MAX_SEGMENT_LENGTH));
+  return out === '' ? 'Untitled' : out;
+}
+
+/**
+ * fastlane deliver files screenshots by resolution, and several of our
+ * sizes land in the same App Store Connect screenshot set (from deliver's
+ * app_screenshot.rb). Two sizes in one set would upload every slide twice.
+ */
+const DELIVER_SETS: Record<string, string> = {
+  '1320x2868': 'APP_IPHONE_67',
+  '1290x2796': 'APP_IPHONE_67',
+  '1260x2736': 'APP_IPHONE_67',
+  '1284x2778': 'APP_IPHONE_65',
+  '1242x2688': 'APP_IPHONE_65',
+  '1206x2622': 'APP_IPHONE_61',
+  '1179x2556': 'APP_IPHONE_61',
+  '1170x2532': 'APP_IPHONE_58',
+  '1125x2436': 'APP_IPHONE_58',
+  '1080x2340': 'APP_IPHONE_58',
+  // "12.9" plus "2nd generation" in the file name would select APP_IPAD_PRO_129; our names never say that.
+  '2064x2752': 'APP_IPAD_PRO_3GEN_129',
+  '2048x2732': 'APP_IPAD_PRO_3GEN_129',
+  '1668x2420': 'APP_IPAD_PRO_3GEN_11',
+  '1668x2388': 'APP_IPAD_PRO_3GEN_11',
+  '1640x2360': 'APP_IPAD_PRO_3GEN_11',
+  '1488x2266': 'APP_IPAD_PRO_3GEN_11',
+  '2880x1800': 'APP_DESKTOP',
+  '2560x1600': 'APP_DESKTOP',
+  '1440x900': 'APP_DESKTOP',
+  '1280x800': 'APP_DESKTOP',
+  '422x514': 'APP_WATCH_ULTRA',
+  '410x502': 'APP_WATCH_ULTRA',
+  '416x496': 'APP_WATCH_SERIES_10',
+  '396x484': 'APP_WATCH_SERIES_7',
+  '368x448': 'APP_WATCH_SERIES_4',
+  '312x390': 'APP_WATCH_SERIES_3',
+  '3840x2160': 'APP_APPLE_TV',
+  '1920x1080': 'APP_APPLE_TV',
+};
+
+/**
+ * The App Store Connect screenshot set fastlane deliver files an App Store
+ * size under; a unique key for unknown resolutions. deliver takes phones and
+ * tablets in either orientation, so a landscape size shares its portrait
+ * size's set. Apple TV 4K and Vision Pro share a resolution, so the family
+ * tells them apart.
+ */
+export function deliverScreenshotSet(size: { width: number; height: number; family?: FamilyId }): string {
+  if (size.family === 'vision') return 'APP_APPLE_VISION_PRO';
+  const key = `${size.width}x${size.height}`;
+  return DELIVER_SETS[key] ?? DELIVER_SETS[`${size.height}x${size.width}`] ?? `SIZE_${key}`;
+}
+
+/** The store's locale code for a project language, or null when that store has none. */
+export function storeLocale(lang: string, store: StoreId): string | null {
+  const info = languageInfo(lang);
+  return store === 'app-store' ? info.appStore : info.play;
+}
+
+/** "App Store" / "Google Play", as used in folder names and messages. */
+export function storeLabel(store: StoreId): string {
+  return store === 'app-store' ? 'App Store' : 'Google Play';
+}
+
+/**
+ * Relative POSIX path of one exported file:
+ *  - stores:   "App Store/<locale>/<size folder>/NN.ext", "Google Play/<locale>/<size folder>/NN.ext",
+ *              feature graphic "Google Play/<locale>/Feature graphic.ext"
+ *  - fastlane: "fastlane/screenshots/<locale>/NN_<size id>.ext" (deliver),
+ *              "fastlane/metadata/android/<locale>/images/<supplyFolder>/NN.ext" (supply),
+ *              feature graphic ".../images/featureGraphic.ext"
+ *  - flat:     "<size id>/<lang>/NN.ext"
+ * NN is the 1-based slide number with two digits. Throws for an unknown size
+ * or a language the size's store has no locale for (planExport skips those).
+ *
+ * `projectName` is part of the contract but no structure contains it: files
+ * go straight into the folder the user picked, which `pickExportTarget`
+ * already names after the project.
+ */
+export function exportPath(structure: ExportStructure, job: Omit<ExportJob, 'path'>, ext: 'png' | 'jpg', _projectName: string): string {
+  const size = sizeById(job.sizeId);
+  if (!size) throw new Error(`Unknown export size "${job.sizeId}"`);
+  if (!Number.isInteger(job.slideIndex) || job.slideIndex < 0) throw new RangeError(`Invalid slide index ${job.slideIndex}`);
+  const nn = String(job.slideIndex + 1).padStart(2, '0');
+  const feature = size.supplyFolder === 'featureGraphic';
+
+  if (structure === 'flat') return `${sanitizeSegment(size.id)}/${sanitizeSegment(job.lang)}/${nn}.${ext}`;
+  if (structure !== 'stores' && structure !== 'fastlane') throw new Error(`Unknown export structure "${String(structure)}"`);
+
+  const code = storeLocale(job.lang, size.store);
+  if (code === null) throw new Error(`${languageInfo(job.lang).name} has no ${storeLabel(size.store)} locale code`);
+  const locale = sanitizeSegment(code);
+
+  if (size.store === 'app-store') {
+    return structure === 'stores'
+      ? `App Store/${locale}/${sanitizeSegment(size.folder)}/${nn}.${ext}`
+      : `fastlane/screenshots/${locale}/${nn}_${sanitizeSegment(size.id)}.${ext}`;
+  }
+  if (structure === 'stores') {
+    return feature ? `Google Play/${locale}/Feature graphic.${ext}` : `Google Play/${locale}/${sanitizeSegment(size.folder)}/${nn}.${ext}`;
+  }
+  const images = `fastlane/metadata/android/${locale}/images`;
+  if (feature) return `${images}/featureGraphic.${ext}`;
+  if (!size.supplyFolder) throw new Error(`Export size "${size.id}" has no fastlane supply folder`);
+  return `${images}/${size.supplyFolder}/${nn}.${ext}`;
+}

package/vendor/wajha/export/png.ts

@@ -0,0 +1,223 @@
+/**
+ * Minimal, fast PNG encoder for export renders.
+ *
+ * Output is always 8-bit truecolour without alpha (colour type 2): Google
+ * Play rejects screenshots with an alpha channel and App Store Connect
+ * rejects transparency, so any alpha in the canvas pixels is composited over
+ * white here. Rows use the adaptive filter heuristic libpng uses (the filter
+ * with the smallest sum of absolute signed bytes wins), then fflate deflates
+ * the whole image in one go.
+ */
+import { zlibSync } from 'fflate';
+
+const SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+/** Bytes per pixel of the encoded image (RGB). */
+const BPP = 3;
+/** Largest IDAT payload we write. Any size is legal; 1 MiB keeps chunks friendly to streaming readers. */
+export const MAX_IDAT_BYTES = 1 << 20;
+const MAX_DIMENSION = 0x7fffffff;
+
+const CRC_TABLE = (() => {
+  const table = new Int32Array(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;
+    table[n] = c;
+  }
+  return table;
+})();
+
+/** CRC-32 (ISO 3309, as used by PNG chunks) of `data[start..end)`. Pass a previous result as `seed` to continue it. */
+export function crc32(data: Uint8Array, start = 0, end = data.length, seed = 0): number {
+  let c = ~seed;
+  for (let i = start; i < end; i++) c = CRC_TABLE[(c ^ data[i]) & 0xff] ^ (c >>> 8);
+  return ~c >>> 0;
+}
+
+/** Throws a RangeError unless `rgba` holds exactly width x height RGBA pixels. */
+export function assertPngInput(rgba: ArrayLike<number>, width: number, height: number): void {
+  if (!Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1 || width > MAX_DIMENSION || height > MAX_DIMENSION) {
+    throw new RangeError(`Invalid PNG size ${width} x ${height}`);
+  }
+  const expected = width * height * 4;
+  if (rgba.length !== expected) throw new RangeError(`Expected ${expected} bytes of RGBA pixels for ${width} x ${height}, got ${rgba.length}`);
+}
+
+const LEVELS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] as const;
+
+function deflateLevel(level: number): (typeof LEVELS)[number] {
+  if (!Number.isFinite(level)) return 6;
+  return LEVELS[Math.min(9, Math.max(0, Math.round(level)))];
+}
+
+/**
+ * Copies one row of RGBA pixels into `out` as RGB composited over white.
+ * Canvas ImageData is not premultiplied, so a pixel with alpha `a` becomes
+ * c * a/255 + 255 * (1 - a/255), rounded to nearest (no ties exist).
+ */
+function compositeRow(rgba: Uint8ClampedArray | Uint8Array, src: number, out: Uint8Array, width: number): void {
+  for (let x = 0, i = src, j = 0; x < width; x++, i += 4, j += 3) {
+    const a = rgba[i + 3];
+    if (a === 255) {
+      out[j] = rgba[i];
+      out[j + 1] = rgba[i + 1];
+      out[j + 2] = rgba[i + 2];
+    } else if (a === 0) {
+      out[j] = 255;
+      out[j + 1] = 255;
+      out[j + 2] = 255;
+    } else {
+      out[j] = 255 - ((((255 - rgba[i]) * a + 127) / 255) | 0);
+      out[j + 1] = 255 - ((((255 - rgba[i + 1]) * a + 127) / 255) | 0);
+      out[j + 2] = 255 - ((((255 - rgba[i + 2]) * a + 127) / 255) | 0);
+    }
+  }
+}
+
+/** |b| for a filtered byte read as a signed int8, the per-byte cost of the MSAD heuristic. */
+const cost = (v: number) => (v < 128 ? v : 256 - v);
+
+function paeth(a: number, b: number, c: number): number {
+  const p = a + b - c;
+  const pa = p > a ? p - a : a - p;
+  const pb = p > b ? p - b : b - p;
+  const pc = p > c ? p - c : c - p;
+  return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+}
+
+/** Filter type (0 None, 1 Sub, 2 Up, 3 Average, 4 Paeth) with the smallest cost for this row; earlier types win ties. */
+function chooseFilter(cur: Uint8Array, prev: Uint8Array, stride: number): number {
+  let none = 0;
+  let sub = 0;
+  let up = 0;
+  let avg = 0;
+  let pae = 0;
+  // The first pixel has no left neighbour (a = c = 0), which removes branches from the main loop.
+  const head = Math.min(BPP, stride);
+  for (let i = 0; i < head; i++) {
+    const x = cur[i];
+    const b = prev[i];
+    none += cost(x);
+    sub += cost(x);
+    up += cost((x - b) & 255);
+    avg += cost((x - (b >> 1)) & 255);
+    pae += cost((x - b) & 255);
+  }
+  for (let i = BPP; i < stride; i++) {
+    const x = cur[i];
+    const a = cur[i - BPP];
+    const b = prev[i];
+    const c = prev[i - BPP];
+    none += cost(x);
+    sub += cost((x - a) & 255);
+    up += cost((x - b) & 255);
+    avg += cost((x - ((a + b) >> 1)) & 255);
+    pae += cost((x - paeth(a, b, c)) & 255);
+  }
+  let best = 0;
+  let min = none;
+  if (sub < min) {
+    best = 1;
+    min = sub;
+  }
+  if (up < min) {
+    best = 2;
+    min = up;
+  }
+  if (avg < min) {
+    best = 3;
+    min = avg;
+  }
+  return pae < min ? 4 : best;
+}
+
+/** Writes the filter byte and the filtered row at `out[o]`. */
+function writeRow(out: Uint8Array, o: number, filter: number, cur: Uint8Array, prev: Uint8Array, stride: number): void {
+  out[o] = filter;
+  const d = o + 1;
+  const head = Math.min(BPP, stride);
+  switch (filter) {
+    case 0:
+      out.set(cur, d);
+      break;
+    case 1:
+      for (let i = 0; i < head; i++) out[d + i] = cur[i];
+      for (let i = BPP; i < stride; i++) out[d + i] = cur[i] - cur[i - BPP];
+      break;
+    case 2:
+      for (let i = 0; i < stride; i++) out[d + i] = cur[i] - prev[i];
+      break;
+    case 3:
+      for (let i = 0; i < head; i++) out[d + i] = cur[i] - (prev[i] >> 1);
+      for (let i = BPP; i < stride; i++) out[d + i] = cur[i] - ((cur[i - BPP] + prev[i]) >> 1);
+      break;
+    default:
+      for (let i = 0; i < head; i++) out[d + i] = cur[i] - prev[i];
+      for (let i = BPP; i < stride; i++) out[d + i] = cur[i] - paeth(cur[i - BPP], prev[i], prev[i - BPP]);
+  }
+}
+
+/** Composites and filters every row into the byte stream that IDAT compresses. */
+function filterImage(rgba: Uint8ClampedArray | Uint8Array, width: number, height: number): Uint8Array {
+  const stride = width * BPP;
+  const out = new Uint8Array(height * (stride + 1));
+  // Uint8Array stores wrap modulo 256, which is exactly the filter arithmetic.
+  let prev = new Uint8Array(stride);
+  let cur = new Uint8Array(stride);
+  for (let y = 0; y < height; y++) {
+    compositeRow(rgba, y * width * 4, cur, width);
+    writeRow(out, y * (stride + 1), chooseFilter(cur, prev, stride), cur, prev, stride);
+    const t = prev;
+    prev = cur;
+    cur = t;
+  }
+  return out;
+}
+
+const ascii = (s: string) => Array.from(s, (ch) => ch.charCodeAt(0));
+const IHDR = ascii('IHDR');
+const IDAT = ascii('IDAT');
+const IEND = ascii('IEND');
+
+/** Writes one chunk (length, type, data, CRC of type + data) at `o`; returns the offset after it. */
+function writeChunk(png: Uint8Array, view: DataView, o: number, type: number[], data: Uint8Array): number {
+  view.setUint32(o, data.length);
+  png.set(type, o + 4);
+  png.set(data, o + 8);
+  const end = o + 8 + data.length;
+  view.setUint32(end, crc32(png, o + 4, end));
+  return end + 4;
+}
+
+/** encodePng with the precise buffer type, so the worker can transfer the result. */
+export function encodePngBuffer(rgba: Uint8ClampedArray | Uint8Array, width: number, height: number, level = 6): Uint8Array<ArrayBuffer> {
+  assertPngInput(rgba, width, height);
+  const idat = zlibSync(filterImage(rgba, width, height), { level: deflateLevel(level) });
+
+  const header = new Uint8Array(13);
+  const hv = new DataView(header.buffer);
+  hv.setUint32(0, width);
+  hv.setUint32(4, height);
+  header[8] = 8; // bit depth
+  header[9] = 2; // colour type: truecolour, no alpha
+  // compression, filter and interlace methods stay 0
+
+  const idatChunks = Math.max(1, Math.ceil(idat.length / MAX_IDAT_BYTES));
+  const png = new Uint8Array(SIGNATURE.length + (12 + 13) + idat.length + 12 * idatChunks + 12);
+  const view = new DataView(png.buffer);
+  png.set(SIGNATURE, 0);
+  let o = writeChunk(png, view, SIGNATURE.length, IHDR, header);
+  for (let start = 0; start < idat.length; start += MAX_IDAT_BYTES) {
+    o = writeChunk(png, view, o, IDAT, idat.subarray(start, Math.min(idat.length, start + MAX_IDAT_BYTES)));
+  }
+  writeChunk(png, view, o, IEND, new Uint8Array(0));
+  return png;
+}
+
+/**
+ * RGBA (canvas ImageData order) -> PNG bytes with color type 2 (RGB, 8-bit).
+ * Alpha is composited over white. `level` is the deflate level 0..9.
+ */
+export function encodePng(rgba: Uint8ClampedArray | Uint8Array, width: number, height: number, level = 6): Uint8Array {
+  return encodePngBuffer(rgba, width, height, level);
+}

package/vendor/wajha/export/types.ts

@@ -0,0 +1,60 @@
+/** Shapes shared by the export modules; re-exported from `./index`. */
+import type { FamilyId, LangCode, Project } from '../model/types';
+type ExportTarget = string;
+
+export interface ExportJob {
+  family: FamilyId;
+  sizeId: string;
+  width: number;
+  height: number;
+  lang: LangCode;
+  slideIndex: number;
+  /** Relative POSIX path inside the export target, e.g. "App Store/en-US/iPhone 6.9/01.png". */
+  path: string;
+}
+
+export interface ExportWarning {
+  kind: 'missing-screenshot' | 'text-overflow' | 'too-many-slides' | 'no-locale-code';
+  message: string;
+  slideIndex?: number;
+  family?: FamilyId;
+  lang?: LangCode;
+}
+
+export interface ExportPlan {
+  jobs: ExportJob[];
+  warnings: ExportWarning[];
+}
+
+export interface ExportProgress {
+  done: number;
+  total: number;
+  current: ExportJob | null;
+}
+
+export interface ExportReport {
+  written: number;
+  failed: { job: ExportJob; error: string }[];
+  cancelled: boolean;
+  target: ExportTarget;
+  ms: number;
+}
+
+export interface RunExportOptions {
+  plan: ExportPlan;
+  target: ExportTarget;
+  format: 'png' | 'jpeg';
+  jpegQuality: number;
+  /** Renders one job to encoded file bytes (provided by the runtime). */
+  renderJob(job: ExportJob, format: 'png' | 'jpeg', jpegQuality: number): Promise<Uint8Array>;
+  write(target: ExportTarget, path: string, data: Uint8Array): Promise<void>;
+  onProgress?(p: ExportProgress): void;
+  signal?: AbortSignal;
+}
+
+export interface CsvImportResult {
+  project: Project;
+  updatedCells: number;
+  addedLanguages: LangCode[];
+  skippedRows: number;
+}