AI-native design editor. Open-source Figma alternative.
fix: keep tiles on canvas resize and show opened pages only when fully drawn (#1753)
Danila Poyarkov4716fcdd93cd
diff --git a/changes/1753/breaking.md b/changes/1753/breaking.mdnew file mode 100644index 000000000..5957c1816--- /dev/null+++ b/changes/1753/breaking.md@@ -0,0 +1 @@+- `useCanvas` from `@open-pencil/vue/canvas/surface` no longer takes `onPresented`; listen for the editor's `render:presented` event with `editor.onEditorEvent('render:presented', …)`, which fires once a frame shows the whole visible scene (#1753).diff --git a/changes/1753/fixed.md b/changes/1753/fixed.mdnew file mode 100644index 000000000..90f73d282--- /dev/null+++ b/changes/1753/fixed.md@@ -0,0 +1 @@+- Opening a document keeps the loader up until its page is fully drawn where it opens, instead of showing the canvas while it still fills in (#1753).diff --git a/changes/1753/performance.md b/changes/1753/performance.mdnew file mode 100644index 000000000..d0648dca3--- /dev/null+++ b/changes/1753/performance.md@@ -0,0 +1 @@+- Resizing the canvas, such as dragging a panel, keeps what is already drawn and renders only the newly exposed edge, instead of blanking and redrawing the whole scene (#1753).diff --git a/packages/core/src/canvas/images/state.ts b/packages/core/src/canvas/images/state.tsindex 378c4902b..e9cde5696 100644--- a/packages/core/src/canvas/images/state.ts+++ b/packages/core/src/canvas/images/state.ts@@ -12,7 +12,7 @@ export interface RendererImages {* Images drawn in place of stored ones while they play, such as a shader's live frames, each* with the surface whose GL context holds its texture.*/- readonly live: Map<string, { image: Image; surface: Surface }>+ readonly live: Map<string, { readonly image: Image; surface: Surface }>/** The document and page whose images the cache and previews hold. */memoryGraph: SceneGraph | nullmemoryPage: string | nulldiff --git a/packages/core/src/canvas/renderer.ts b/packages/core/src/canvas/renderer.tsindex 24cfc7982..157afa1d9 100644--- a/packages/core/src/canvas/renderer.ts+++ b/packages/core/src/canvas/renderer.ts@@ -409,10 +409,21 @@ export class SkiaRenderer {return RendererFonts.prepareForExport(this, graph, pageId, nodeIds)}- replaceSurface(surface: Surface): void {- this.tiledScene.destroy()- // Live textures belong to the old surface's context, so they go before it does.- releaseLiveImages(this)+ /**+ * Draws into `surface` from now on. A surface on the same GPU context, such as the canvas+ * resized, keeps the rendered tiles and live textures, which belong to the context; only+ * newly exposed tiles render. A new context starts them over.+ */+ replaceSurface(surface: Surface, { sameContext = false }: { sameContext?: boolean } = {}): void {+ if (sameContext) {+ for (const live of this.images.live.values()) {+ if (live.surface === this.surface) live.surface = surface+ }+ } else {+ this.tiledScene.destroy()+ // Live textures belong to the old surface's context, so they go before it does.+ releaseLiveImages(this)+ }this.surface.delete()this.surface = surfacethis.invalidateScenePicture()diff --git a/packages/core/src/canvas/renderer/pipeline.ts b/packages/core/src/canvas/renderer/pipeline.tsindex 44b7e93c6..37b2c38b1 100644--- a/packages/core/src/canvas/renderer/pipeline.ts+++ b/packages/core/src/canvas/renderer/pipeline.ts@@ -306,7 +306,11 @@ export function render()if (layer !== 'overlays') {- if (requiresUncachedSceneRender) r.tiledScenePending = false+ // Drawn directly, the whole scene is on screen this frame.+ if (requiresUncachedSceneRender) {+ r.tiledScenePending = false+ r.tiledSceneCovered = true+ }canvas.save()canvas.scale(r.dpr, r.dpr)diff --git a/packages/core/src/editor/create.ts b/packages/core/src/editor/create.tsindex 95c84867b..129b5f36c 100644--- a/packages/core/src/editor/create.ts+++ b/packages/core/src/editor/create.ts@@ -71,7 +71,8 @@ import type {EditorEventName,EditorEvents,EditorOptions,- EditorState+ EditorState,+ RenderVersions} from './types'import { createUndoActions } from './undo'import { createVariableActions } from './variables'@@ -151,6 +152,11 @@ export function createEditor(options?: EditorOptions) {state.sceneVersion++}+ /** A canvas showed a frame of `versions` with nothing left to fill in. */+ function reportPresented(versions: RenderVersions) {+ emitEditorEvent('render:presented', versions)+ }+function requestRepaint() {state.renderVersion++emitNavigationTrace('render:requested', {@@ -456,6 +462,7 @@ export function createEditor(options?: EditorOptions) {requestRefresh,textSelectionChanged,requestRepaint,+ reportPresented,onEditorEvent,setCanvasKit,setNavigationPhase,diff --git a/packages/core/src/editor/index.ts b/packages/core/src/editor/index.tsindex 7d7f2c1b9..f329b13a2 100644--- a/packages/core/src/editor/index.ts+++ b/packages/core/src/editor/index.ts@@ -78,6 +78,7 @@ export type {EditorContext,EditorEventName,EditorEvents,+ RenderVersions,EditorOptions,EditorState,EditorSharedState,diff --git a/packages/core/src/editor/types.ts b/packages/core/src/editor/types.tsindex b8de39e7a..be6c42ed8 100644--- a/packages/core/src/editor/types.ts+++ b/packages/core/src/editor/types.ts@@ -217,9 +217,24 @@ export type FigmaClipboardImageResolver = (hashes: string[]) => Promise<ReadonlyMap<string, Uint8Array>>+/**+ * What a frame draws: `sceneVersion` counts the document's content, `renderVersion` everything+ * on screen, the viewport included.+ */+export interface RenderVersions {+ renderVersion: number+ sceneVersion: number+}+export interface EditorEvents extends SceneGraphEvents {- 'render:requested': (versions: { renderVersion: number; sceneVersion: number }) => void- 'repaint:requested': (versions: { renderVersion: number; sceneVersion: number }) => void+ 'render:requested': (versions: RenderVersions) => void+ 'repaint:requested': (versions: RenderVersions) => void+ /**+ * A canvas drawing the editor's own state showed a frame of these versions with the whole+ * visible scene on screen, nothing left to fill in. Overlay-only canvases and split panes+ * showing another view do not report.+ */+ 'render:presented': (versions: RenderVersions) => void'graph:replaced': (graph: SceneGraph) => void'document:color-space-changed': (colorSpace: DocumentColorSpace) => void'document:libraries-changed': () => voiddiff --git a/packages/docs/.vitepress/theme/landing/stage/StageCanvas.vue b/packages/docs/.vitepress/theme/landing/stage/StageCanvas.vueindex cb5a817a9..b97222ea9 100644--- a/packages/docs/.vitepress/theme/landing/stage/StageCanvas.vue+++ b/packages/docs/.vitepress/theme/landing/stage/StageCanvas.vue@@ -37,9 +37,7 @@ const { hitTestSectionTitle, hitTestComponentLabel, hitTestFrameTitle, hitTestIsshowRulers: false,shouldSuspendRender,onReady: store.markCanvasReady,- onViewportResize: (width, height) => store.setViewportSize(width, height),- onPresented: ({ sceneVersion }) =>- store.preparationController.acknowledgePresentation(sceneVersion)+ onViewportResize: (width, height) => store.setViewportSize(width, height)})const { cursorOverride } = useCanvasInput(diff --git a/packages/docs/.vitepress/theme/landing/stage/useStageDocument.ts b/packages/docs/.vitepress/theme/landing/stage/useStageDocument.tsindex f0dcc729a..0ba567956 100644--- a/packages/docs/.vitepress/theme/landing/stage/useStageDocument.ts+++ b/packages/docs/.vitepress/theme/landing/stage/useStageDocument.ts@@ -42,10 +42,7 @@ export function useStageDocument(scene: SceneBuilder) {// As the app does when it opens a page: render, and finish once that frame is on screen,// so whatever stands in for the stage until now never gives way to an empty canvas.preparation.update({ phase: 'preparing-render' })- await store.preparationController.waitForPresentation(- preparation.id,- store.state.sceneVersion- )+ await store.preparationController.waitForPresentation(preparation.id, store.state)preparation.complete()ready.value = true} catch (error) {diff --git a/packages/vue/src/canvas/surface/lifecycle.ts b/packages/vue/src/canvas/surface/lifecycle.tsindex 9462b6641..ceb29e800 100644--- a/packages/vue/src/canvas/surface/lifecycle.ts+++ b/packages/vue/src/canvas/surface/lifecycle.ts@@ -147,9 +147,18 @@ export function createCanvasSurfaceManager({return true}- function acknowledgePresentation() {+ /**+ * Reports the frame as shown once the whole visible scene is on it. A scene frame with tiles+ * still to draw is not: a loader waiting on it would give way to a canvas that then fills in.+ * Only a canvas drawing the editor's own state reports, since the versions are the editor's:+ * a split pane showing another view, perhaps another page, says nothing about this one.+ */+ function reportPresented(renderer: SkiaRenderer) {+ const layer = options?.layer ?? 'full'+ if (layer === 'overlays' || (layer === 'scene' && !renderer.tiledSceneCovered)) returnconst renderedState = options?.getRenderState?.() ?? editor.state- options?.onPresented?.({+ if (renderedState !== editor.state) return+ editor.reportPresented({renderVersion: renderedState.renderVersion,sceneVersion: renderedState.sceneVersion})@@ -181,7 +190,7 @@ export function createCanvasSurfaceManager({)renderLoop.markRendered()options?.onFrame?.({ panX: view.panX, panY: view.panY, zoom: view.zoom })- acknowledgePresentation()+ reportPresented(state.renderer)if (options?.layer === 'scene' && tileWorkPending(state.renderer)) {renderLoop.markDirty()}@@ -218,8 +227,13 @@ export function createCanvasSurfaceManager({createSurface(canvas, { reloadFonts: true })return}- state.renderer.presentationColorSpace = result.presentation ?? 'srgb'- state.renderer.replaceSurface(surface)+ // Tiles keep the colours they were recorded in, so a resize that changes the presentation+ // color space starts them over like a new context.+ const presentation = result.presentation ?? 'srgb'+ const sameContext =+ result.glHandle === null && state.renderer.presentationColorSpace === presentation+ state.renderer.presentationColorSpace = presentation+ state.renderer.replaceSurface(surface, { sameContext })renderNow()}diff --git a/packages/vue/src/canvas/surface/types.ts b/packages/vue/src/canvas/surface/types.tsindex 5de373786..e765fa93e 100644--- a/packages/vue/src/canvas/surface/types.ts+++ b/packages/vue/src/canvas/surface/types.ts@@ -11,7 +11,6 @@ export type CanvasRenderLayer = 'full' | 'scene' | 'overlays'export interface UseCanvasOptions {shouldSuspendRender?: () => boolean- onPresented?: (versions: { renderVersion: number; sceneVersion: number }) => void/*** Selects which render layer this canvas owns.*/diff --git a/src/app/document/io/read.ts b/src/app/document/io/read.tsindex 90204b8a7..a4225e6fd 100644--- a/src/app/document/io/read.ts+++ b/src/app/document/io/read.ts@@ -68,6 +68,14 @@ export function createOpenActions({await fitCurrentPageToViewport()load.update({ phase: 'preparing-render', detail: state.documentName })editor.requestRender()+ // The document is open by now: a canvas that cannot show it fails the render, not the read.+ await preparationController+ .waitForPresentation(load.id, editor.state)+ .catch((error: unknown) => {+ const message = error instanceof Error ? error.message : String(error)+ load.fail({ code: 'render-failed', message, retryable: true })+ toast.error(notificationMessages.get().operationFailed({ error: message }))+ })succeeded = true} catch (e) {if (load.signal.aborted) returndiff --git a/src/app/editor/fonts/status.ts b/src/app/editor/fonts/status.tsindex 69cca49c5..b40d0b4a4 100644--- a/src/app/editor/fonts/status.ts+++ b/src/app/editor/fonts/status.ts@@ -73,10 +73,7 @@ export function useDocumentFontStatus() {preparation.update({ phase: 'preparing-render' })editor.requestRender()if (editor.renderer) {- await editor.preparationController.waitForPresentation(- preparation.id,- editor.state.sceneVersion- )+ await editor.preparationController.waitForPresentation(preparation.id, editor.state)}refresh()succeeded = truediff --git a/src/app/editor/preparation/controller.ts b/src/app/editor/preparation/controller.tsindex 4bcf0959a..e1e38a842 100644--- a/src/app/editor/preparation/controller.ts+++ b/src/app/editor/preparation/controller.ts@@ -1,5 +1,7 @@import { TimeoutError } from 'es-toolkit/error'+import type { Editor, RenderVersions } from '@open-pencil/core'+import type { EditorPreparationEventEmitter } from '@/app/editor/preparation/events'import type {BeginEditorPreparation,@@ -13,7 +15,7 @@ import type { AppEditorState } from '@/app/editor/session/types'const PRESENTATION_TIMEOUT_MS = 10_000interface PresentationWaiter {- sceneVersion: number+ versions: RenderVersionsresolve: () => voidreject: (error: Error) => void/** Runs only while a canvas shows the document, which is the only place it is presented. */@@ -26,12 +28,19 @@ interface PresentationWaiter {export interface EditorPreparationControllerOptions {presentationTimeoutMs?: number+ /** The editor whose canvases report frames shown, through `render:presented`. */+ editor?: Pick<Editor, 'onEditorEvent'>}export interface EditorPreparationController {begin(options: BeginEditorPreparation): EditorPreparationHandle- acknowledgePresentation(sceneVersion: number): void- waitForPresentation(id: number, sceneVersion: number): Promise<void>+ /** A frame of these versions is fully shown; `render:presented` reports it from canvases. */+ acknowledgePresentation(versions: RenderVersions): void+ /**+ * Resolves once a frame at least as new as `versions` in both is fully drawn. The versions are+ * read when called, so an editor's live state can be passed.+ */+ waitForPresentation(id: number, versions: RenderVersions): Promise<void>/*** A canvas started showing the document; returns its detach. A tab in the background has no* canvas, so its scene waits to be presented until the tab is shown, without timing out.@@ -54,7 +63,10 @@ export function createEditorPreparationController(let nextId = 0let activeAbort: AbortController | null = nulllet activeCancel: ((reason: EditorPreparationCancelReason) => void) | null = null- let presentedSceneVersion = -1+ /** The newest frame shown; its two versions came together, so one frame meets a wait. */+ let presented: RenderVersions = { renderVersion: -1, sceneVersion: -1 }+ const covers = (frame: RenderVersions, versions: RenderVersions) =>+ frame.renderVersion >= versions.renderVersion && frame.sceneVersion >= versions.sceneVersionlet canvases = 0let canvasFailure: Error | null = nullconst presentationWaiters = new Map<number, PresentationWaiter>()@@ -83,6 +95,18 @@ export function createEditorPreparationController(const isActive = (id: number) => state.preparation?.id === id+ function acknowledgePresentation(versions: RenderVersions) {+ presented = { renderVersion: versions.renderVersion, sceneVersion: versions.sceneVersion }+ for (const [id, waiter] of presentationWaiters) {+ if (covers(presented, waiter.versions)) settle(id, null)+ }+ }++ const stopPresentations = options.editor?.onEditorEvent(+ 'render:presented',+ acknowledgePresentation+ )+return {begin(options) {activeCancel?.('superseded')@@ -157,18 +181,13 @@ export function createEditorPreparationController(cancel}},- acknowledgePresentation(sceneVersion) {- presentedSceneVersion = Math.max(presentedSceneVersion, sceneVersion)- for (const [id, waiter] of presentationWaiters) {- if (waiter.sceneVersion <= presentedSceneVersion) settle(id, null)- }- },- waitForPresentation(id, sceneVersion) {- if (!isActive(id) || presentedSceneVersion >= sceneVersion) return Promise.resolve()+ acknowledgePresentation,+ waitForPresentation(id, versions) {+ if (!isActive(id) || covers(presented, versions)) return Promise.resolve()settle(id, null)return new Promise<void>((resolve, reject) => {const waiter: PresentationWaiter = {- sceneVersion,+ versions: { renderVersion: versions.renderVersion, sceneVersion: versions.sceneVersion },resolve,reject,timer: null,@@ -203,6 +222,7 @@ export function createEditorPreparationController(for (const id of presentationWaiters.keys()) settle(id, error)},dispose() {+ stopPresentations?.()activeCancel?.('tab-closed')activeAbort?.abort()activeAbort = nulldiff --git a/src/app/editor/session/create.ts b/src/app/editor/session/create.tsindex f9a5956fe..06c728b7a 100644--- a/src/app/editor/session/create.ts+++ b/src/app/editor/session/create.ts@@ -24,14 +24,18 @@ import {type EditorPreparationEventName,type EditorPreparationEvents} from '@/app/editor/preparation/events'-import { pageProgressUnit, type EditorPreparationHandle } from '@/app/editor/preparation/types'+import { pageProgressUnit } from '@/app/editor/preparation/types'import {createEditorComputedRefs,createEditorStoreModules,defineEditorStoreAccessors} from '@/app/editor/session/modules'import { scopedStoreFactory } from '@/app/editor/session/scope'-import { createInitialAppEditorState, type AppEditorState } from '@/app/editor/session/types'+import {+ createInitialAppEditorState,+ type AppEditorState,+ type AppSwitchPageOptions+} from '@/app/editor/session/types'import { notificationMessages } from '@/app/i18n/notifications'import { createDeferred } from '@/app/runtime/deferred'import { toast } from '@/app/shell/ui'@@ -133,7 +137,9 @@ function buildEditorStore(initialGraph?: SceneGraph) {})preparationLifecycle.delete(failure.id)})- const preparationController = createEditorPreparationController(state, preparationEvents)+ const preparationController = createEditorPreparationController(state, preparationEvents, {+ editor+ })const modules = createEditorStoreModules(editor, state, io, viewportSize, preparationController)// ─── Public API ───────────────────────────────────────────────@@ -141,17 +147,7 @@ function buildEditorStore(initialGraph?: SceneGraph) {const panes = createCanvasPaneRegistry(state)- async function switchPage(- pageId: string,- options: {- preparation?: EditorPreparationHandle- onProgress?: Parameters<typeof editor.switchPage>[1] extends infer Options- ? Options extends { onProgress?: infer Progress }- ? Progress- : never- : never- } = {}- ) {+ async function switchPage(pageId: string, options: AppSwitchPageOptions = {}) {const page = editor.graph.getNode(pageId)const preparation =options.preparation ??@@ -177,7 +173,9 @@ function buildEditorStore(initialGraph?: SceneGraph) {if (prepared) {editor.commitPageSwitch(prepared)preparation.update({ phase: 'preparing-render', detail: page?.name ?? null })- await preparationController.waitForPresentation(preparation.id, editor.state.sceneVersion)+ await options.beforePresentation?.()+ preparation.signal.throwIfAborted()+ await preparationController.waitForPresentation(preparation.id, editor.state)preparation.signal.throwIfAborted()}succeeded = truediff --git a/src/app/editor/session/types.ts b/src/app/editor/session/types.tsindex 1bf0d26ca..276a9d7ca 100644--- a/src/app/editor/session/types.ts+++ b/src/app/editor/session/types.ts@@ -1,8 +1,12 @@-import { createDefaultEditorState, type EditorState } from '@open-pencil/core'+import {+ createDefaultEditorState,+ type EditorState,+ type SwitchPageOptions+} from '@open-pencil/core'import type { DocumentColorSpace } from '@open-pencil/scene-graph'import type { PresentationColorSpace } from '@open-pencil/vue/canvas/surface'-import type { EditorPreparation } from '@/app/editor/preparation/types'+import type { EditorPreparation, EditorPreparationHandle } from '@/app/editor/preparation/types'import type { NodeEditState } from '@/app/editor/vector/types'import { appPreferences } from '@/app/settings/preferences/store'import { resolvedAppTheme } from '@/app/shell/theme'@@ -63,3 +67,15 @@ export type AppEditorState = EditorState & {/** Mirror of the document's color space, kept reactive for UI. */documentColorSpace: DocumentColorSpace}++/** How the app switches pages: inside a preparation, with the loader up until the page is shown. */+export interface AppSwitchPageOptions {+ /** The preparation the switch belongs to, such as a document opening; else it starts its own. */+ preparation?: EditorPreparationHandle+ /**+ * Runs once the page is committed and before its first frame counts as shown, such as+ * fitting the viewport, so what appears is drawn where it will stay.+ */+ beforePresentation?: () => void | Promise<void>+ onProgress?: SwitchPageOptions['onProgress']+}diff --git a/src/app/tabs/index.ts b/src/app/tabs/index.tsindex a4404a24b..d3d485612 100644--- a/src/app/tabs/index.ts+++ b/src/app/tabs/index.ts@@ -363,15 +363,20 @@ async function showImportedGraph(const firstPageId = store.graph.getPages()[0]?.id ?? store.graph.rootIdconst pageId = remembered?.pageId ?? firstPageIdload?.update({ phase: 'populating-page', detail: store.graph.getNode(pageId)?.name ?? null })- await store.switchPage(pageId, { preparation: load })+ // The view is placed before the first frame counts as shown, so the loader gives way to the+ // page drawn where it opens rather than one that then moves and fills in.+ await store.switchPage(pageId, {+ preparation: load,+ beforePresentation: async () => {+ if (remembered) {+ await yieldToUI()+ store.centerOn(remembered.center.x, remembered.center.y, remembered.zoom)+ } else {+ await store.fitCurrentPageToViewport()+ }+ }+ })load?.signal.throwIfAborted()- load?.update({ phase: 'preparing-render', detail: store.state.documentName })- if (remembered) {- await yieldToUI()- store.centerOn(remembered.center.x, remembered.center.y, remembered.zoom)- } else {- await store.fitCurrentPageToViewport()- }}async function cacheOpenedFigCover(path: string, store: EditorStore): Promise<void> {diff --git a/src/components/EditorCanvas.vue b/src/components/EditorCanvas.vueindex d57f1ada5..0d4dcc42a 100644--- a/src/components/EditorCanvas.vue+++ b/src/components/EditorCanvas.vue@@ -125,8 +125,6 @@ useCanvas(sceneCanvasRef, store, {showRulers: false,getRenderState,onViewportResize,- onPresented: ({ sceneVersion }) =>- store.preparationController.acknowledgePresentation(sceneVersion),onPresentation: (colorSpace) => {store.state.canvasPresentation = colorSpace}diff --git a/tests/app/ai/chat/trace/rebuild.test.ts b/tests/app/ai/chat/trace/rebuild.test.tsindex 6f697b685..a7f6c7e97 100644--- a/tests/app/ai/chat/trace/rebuild.test.ts+++ b/tests/app/ai/chat/trace/rebuild.test.ts@@ -69,7 +69,10 @@ async function recordRun({ steps, contextLimits }: RunOptions) {api.currentPage = api.wrapNode(pageId ?? editor.state.currentPageId)return api})- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)+ store.preparationController.acknowledgePresentation({+ renderVersion: Number.MAX_SAFE_INTEGER,+ sceneVersion: Number.MAX_SAFE_INTEGER+ })aiToolOverrides.value = { create_shape: true }let call = 0diff --git a/tests/app/ai/reply/run.test.ts b/tests/app/ai/reply/run.test.tsindex 07d7683b9..46d4a6d31 100644--- a/tests/app/ai/reply/run.test.ts+++ b/tests/app/ai/reply/run.test.ts@@ -102,7 +102,10 @@ async function withStore(return api})// No canvas presents frames here; treat every page switch as presented.- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)+ store.preparationController.acknowledgePresentation({+ renderVersion: Number.MAX_SAFE_INTEGER,+ sceneVersion: Number.MAX_SAFE_INTEGER+ })try {aiToolOverrides.value = { create_shape: true, switch_page: true }const a = store.state.currentPageIddiff --git a/tests/app/automation/bridge/handlers.test.ts b/tests/app/automation/bridge/handlers.test.tsindex bb756d737..d030198b8 100644--- a/tests/app/automation/bridge/handlers.test.ts+++ b/tests/app/automation/bridge/handlers.test.ts@@ -44,7 +44,7 @@ async function settle<T>(pending: Promise<T>): Promise<T> {const idle = Symbol('idle')for (const tab of getTabsSnapshot()) {if (tab.store.state.preparation?.phase !== 'preparing-render') continue- tab.store.preparationController.acknowledgePresentation(tab.store.state.sceneVersion)+ tab.store.preparationController.acknowledgePresentation(tab.store.state)}const result = await Promise.race([pending,diff --git a/tests/app/comments/session.test.ts b/tests/app/comments/session.test.tsindex cba2c7f8a..2acca225a 100644--- a/tests/app/comments/session.test.ts+++ b/tests/app/comments/session.test.ts@@ -126,7 +126,10 @@ test('going to a comment opens its page and its thread', async () => {const store = openDocument()const first = store.state.currentPageIdconst added = comment(store, 40, 40, 'on page one')- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)+ store.preparationController.acknowledgePresentation({+ renderVersion: Number.MAX_SAFE_INTEGER,+ sceneVersion: Number.MAX_SAFE_INTEGER+ })await store.switchPage(store.graph.addPage('Second').id)expect(store.state.currentPageId).not.toBe(first)diff --git a/tests/app/editor/preparation/controller.test.ts b/tests/app/editor/preparation/controller.test.tsindex d78ff8f74..2730a6cea 100644--- a/tests/app/editor/preparation/controller.test.ts+++ b/tests/app/editor/preparation/controller.test.ts@@ -1,10 +1,15 @@import { describe, expect, jest, test } from 'bun:test'+import { createEditor } from '@open-pencil/core'+import { createEditorPreparationController } from '@/app/editor/preparation/controller'import { createEditorPreparationEvents } from '@/app/editor/preparation/events'import type { EditorPreparationResult } from '@/app/editor/preparation/types'import { createInitialAppEditorState } from '@/app/editor/session/types'+/** Versions of a frame whose view and scene both reached `version`. */+const at = (version: number) => ({ renderVersion: version, sceneVersion: version })+describe('editor preparation controller', () => {test('keeps one reactive preparation snapshot until its owner finishes', () => {const state = createInitialAppEditorState('page')@@ -55,24 +60,92 @@ describe('editor preparation controller', () => {expect(state.preparation).toBeNull()})+ test('hears frames shown on the editor bus until disposed', async () => {+ const state = createInitialAppEditorState('page')+ const editor = createEditor()+ const controller = createEditorPreparationController(state, undefined, { editor })+ const first = controller.begin({ kind: 'page-switch' })+ const waiting = controller.waitForPresentation(first.id, at(3))+ editor.reportPresented(at(3))+ await waiting+ first.complete()++ controller.dispose()+ const second = controller.begin({ kind: 'page-switch' })+ let settled = false+ void controller.waitForPresentation(second.id, at(4)).finally(() => {+ settled = true+ })+ editor.reportPresented(at(4))+ await Promise.resolve()+ expect(settled).toBe(false)+ })++ test('waits for a frame of both the scene and the view, such as a fit after the page', async () => {+ const state = createInitialAppEditorState('page')+ const controller = createEditorPreparationController(state)+ const handle = controller.begin({ kind: 'page-switch' })++ let presented = false+ const waiting = controller+ .waitForPresentation(handle.id, { renderVersion: 9, sceneVersion: 7 })+ .then(() => {+ presented = true+ return presented+ })+ // The page's scene drawn at the view it had before the fit does not count.+ controller.acknowledgePresentation({ renderVersion: 8, sceneVersion: 7 })+ await Promise.resolve()+ expect(presented).toBe(false)++ controller.acknowledgePresentation({ renderVersion: 9, sceneVersion: 7 })+ await waiting+ expect(presented).toBe(true)+ handle.complete()+ })++ test('waits for the scene as well as the view, and for one frame that has both', async () => {+ const state = createInitialAppEditorState('page')+ const controller = createEditorPreparationController(state)+ const handle = controller.begin({ kind: 'page-switch' })++ let presented = false+ const waiting = controller+ .waitForPresentation(handle.id, { renderVersion: 9, sceneVersion: 7 })+ .then(() => {+ presented = true+ return presented+ })+ // The view without the scene, then the scene in an older view: neither frame has both.+ controller.acknowledgePresentation({ renderVersion: 9, sceneVersion: 6 })+ controller.acknowledgePresentation({ renderVersion: 8, sceneVersion: 7 })+ await Promise.resolve()+ expect(presented).toBe(false)++ controller.acknowledgePresentation({ renderVersion: 9, sceneVersion: 7 })+ await waiting+ expect(presented).toBe(true)+ handle.complete()+ })+test('waits for the prepared scene to be presented before finishing', async () => {const state = createInitialAppEditorState('page')const controller = createEditorPreparationController(state)const handle = controller.begin({ kind: 'page-switch' })let presented = false- const waiting = controller.waitForPresentation(handle.id, 7).then(() => {+ const waiting = controller.waitForPresentation(handle.id, at(7)).then(() => {presented = truereturn presented})await Promise.resolve()expect(presented).toBe(false)- controller.acknowledgePresentation(6)+ controller.acknowledgePresentation(at(6))await Promise.resolve()expect(presented).toBe(false)- controller.acknowledgePresentation(7)+ controller.acknowledgePresentation(at(7))await waitingexpect(presented).toBe(true)handle.complete()@@ -85,7 +158,7 @@ describe('editor preparation controller', () => {const handle = controller.begin({ kind: 'page-switch' })controller.attachCanvas()- await expect(controller.waitForPresentation(handle.id, 7)).rejects.toHaveProperty(+ await expect(controller.waitForPresentation(handle.id, at(7))).rejects.toHaveProperty('message','The operation was timed out')@@ -101,7 +174,7 @@ describe('editor preparation controller', () => {})const handle = controller.begin({ kind: 'page-switch' })let settled = false- const waiting = controller.waitForPresentation(handle.id, 7).finally(() => {+ const waiting = controller.waitForPresentation(handle.id, at(7)).finally(() => {settled = true})// A tab opened in the background: nothing draws it, and that is not a failure.@@ -118,7 +191,7 @@ describe('editor preparation controller', () => {expect(settled).toBe(false)controller.attachCanvas()- controller.acknowledgePresentation(7)+ controller.acknowledgePresentation(at(7))await waitinghandle.complete()} finally {@@ -132,20 +205,20 @@ describe('editor preparation controller', () => {const failure = new Error('The canvas could not start')const first = controller.begin({ kind: 'page-switch' })- const waiting = controller.waitForPresentation(first.id, 7)+ const waiting = controller.waitForPresentation(first.id, at(7))controller.failCanvas(failure)await expect(waiting).rejects.toBe(failure)first.fail({ code: 'render-failed', message: failure.message, retryable: true })const second = controller.begin({ kind: 'page-switch' })- await expect(controller.waitForPresentation(second.id, 8)).rejects.toBe(failure)+ await expect(controller.waitForPresentation(second.id, at(8))).rejects.toBe(failure)second.fail({ code: 'render-failed', message: failure.message, retryable: true })// A canvas that starts later presents scenes again.controller.attachCanvas()const third = controller.begin({ kind: 'page-switch' })- const presenting = controller.waitForPresentation(third.id, 9)- controller.acknowledgePresentation(9)+ const presenting = controller.waitForPresentation(third.id, at(9))+ controller.acknowledgePresentation(at(9))await presentingthird.complete()})@@ -156,7 +229,7 @@ describe('editor preparation controller', () => {const failure = new Error('The canvas could not start')const handle = controller.begin({ kind: 'page-switch' })const detach = controller.attachCanvas()- const waiting = controller.waitForPresentation(handle.id, 7)+ const waiting = controller.waitForPresentation(handle.id, at(7))// Another pane fails while this one still draws; then this one closes before presenting.controller.failCanvas(failure)detach()@@ -173,7 +246,7 @@ describe('editor preparation controller', () => {})const handle = controller.begin({ kind: 'page-switch' })let failure: unknown = null- const waiting = controller.waitForPresentation(handle.id, 7).catch((error: unknown) => {+ const waiting = controller.waitForPresentation(handle.id, at(7)).catch((error: unknown) => {failure = error})// Two visits of 60 ms each: the scene had longer than its 100 ms to draw.@@ -184,7 +257,7 @@ describe('editor preparation controller', () => {jest.advanceTimersByTime(60)await Promise.resolve()expect(failure).toHaveProperty('message', 'The operation was timed out')- controller.acknowledgePresentation(7)+ controller.acknowledgePresentation(at(7))await waitinghandle.fail({ code: 'render-failed', message: 'Timed out', retryable: true })} finally {diff --git a/tests/app/editor/session/page-switch.test.ts b/tests/app/editor/session/page-switch.test.tsindex c5081b471..cc21557fa 100644--- a/tests/app/editor/session/page-switch.test.ts+++ b/tests/app/editor/session/page-switch.test.ts@@ -8,7 +8,7 @@ test('a page switch overtaken by another resolves instead of rejecting', async (// Stand in for the canvas, which acknowledges each scene it presents.store.onPreparationEvent('preparation:updated', (preparation) => {if (preparation.phase === 'preparing-render')- store.preparationController.acknowledgePresentation(store.state.sceneVersion)+ store.preparationController.acknowledgePresentation(store.state)})const b = store.graph.addPage('B').idconst c = store.graph.addPage('C').iddiff --git a/tests/app/presence/registry.test.ts b/tests/app/presence/registry.test.tsindex d241fcd5b..d7130a4e6 100644--- a/tests/app/presence/registry.test.ts+++ b/tests/app/presence/registry.test.ts@@ -80,7 +80,10 @@ test('follows the page on screen', async () => {const { store, other } = setup()addAgent(store, 'chat').update({ status: 'editing', cursor: { x: 1, y: 1, pageId: other } })expect(store.state.presenceCursors).toHaveLength(0)- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)+ store.preparationController.acknowledgePresentation({+ renderVersion: Number.MAX_SAFE_INTEGER,+ sceneVersion: Number.MAX_SAFE_INTEGER+ })await store.switchPage(other)expect(store.state.presenceCursors).toHaveLength(1)})@@ -93,7 +96,10 @@ function centered(store: ReturnType<typeof createEditorStore>) {test('following an agent takes the view to its page and keeps its cursor centered', async () => {const { store, other } = setup()- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)+ store.preparationController.acknowledgePresentation({+ renderVersion: Number.MAX_SAFE_INTEGER,+ sceneVersion: Number.MAX_SAFE_INTEGER+ })const agent = addAgent(store, 'chat')agent.update({ status: 'editing', cursor: { x: 300, y: 200, pageId: other } })const switched = new Promise<string>((resolve) => {@@ -131,7 +137,10 @@ test('following a person matches their zoom, and stops when they leave', () => {test('switching to another page yourself stops following', async () => {const { store, pageId, other } = setup()- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)+ store.preparationController.acknowledgePresentation({+ renderVersion: Number.MAX_SAFE_INTEGER,+ sceneVersion: Number.MAX_SAFE_INTEGER+ })const ana = { clientId: 4, name: 'Ana', color: red, agents: [] }setPeers(store, [{ ...ana, cursor: { x: 40, y: 50, pageId, zoom: 1 } }])follow(store, { kind: 'person', clientId: 4 })@@ -142,7 +151,10 @@ test('switching to another page yourself stops following', async () => {test('following survives the target moving on while its page switch is in flight', async () => {const { store, other } = setup()- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)+ store.preparationController.acknowledgePresentation({+ renderVersion: Number.MAX_SAFE_INTEGER,+ sceneVersion: Number.MAX_SAFE_INTEGER+ })const third = store.graph.addPage('Third').idconst agent = addAgent(store, 'chat')agent.update({ status: 'editing', cursor: { x: 10, y: 10, pageId: other } })@@ -161,7 +173,10 @@ test('following survives the target moving on while its page switch is in flighttest('switching pages yourself stops following a resting agent too', async () => {const { store, other } = setup()- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)+ store.preparationController.acknowledgePresentation({+ renderVersion: Number.MAX_SAFE_INTEGER,+ sceneVersion: Number.MAX_SAFE_INTEGER+ })const agent = addAgent(store, 'chat')follow(store, { kind: 'agent', agentId: agent.id })await store.switchPage(other)@@ -191,7 +206,10 @@ test('zooming yourself stops following', () => {test('cursor updates while heading to a page do not restart the switch', async () => {const { store, other } = setup()- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)+ store.preparationController.acknowledgePresentation({+ renderVersion: Number.MAX_SAFE_INTEGER,+ sceneVersion: Number.MAX_SAFE_INTEGER+ })const switchPage = spyOn(store, 'switchPage')const agent = addAgent(store, 'chat')agent.update({ status: 'editing', cursor: { x: 10, y: 10, pageId: other } })@@ -226,7 +244,10 @@ test('a cursor on a page this document lacks is waited out, not switched to', ()test('stopping while following heads to another page stays where you are', async () => {const { store, pageId, other } = setup()- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)+ store.preparationController.acknowledgePresentation({+ renderVersion: Number.MAX_SAFE_INTEGER,+ sceneVersion: Number.MAX_SAFE_INTEGER+ })const agent = addAgent(store, 'chat')agent.update({ status: 'editing', cursor: { x: 10, y: 10, pageId: other } })follow(store, { kind: 'agent', agentId: agent.id })diff --git a/tests/app/recent-files/view.test.ts b/tests/app/recent-files/view.test.tsindex 11027a1ee..6d6eaf45f 100644--- a/tests/app/recent-files/view.test.ts+++ b/tests/app/recent-files/view.test.ts@@ -37,7 +37,10 @@ describe("a document's remembered view", () => {const store = openedFromPath()rememberRecentFile(PATH, 'design')const second = store.graph.addPage('Second').id- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)+ store.preparationController.acknowledgePresentation({+ renderVersion: Number.MAX_SAFE_INTEGER,+ sceneVersion: Number.MAX_SAFE_INTEGER+ })await store.switchPage(second)store.centerOn(300, 200, 2)@@ -81,7 +84,10 @@ describe("a document's remembered view", () => {}))expect(rememberedDocumentView(store)).toBeNull()- store.preparationController.acknowledgePresentation(Number.MAX_SAFE_INTEGER)+ store.preparationController.acknowledgePresentation({+ renderVersion: Number.MAX_SAFE_INTEGER,+ sceneVersion: Number.MAX_SAFE_INTEGER+ })await store.switchPage(hidden.id)rememberDocumentView(store)expect(recentDocuments.value[0]?.view?.pageId).toBe(hidden.id)diff --git a/tests/engine/app/tabs/open-file-dedup.test.ts b/tests/engine/app/tabs/open-file-dedup.test.tsindex 459a929d5..b11bb353f 100644--- a/tests/engine/app/tabs/open-file-dedup.test.ts+++ b/tests/engine/app/tabs/open-file-dedup.test.ts@@ -57,7 +57,7 @@ function setupGlobals() {function acknowledgePendingPresentation(): void {for (const tab of getTabsSnapshot()) {if (tab.store.state.preparation?.phase !== 'preparing-render') continue- tab.store.preparationController.acknowledgePresentation(tab.store.state.sceneVersion)+ tab.store.preparationController.acknowledgePresentation(tab.store.state)}}diff --git a/tests/engine/render/canvas/surface-replacement.test.ts b/tests/engine/render/canvas/surface-replacement.test.tsindex c3d35a76a..94c4db430 100644--- a/tests/engine/render/canvas/surface-replacement.test.ts+++ b/tests/engine/render/canvas/surface-replacement.test.ts@@ -1,6 +1,6 @@import { describe, expect, mock, test } from 'bun:test'-import type { Surface } from 'canvaskit-wasm'+import type { Image, Surface } from 'canvaskit-wasm'import { SkiaRenderer } from '#core/canvas/renderer'@@ -10,24 +10,54 @@ function surface() {return { delete: mock() } as Surface & { delete: ReturnType<typeof mock> }}+function liveImage() {+ return asDouble<Image & { delete: ReturnType<typeof mock> }>({ delete: mock() })+}++function rendererOn(previous: Surface, image: Image) {+ const renderer: Pick<+ SkiaRenderer,+ 'surface' | 'images' | 'tiledScene' | 'invalidateScenePicture' | 'replaceSurface'+ > = {+ surface: previous,+ images: asDouble<SkiaRenderer['images']>({+ live: new Map([['shader', { image, surface: previous }]])+ }),+ tiledScene: asDouble<SkiaRenderer['tiledScene']>({ destroy: mock() }),+ invalidateScenePicture: mock(),+ replaceSurface: SkiaRenderer.prototype.replaceSurface+ }+ return renderer+}+describe('renderer surface replacement', () => {- test('clears context-owned tiled resources before replacing the main surface', () => {+ test('clears context-owned resources when the surface comes from a new context', () => {const previous = surface()const next = surface()- const renderer: Pick<- SkiaRenderer,- 'surface' | 'images' | 'tiledScene' | 'invalidateScenePicture' | 'replaceSurface'- > = {- surface: previous,- images: asDouble<SkiaRenderer['images']>({ live: new Map() }),- tiledScene: asDouble<SkiaRenderer['tiledScene']>({ destroy: mock() }),- invalidateScenePicture: mock(),- replaceSurface: SkiaRenderer.prototype.replaceSurface- }+ const image = liveImage()+ const renderer = rendererOn(previous, image)renderer.replaceSurface.call(asRenderer(renderer), next)expect(renderer.tiledScene.destroy).toHaveBeenCalledTimes(1)+ expect(image.delete).toHaveBeenCalledTimes(1)+ expect(renderer.images.live.size).toBe(0)+ expect(previous.delete).toHaveBeenCalledTimes(1)+ expect(renderer.surface).toBe(next)+ expect(renderer.invalidateScenePicture).toHaveBeenCalledTimes(1)+ })++ test('keeps tiles and live textures when the surface shares the context, as on resize', () => {+ const previous = surface()+ const next = surface()+ const image = liveImage()+ const renderer = rendererOn(previous, image)++ renderer.replaceSurface.call(asRenderer(renderer), next, { sameContext: true })++ expect(renderer.tiledScene.destroy).not.toHaveBeenCalled()+ expect(image.delete).not.toHaveBeenCalled()+ expect(renderer.images.live.get('shader')).toEqual({ image, surface: next })expect(previous.delete).toHaveBeenCalledTimes(1)expect(renderer.surface).toBe(next)expect(renderer.invalidateScenePicture).toHaveBeenCalledTimes(1)