@archastro/astroshot-review 0.2.1

package/dist/data/store.js

@@ -0,0 +1,408 @@
+/**
+ * The tray's model: every shot and friction log under the roots, newest
+ * arrival first, kept fresh by the filesystem watcher, with the review
+ * actions the UI exposes. Mutations run one at a time so a rescan and a
+ * live event can never interleave.
+ */
+import path from "node:path";
+import { LOG_FILE, loadFrictionLogs } from "./friction.js";
+import { HashCache } from "./hash-cache.js";
+import { loadIndex, reconcileArrivalOrder, saveIndex } from "./index-cache.js";
+import { MAX_SCAN_DEPTH, frictionLogsDir } from "./paths.js";
+import { addComment, markSeen } from "./review-store.js";
+import { findAstroshotDirs, rebuildShot, scanFeatureDir, scanTree } from "./scan.js";
+import { watchRoots } from "./watcher.js";
+/** Depth of the quick pass that finds repo-level trees almost instantly. */
+export const SHALLOW_DEPTH = 3;
+/** A deep walk this recent is skipped at startup; `r` always forces one. */
+export const FULL_SCAN_TTL_MS = 30 * 60 * 1000;
+export class ReviewStore {
+    state;
+    listeners = new Set();
+    trees = new Map();
+    shotsByPath = new Map();
+    arrivalOrder = [];
+    hashes;
+    watcher = null;
+    queue = Promise.resolve();
+    options;
+    index = null;
+    disposed = false;
+    saveTimer = null;
+    fullScanAt = null;
+    /** Arrival order frozen at scan start so batches do not reorder the stream. */
+    scanBaseOrder = null;
+    constructor(options) {
+        this.options = options;
+        this.hashes = new HashCache();
+        this.state = {
+            roots: options.roots,
+            shots: [],
+            frictionLogs: [],
+            treeCount: 0,
+            scanning: false,
+            phase: "idle",
+            watching: false,
+            unreadCount: 0,
+            lastEvent: null,
+            error: null,
+            revision: 0,
+        };
+    }
+    getState() {
+        return this.state;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    publish(patch = {}) {
+        this.state = { ...this.state, ...patch, revision: this.state.revision + 1 };
+        for (const listener of this.listeners)
+            listener();
+    }
+    log(message) {
+        this.options.onLog?.(message);
+    }
+    /** Serialize mutations. */
+    enqueue(task) {
+        const run = this.queue.then(task, task);
+        this.queue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async start() {
+        if (this.options.useIndex !== false) {
+            this.index = await loadIndex(this.options.roots, this.options.indexPath);
+            if (this.index) {
+                this.arrivalOrder = this.index.arrivalOrder;
+                this.hashes.seed(this.index.hashes);
+                this.fullScanAt = this.index.fullScanAt ?? null;
+            }
+        }
+        if (this.options.watch !== false) {
+            this.watcher = watchRoots(this.options.roots, (event) => void this.handleEvent(event), {
+                settleMs: this.options.settleMs,
+                onError: (root, error) => {
+                    this.log(`watch ${root}: ${error.message}`);
+                    this.publish({ watching: this.watcher?.supported ?? false, error: `watch: ${error.message}` });
+                },
+            });
+            this.publish({ watching: this.watcher.supported });
+        }
+        await this.rescan();
+    }
+    /**
+     * Warm scan from the index, a shallow walk for repo-level trees, then a
+     * deep walk when the index is stale (or when forced by the user).
+     */
+    rescan(options = {}) {
+        return this.enqueue(async () => {
+            const cachedDirs = this.index?.astroshotDirs ?? [];
+            const known = new Set();
+            this.scanBaseOrder = [...this.arrivalOrder];
+            if (cachedDirs.length > 0) {
+                this.publish({ scanning: true, phase: "warm" });
+                await this.scanTrees(cachedDirs);
+                for (const dir of cachedDirs)
+                    if (this.trees.has(dir))
+                        known.add(dir);
+                this.recompute();
+            }
+            const discover = async (maxDepth, phase) => {
+                this.publish({ scanning: true, phase });
+                const discovered = new Set();
+                const pending = [];
+                let flushing = Promise.resolve();
+                await findAstroshotDirs(this.options.roots, {
+                    maxDepth,
+                    concurrency: phase === "full" ? 6 : 16,
+                    onFound: (astroshotDir) => {
+                        discovered.add(astroshotDir);
+                        if (known.has(astroshotDir))
+                            return;
+                        known.add(astroshotDir);
+                        pending.push(astroshotDir);
+                        // Stream results into the tray while the walk continues.
+                        flushing = flushing.then(async () => {
+                            const batch = pending.splice(0, pending.length);
+                            if (batch.length === 0)
+                                return;
+                            await this.scanTrees(batch);
+                            this.recompute();
+                        });
+                    },
+                });
+                await flushing;
+                return discovered;
+            };
+            const shallow = await discover(SHALLOW_DEPTH, "shallow");
+            const stale = options.force ||
+                !this.fullScanAt ||
+                Date.now() - Date.parse(this.fullScanAt) > FULL_SCAN_TTL_MS ||
+                Number.isNaN(Date.parse(this.fullScanAt));
+            let complete = shallow;
+            if (stale) {
+                complete = await discover(MAX_SCAN_DEPTH, "full");
+                this.fullScanAt = new Date().toISOString();
+            }
+            // Trees that vanished from disk leave the stream; cached deep trees
+            // survive a shallow-only start because they were re-verified above.
+            for (const dir of [...this.trees.keys()]) {
+                if (!complete.has(dir) && (stale || !cachedDirs.includes(dir)))
+                    this.trees.delete(dir);
+            }
+            // Cached trees may have changed while the tray was closed.
+            await this.scanTrees(cachedDirs.filter((dir) => this.trees.has(dir)));
+            this.recompute();
+            this.scanBaseOrder = null;
+            this.publish({ scanning: false, phase: "idle" });
+            this.scheduleSave();
+        });
+    }
+    async scanTrees(dirs) {
+        const concurrency = 6;
+        let cursor = 0;
+        const worker = async () => {
+            while (cursor < dirs.length) {
+                const dir = dirs[cursor++];
+                try {
+                    const tree = await scanTree(dir, this.hashes);
+                    this.trees.set(dir, tree);
+                    this.watcher?.watchTree(dir);
+                }
+                catch (error) {
+                    this.log(`scan ${dir}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                if (cursor % 8 === 0)
+                    this.recompute();
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(concurrency, dirs.length) }, worker));
+    }
+    /** Rebuild the flat, ordered shot and friction lists from the trees. */
+    recompute() {
+        const all = [];
+        const frictionLogs = [];
+        for (const tree of this.trees.values()) {
+            all.push(...tree.shots);
+            frictionLogs.push(...tree.frictionLogs);
+        }
+        this.shotsByPath.clear();
+        for (const shot of all)
+            this.shotsByPath.set(shot.path, shot);
+        this.arrivalOrder = reconcileArrivalOrder(this.scanBaseOrder ?? this.arrivalOrder, all);
+        frictionLogs.sort((a, b) => b.updatedAt - a.updatedAt);
+        this.publish({
+            shots: this.orderedShots(),
+            frictionLogs,
+            treeCount: this.trees.size,
+        });
+    }
+    orderedShots() {
+        const shots = [];
+        for (const shotPath of this.arrivalOrder) {
+            const shot = this.shotsByPath.get(shotPath);
+            if (shot)
+                shots.push(shot);
+        }
+        return shots;
+    }
+    scheduleSave() {
+        if (this.options.useIndex === false)
+            return;
+        if (this.saveTimer)
+            clearTimeout(this.saveTimer);
+        this.saveTimer = setTimeout(() => {
+            this.saveTimer = null;
+            void this.saveIndexNow();
+        }, 500);
+        this.saveTimer.unref();
+    }
+    async saveIndexNow() {
+        this.hashes.retain(new Set(this.shotsByPath.keys()), (filePath) => filePath.endsWith("log.jsonl"));
+        const document = {
+            version: 1,
+            roots: this.options.roots,
+            astroshotDirs: [...this.trees.keys()].sort(),
+            arrivalOrder: this.arrivalOrder,
+            hashes: this.hashes.toJSON(),
+            updatedAt: new Date().toISOString(),
+            fullScanAt: this.fullScanAt ?? undefined,
+        };
+        try {
+            await saveIndex(document, this.options.indexPath);
+            this.index = document;
+        }
+        catch (error) {
+            this.log(`index save: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    handleEvent(event) {
+        return this.enqueue(async () => {
+            try {
+                switch (event.kind) {
+                    case "shot":
+                        await this.ingestShot(event);
+                        break;
+                    case "feature":
+                        await this.refreshFeature(event.featureDir, event.astroshotDir);
+                        break;
+                    case "friction":
+                        await this.refreshFriction(event.astroshotDir);
+                        break;
+                    case "tree":
+                        await this.refreshTree(event.astroshotDir);
+                        break;
+                }
+            }
+            catch (error) {
+                this.log(`event ${event.kind}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            this.scheduleSave();
+        });
+    }
+    treeFor(astroshotDir) {
+        const existing = this.trees.get(astroshotDir);
+        if (existing)
+            return existing;
+        const worktreePath = path.dirname(astroshotDir);
+        const tree = {
+            astroshotDir,
+            worktreePath,
+            worktree: path.basename(worktreePath),
+            shots: [],
+            frictionLogs: [],
+        };
+        this.trees.set(astroshotDir, tree);
+        return tree;
+    }
+    async ingestShot(event) {
+        const tree = this.treeFor(event.astroshotDir);
+        const shot = await rebuildShot(event.path, {
+            worktreePath: tree.worktreePath,
+            worktree: tree.worktree,
+            feature: path.basename(event.featureDir),
+            featureDir: event.featureDir,
+        }, this.hashes);
+        const wasKnown = this.shotsByPath.has(event.path);
+        tree.shots = tree.shots.filter((candidate) => candidate.path !== event.path);
+        if (!shot) {
+            // Image vanished: drop it everywhere.
+            this.shotsByPath.delete(event.path);
+            this.arrivalOrder = this.arrivalOrder.filter((entry) => entry !== event.path);
+            this.publish({ shots: this.orderedShots() });
+            return;
+        }
+        tree.shots.push(shot);
+        this.shotsByPath.set(shot.path, shot);
+        this.arrivalOrder = [shot.path, ...this.arrivalOrder.filter((entry) => entry !== shot.path)];
+        this.publish({
+            shots: this.orderedShots(),
+            treeCount: this.trees.size,
+            unreadCount: wasKnown ? this.state.unreadCount : this.state.unreadCount + 1,
+            lastEvent: { kind: wasKnown ? "updated-shot" : "new-shot", shot, at: Date.now() },
+        });
+    }
+    async refreshFeature(featureDir, astroshotDir) {
+        const tree = this.treeFor(astroshotDir);
+        const shots = await scanFeatureDir(featureDir, { worktreePath: tree.worktreePath, worktree: tree.worktree }, this.hashes);
+        const previous = new Set(tree.shots.filter((shot) => shot.featureDir === featureDir).map((shot) => shot.path));
+        tree.shots = [...tree.shots.filter((shot) => shot.featureDir !== featureDir), ...shots];
+        const fresh = shots.filter((shot) => !previous.has(shot.path));
+        this.recompute();
+        if (fresh.length > 0) {
+            const newest = fresh.sort((a, b) => b.capturedAt - a.capturedAt)[0];
+            this.publish({
+                unreadCount: this.state.unreadCount + fresh.length,
+                lastEvent: { kind: "new-shot", shot: newest, at: Date.now() },
+            });
+        }
+    }
+    async refreshFriction(astroshotDir) {
+        const tree = this.treeFor(astroshotDir);
+        tree.frictionLogs = await loadFrictionLogs(frictionLogsDir(astroshotDir), { worktreePath: tree.worktreePath, worktree: tree.worktree }, this.hashes);
+        this.recompute();
+    }
+    async refreshTree(astroshotDir) {
+        try {
+            const tree = await scanTree(astroshotDir, this.hashes);
+            if (tree.shots.length === 0 && tree.frictionLogs.length === 0) {
+                this.trees.delete(astroshotDir);
+            }
+            else {
+                this.trees.set(astroshotDir, tree);
+            }
+        }
+        catch {
+            this.trees.delete(astroshotDir);
+        }
+        this.recompute();
+    }
+    /** The user opened the stream: clear the unread badge. */
+    markOpened() {
+        if (this.state.unreadCount !== 0)
+            this.publish({ unreadCount: 0 });
+    }
+    async markShotSeen(shot, comment) {
+        await markSeen({ directory: shot.featureDir, fileName: shot.fileName, runId: shot.runId, targetPath: shot.path }, { comment });
+        return this.reloadShot(shot);
+    }
+    async addShotComment(shot, body) {
+        await addComment({ directory: shot.featureDir, fileName: shot.fileName, runId: shot.runId, targetPath: shot.path }, body);
+        return this.reloadShot(shot);
+    }
+    reloadShot(shot) {
+        return this.enqueue(async () => {
+            const tree = this.treeFor(path.dirname(shot.featureDir));
+            const rebuilt = await rebuildShot(shot.path, { worktreePath: shot.worktreePath, worktree: shot.worktree, feature: shot.feature, featureDir: shot.featureDir }, this.hashes);
+            if (!rebuilt)
+                return shot;
+            tree.shots = tree.shots.map((candidate) => (candidate.path === shot.path ? rebuilt : candidate));
+            if (!tree.shots.includes(rebuilt))
+                tree.shots.push(rebuilt);
+            this.shotsByPath.set(rebuilt.path, rebuilt);
+            // Sidecar writes for one shot also re-scope siblings on a run change.
+            this.publish({ shots: this.orderedShots() });
+            return rebuilt;
+        });
+    }
+    /** Mark many shots seen; failures are counted, never fatal. */
+    async markManySeen(shots) {
+        let ok = 0;
+        let failed = 0;
+        for (const shot of shots) {
+            try {
+                await this.markShotSeen(shot);
+                ok += 1;
+            }
+            catch {
+                failed += 1;
+            }
+        }
+        // Reload every touched feature so run resets propagate.
+        const features = new Map();
+        for (const shot of shots)
+            features.set(shot.featureDir, shot);
+        for (const shot of features.values()) {
+            await this.handleEvent({ kind: "feature", featureDir: shot.featureDir, astroshotDir: path.dirname(shot.featureDir) });
+        }
+        return { ok, failed };
+    }
+    async markFrictionRunSeen(log, run) {
+        if (!run.logPath)
+            throw new Error("This run has no log.jsonl to acknowledge");
+        await markSeen({ directory: run.directory, fileName: LOG_FILE, runId: run.runId, targetPath: run.logPath });
+        await this.handleEvent({ kind: "friction", astroshotDir: path.join(log.worktreePath, ".astroshot") });
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.watcher?.close();
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+            await this.saveIndexNow();
+        }
+    }
+}

package/dist/data/watcher.d.ts

@@ -0,0 +1,37 @@
+export type WatchEvent = {
+    kind: "shot";
+    path: string;
+    featureDir: string;
+    astroshotDir: string;
+} | {
+    kind: "feature";
+    featureDir: string;
+    astroshotDir: string;
+} | {
+    kind: "friction";
+    astroshotDir: string;
+} | {
+    kind: "tree";
+    astroshotDir: string;
+};
+export declare function classifyPath(fullPath: string): WatchEvent | null;
+export declare function eventKey(event: WatchEvent): string;
+export interface WatchOptions {
+    settleMs?: number;
+    onError?: (root: string, error: Error) => void;
+    /**
+     * Watch each root recursively. Cheap where the OS offers a single
+     * recursive stream (FSEvents on macOS, ReadDirectoryChangesW on Windows);
+     * elsewhere every directory costs an inotify watch, so only discovered
+     * `.astroshot` trees are watched and new trees need a rescan.
+     */
+    recursiveRoots?: boolean;
+}
+export interface RootWatcher {
+    close(): void;
+    /** Whether at least one watch is live. */
+    readonly supported: boolean;
+    /** Follow one `.astroshot` tree (no-op when roots are watched recursively). */
+    watchTree(astroshotDir: string): void;
+}
+export declare function watchRoots(roots: string[], onEvent: (event: WatchEvent) => void, options?: WatchOptions): RootWatcher;

package/dist/data/watcher.js

@@ -0,0 +1,126 @@
+/**
+ * Recursive filesystem watching over the roots, routed the same way the app
+ * routes FSEvents: image files ingest individually, sidecars refresh their
+ * feature, friction-log paths refresh the whole friction namespace, and new
+ * or vanished `.astroshot` directories rescan the tree.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { ASTROSHOT_DIR, FRICTION_DIR, VIDEO_EXTENSIONS, extensionOf, isImageFile } from "./paths.js";
+export function classifyPath(fullPath) {
+    const parts = fullPath.split(path.sep);
+    const index = parts.indexOf(ASTROSHOT_DIR);
+    if (index === -1)
+        return null;
+    const astroshotDir = parts.slice(0, index + 1).join(path.sep);
+    const rest = parts.slice(index + 1);
+    if (rest.length === 0)
+        return { kind: "tree", astroshotDir };
+    if (rest[0] === FRICTION_DIR)
+        return { kind: "friction", astroshotDir };
+    if (rest[0].startsWith("."))
+        return null;
+    const featureDir = path.join(astroshotDir, rest[0]);
+    if (rest.length === 1)
+        return { kind: "feature", featureDir, astroshotDir };
+    if (rest.length === 2) {
+        const name = rest[1];
+        if (name === "manifest.json" || name === "review.json")
+            return { kind: "feature", featureDir, astroshotDir };
+        if (isImageFile(name))
+            return { kind: "shot", path: fullPath, featureDir, astroshotDir };
+        if (VIDEO_EXTENSIONS.includes(extensionOf(name)))
+            return { kind: "feature", featureDir, astroshotDir };
+    }
+    return null;
+}
+export function eventKey(event) {
+    switch (event.kind) {
+        case "shot":
+            return `shot:${event.path}`;
+        case "feature":
+            return `feature:${event.featureDir}`;
+        case "friction":
+            return `friction:${event.astroshotDir}`;
+        case "tree":
+            return `tree:${event.astroshotDir}`;
+    }
+}
+export function watchRoots(roots, onEvent, options = {}) {
+    const settleMs = options.settleMs ?? 250;
+    const recursiveRoots = options.recursiveRoots ?? (process.platform === "darwin" || process.platform === "win32");
+    const timers = new Map();
+    const pending = new Map();
+    const watchers = new Map();
+    let supported = true;
+    const attach = (target, recursive) => {
+        if (watchers.has(target))
+            return true;
+        try {
+            const watcher = fs.watch(target, { recursive, persistent: false }, (_type, filename) => {
+                if (!filename)
+                    return;
+                const fullPath = path.join(target, filename.toString());
+                const event = classifyPath(fullPath);
+                if (event)
+                    schedule(event);
+            });
+            watcher.on("error", (error) => {
+                watchers.delete(target);
+                watcher.close();
+                if (watchers.size === 0)
+                    supported = false;
+                options.onError?.(target, error);
+            });
+            watchers.set(target, watcher);
+            return true;
+        }
+        catch (error) {
+            options.onError?.(target, error instanceof Error ? error : new Error(String(error)));
+            return false;
+        }
+    };
+    const schedule = (event) => {
+        const key = eventKey(event);
+        pending.set(key, event);
+        const existing = timers.get(key);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            timers.delete(key);
+            const queued = pending.get(key);
+            pending.delete(key);
+            if (queued)
+                onEvent(queued);
+        }, settleMs);
+        timer.unref();
+        timers.set(key, timer);
+    };
+    let attached = 0;
+    for (const root of roots) {
+        if (attach(root, recursiveRoots))
+            attached += 1;
+    }
+    supported = attached > 0;
+    return {
+        get supported() {
+            return supported;
+        },
+        watchTree(astroshotDir) {
+            if (recursiveRoots)
+                return;
+            if (attach(astroshotDir, true))
+                supported = true;
+            // A sibling `.astroshot` appearing next to a known tree shows up too.
+            attach(path.dirname(astroshotDir), false);
+        },
+        close() {
+            for (const timer of timers.values())
+                clearTimeout(timer);
+            timers.clear();
+            for (const watcher of watchers.values())
+                watcher.close();
+            watchers.clear();
+        },
+    };
+}

package/dist/images/halfblocks.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Fallback renderer for terminals without a graphics protocol: two pixels per
+ * cell using the upper-half block and truecolor foreground/background.
+ */
+export interface CellArtOptions {
+    width: number;
+    height: number;
+    rgb: Buffer;
+}
+export declare function rgbToHalfBlockLines(options: CellArtOptions): string[];

package/dist/images/halfblocks.js

@@ -0,0 +1,21 @@
+/**
+ * Fallback renderer for terminals without a graphics protocol: two pixels per
+ * cell using the upper-half block and truecolor foreground/background.
+ */
+export function rgbToHalfBlockLines(options) {
+    const { width, height, rgb } = options;
+    const lines = [];
+    for (let y = 0; y < height; y += 2) {
+        let line = "";
+        for (let x = 0; x < width; x += 1) {
+            const top = (y * width + x) * 3;
+            const bottomRow = y + 1 < height ? y + 1 : y;
+            const bottom = (bottomRow * width + x) * 3;
+            line += `\x1b[38;2;${rgb[top]};${rgb[top + 1]};${rgb[top + 2]}m` +
+                `\x1b[48;2;${rgb[bottom]};${rgb[bottom + 1]};${rgb[bottom + 2]}m▀`;
+        }
+        line += "\x1b[0m";
+        lines.push(line);
+    }
+    return lines;
+}

package/dist/images/png.d.ts

@@ -0,0 +1,14 @@
+export interface ImageSize {
+    width: number;
+    height: number;
+}
+/** Read width/height from a PNG's IHDR chunk without decoding pixels. */
+export declare function readPngSize(bytes: Buffer): ImageSize | null;
+/** Read just enough of a file to learn its pixel size. */
+export declare function readPngSizeFromFile(filePath: string): Promise<ImageSize | null>;
+export declare function isPngPath(filePath: string): boolean;
+/**
+ * Largest box that fits inside `bounds` while keeping `source`'s aspect
+ * ratio. Never scales up: a small source keeps its own size.
+ */
+export declare function fitInside(source: ImageSize, bounds: ImageSize): ImageSize;

package/dist/images/png.js

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+/** Read width/height from a PNG's IHDR chunk without decoding pixels. */
+export function readPngSize(bytes) {
+    if (bytes.length < 24)
+        return null;
+    if (!bytes.subarray(0, 8).equals(PNG_SIGNATURE))
+        return null;
+    if (bytes.toString("ascii", 12, 16) !== "IHDR")
+        return null;
+    const width = bytes.readUInt32BE(16);
+    const height = bytes.readUInt32BE(20);
+    if (width === 0 || height === 0)
+        return null;
+    return { width, height };
+}
+/** Read just enough of a file to learn its pixel size. */
+export async function readPngSizeFromFile(filePath) {
+    const handle = await fs.promises.open(filePath, "r");
+    try {
+        const header = Buffer.alloc(32);
+        const { bytesRead } = await handle.read(header, 0, 32, 0);
+        return readPngSize(header.subarray(0, bytesRead));
+    }
+    finally {
+        await handle.close();
+    }
+}
+export function isPngPath(filePath) {
+    return /\.png$/i.test(filePath);
+}
+/**
+ * Largest box that fits inside `bounds` while keeping `source`'s aspect
+ * ratio. Never scales up: a small source keeps its own size.
+ */
+export function fitInside(source, bounds) {
+    if (source.width <= bounds.width && source.height <= bounds.height) {
+        return { width: source.width, height: source.height };
+    }
+    const scale = Math.min(bounds.width / source.width, bounds.height / source.height);
+    return {
+        width: Math.max(1, Math.round(source.width * scale)),
+        height: Math.max(1, Math.round(source.height * scale)),
+    };
+}