artcraft: drop worker base-bitmap cache so rapid HistoryStack navigation doesn't lag

Each base change triggered an immediate clone+postMessage on top of the
already-debounced pre-bake, costing ~5-15ms per click through history.
Folding the base back into each composite call (atomic per-message) lets
the debounced pre-bake absorb the clone cost on its own schedule and
sidesteps a race where concurrent bakes with different bases could leave
a stale base in the worker-side cache.
This commit is contained in:
Tanish Manku committed 2026-05-09 13:49:37 -07:00
1 parent bbdde58b92
commit 5d8e22afb2
3 files changed
+25 -77

No files matched your search

@@ -32,7 +32,6 @@ import { EncodeImageBitmapToBase64 } from "./utilities/EncodeImageBitmapToBase64
import {
compositeInWorker,
maskInWorker,
setBaseBitmapInWorker,
} from "./utilities/generatePipeline";
import { RefImage, usePrompt2DStore } from "@storyteller/ui-promptbox";
import { PromptsApi } from "@storyteller/api";
@@ -599,13 +598,23 @@ const PageDraw = ({ adapter }: PageDrawProps) => {
pixelRatio: 1 / stageRef.current.scaleX(),
});
// Move the marker pixels off the main thread. The base bitmap is already
// cached in the worker (synced via setBaseBitmapInWorker on baseImageBitmap
// changes), so we only need to send the marker on each bake.
const markerBitmap = await createImageBitmap(markerLayerCanvas);
// Move the marker pixels and a clone of the base bitmap off the main
// thread. The worker handles the exact-size resize, compositing, and PNG
// encoding. Each bake carries its own base atomically; we don't try to
// cache it across bakes — pre-baking on idle (see runCompositeBake) hides
// the per-bake clone cost on the click path, and the atomic-per-call
// contract avoids any race where concurrent bakes leave a stale base in a
// worker-side cache.
const [markerBitmap, baseBitmap] = await Promise.all([
createImageBitmap(markerLayerCanvas),
baseImageBitmap
? createImageBitmap(baseImageBitmap)
: Promise.resolve(undefined),
]);
const blob = await compositeInWorker({
markerBitmap,
baseBitmap,
width,
height,
});
@@ -613,33 +622,6 @@ const PageDraw = ({ adapter }: PageDrawProps) => {
return new File([blob], `${uuid}.png`, { type: "image/png" });
}, [baseImageBitmap, baseImageInfo]);
// Push the current base bitmap into the worker's cache whenever it changes.
// The worker keeps it across generates so we don't pay createImageBitmap +
// postMessage(transfer) on every Generate click.
useEffect(() => {
if (!baseImageBitmap) {
setBaseBitmapInWorker(undefined).catch((err) =>
console.error("Failed to clear worker base bitmap:", err),
);
return;
}
let cancelled = false;
createImageBitmap(baseImageBitmap)
.then((clone) => {
if (cancelled) {
clone.close();
return;
}
return setBaseBitmapInWorker(clone);
})
.catch((err) =>
console.error("Failed to send worker base bitmap:", err),
);
return () => {
cancelled = true;
};
}, [baseImageBitmap]);
// Pre-bake the composite File on idle so the Generate click path is
// near-instant in the common case (user pauses >300ms before clicking). The
// bake itself still freezes the main thread for the Konva readback, but it
@@ -1,13 +1,12 @@
import GeneratePipelineWorker from "./generatePipeline.worker.ts?worker&inline";
type SetBaseOk = { id: number; ok: true; type: "setBase" };
type CompositeOk = { id: number; ok: true; type: "composite"; blob: Blob };
type MaskOk = { id: number; ok: true; type: "mask"; bytes: Uint8Array };
type WorkerErr = { id: number; ok: false; error: string };
type WorkerResponse = SetBaseOk | CompositeOk | MaskOk | WorkerErr;
type WorkerResponse = CompositeOk | MaskOk | WorkerErr;
type Pending = {
resolve: (value: SetBaseOk | CompositeOk | MaskOk) => void;
resolve: (value: CompositeOk | MaskOk) => void;
reject: (err: Error) => void;
};
@@ -40,34 +39,16 @@ const ensureWorker = (): Worker => {
return worker;
};
export const setBaseBitmapInWorker = (
baseBitmap?: ImageBitmap,
): Promise<void> => {
const worker = ensureWorker();
const id = nextId++;
const transfer: Transferable[] = baseBitmap ? [baseBitmap] : [];
return new Promise<void>((resolve, reject) => {
pendingRequests.set(id, {
resolve: (res) => {
if (res.type !== "setBase") {
reject(new Error("Unexpected response type for setBase"));
return;
}
resolve();
},
reject,
});
worker.postMessage({ id, type: "setBase", baseBitmap }, transfer);
});
};
export const compositeInWorker = (params: {
markerBitmap: ImageBitmap;
baseBitmap?: ImageBitmap;
width: number;
height: number;
}): Promise<Blob> => {
const worker = ensureWorker();
const id = nextId++;
const transfer: Transferable[] = [params.markerBitmap];
if (params.baseBitmap) transfer.push(params.baseBitmap);
return new Promise<Blob>((resolve, reject) => {
pendingRequests.set(id, {
resolve: (res) => {
@@ -79,9 +60,7 @@ export const compositeInWorker = (params: {
},
reject,
});
worker.postMessage({ id, type: "composite", ...params }, [
params.markerBitmap,
]);
worker.postMessage({ id, type: "composite", ...params }, transfer);
});
};
@@ -1,15 +1,11 @@
/// <reference lib="webworker" />
type WorkerRequest =
| {
id: number;
type: "setBase";
baseBitmap?: ImageBitmap;
}
| {
id: number;
type: "composite";
markerBitmap: ImageBitmap;
baseBitmap?: ImageBitmap;
width: number;
height: number;
}
@@ -22,16 +18,10 @@ type WorkerRequest =
};
type WorkerResponse =
| { id: number; ok: true; type: "setBase" }
| { id: number; ok: true; type: "composite"; blob: Blob }
| { id: number; ok: true; type: "mask"; bytes: Uint8Array }
| { id: number; ok: false; error: string };
// The base image rarely changes (only when the user picks a new starting image
// or lands on a generation result). Caching it here avoids cloning + transferring
// it on every Generate click.
let cachedBaseBitmap: ImageBitmap | null = null;
const ctxOf = (canvas: OffscreenCanvas): OffscreenCanvasRenderingContext2D => {
const ctx = canvas.getContext("2d");
if (!ctx) throw new Error("Failed to get OffscreenCanvas 2d context");
@@ -48,15 +38,12 @@ const post = (response: WorkerResponse, transfer: Transferable[] = []) => {
self.addEventListener("message", async (event: MessageEvent<WorkerRequest>) => {
const req = event.data;
try {
if (req.type === "setBase") {
cachedBaseBitmap?.close();
cachedBaseBitmap = req.baseBitmap ?? null;
post({ id: req.id, ok: true, type: "setBase" });
} else if (req.type === "composite") {
if (req.type === "composite") {
const canvas = new OffscreenCanvas(req.width, req.height);
const ctx = ctxOf(canvas);
if (cachedBaseBitmap) {
ctx.drawImage(cachedBaseBitmap, 0, 0, req.width, req.height);
if (req.baseBitmap) {
ctx.drawImage(req.baseBitmap, 0, 0, req.width, req.height);
req.baseBitmap.close();
} else {
ctx.fillStyle = "white";
ctx.fillRect(0, 0, req.width, req.height);