diff --git a/app/apps/blocks/blocks-app.worker.ts b/app/apps/blocks/blocks-app.worker.ts index 296e4d63..15db7d81 100644 --- a/app/apps/blocks/blocks-app.worker.ts +++ b/app/apps/blocks/blocks-app.worker.ts @@ -167,6 +167,12 @@ function post(message: WorkerAppReply): void { global.postMessage(message); } +// The host queues messages until this arrives: posts to a worker whose bundle +// is still evaluating can be silently dropped (see WorkerAppHost). Top-level +// evaluation is synchronous, so the handler below is installed before any +// queued message can be delivered. +post({ type: "worker-ready" }); + global.onmessage = (event: { data: WorkerAppMessage }) => { const message = event.data; switch (message.type) { diff --git a/app/apps/freecell/freecell-app.worker.ts b/app/apps/freecell/freecell-app.worker.ts index d317adf6..2294232c 100644 --- a/app/apps/freecell/freecell-app.worker.ts +++ b/app/apps/freecell/freecell-app.worker.ts @@ -128,6 +128,12 @@ function post(message: WorkerAppReply): void { global.postMessage(message); } +// The host queues messages until this arrives: posts to a worker whose bundle +// is still evaluating can be silently dropped (see WorkerAppHost). Top-level +// evaluation is synchronous, so the handler below is installed before any +// queued message can be delivered. +post({ type: "worker-ready" }); + global.onmessage = (event: { data: WorkerAppMessage }) => { const message = event.data; switch (message.type) { diff --git a/app/apps/minesweeper/minesweeper-app.worker.ts b/app/apps/minesweeper/minesweeper-app.worker.ts index 20a78218..f42cea93 100644 --- a/app/apps/minesweeper/minesweeper-app.worker.ts +++ b/app/apps/minesweeper/minesweeper-app.worker.ts @@ -132,6 +132,12 @@ function post(message: WorkerAppReply): void { global.postMessage(message); } +// The host queues messages until this arrives: posts to a worker whose bundle +// is still evaluating can be silently dropped (see WorkerAppHost). Top-level +// evaluation is synchronous, so the handler below is installed before any +// queued message can be delivered. +post({ type: "worker-ready" }); + global.onmessage = (event: { data: WorkerAppMessage }) => { const message = event.data; switch (message.type) { diff --git a/app/apps/navigate/navigate-app.worker.ts b/app/apps/navigate/navigate-app.worker.ts index 78472fbf..8dbaff7c 100644 --- a/app/apps/navigate/navigate-app.worker.ts +++ b/app/apps/navigate/navigate-app.worker.ts @@ -148,6 +148,12 @@ function post(message: WorkerAppReply): void { global.postMessage(message); } +// The host queues messages until this arrives: posts to a worker whose bundle +// is still evaluating can be silently dropped (see WorkerAppHost). Top-level +// evaluation is synchronous, so the handler below is installed before any +// queued message can be delivered. +post({ type: "worker-ready" }); + global.onmessage = (event: { data: WorkerAppMessage }) => { const message = event.data; switch (message.type) { diff --git a/app/apps/pinball/pinball-app.worker.ts b/app/apps/pinball/pinball-app.worker.ts index 5b3b7f8c..a35eb533 100644 --- a/app/apps/pinball/pinball-app.worker.ts +++ b/app/apps/pinball/pinball-app.worker.ts @@ -287,6 +287,12 @@ function post(message: WorkerAppReply): void { global.postMessage(message); } +// The host queues messages until this arrives: posts to a worker whose bundle +// is still evaluating can be silently dropped (see WorkerAppHost). Top-level +// evaluation is synchronous, so the handler below is installed before any +// queued message can be delivered. +post({ type: "worker-ready" }); + global.onmessage = (event: { data: WorkerAppMessage }) => { const message = event.data; switch (message.type) { diff --git a/app/apps/roam/roam-app.worker.ts b/app/apps/roam/roam-app.worker.ts index c447a8ab..88384a42 100644 --- a/app/apps/roam/roam-app.worker.ts +++ b/app/apps/roam/roam-app.worker.ts @@ -154,6 +154,12 @@ function post(message: WorkerAppReply): void { global.postMessage(message); } +// The host queues messages until this arrives: posts to a worker whose bundle +// is still evaluating can be silently dropped (see WorkerAppHost). Top-level +// evaluation is synchronous, so the handler below is installed before any +// queued message can be delivered. +post({ type: "worker-ready" }); + global.onmessage = (event: { data: WorkerAppMessage }) => { const message = event.data; switch (message.type) { diff --git a/app/apps/terminal/terminal-app.worker.ts b/app/apps/terminal/terminal-app.worker.ts index ea47dbbe..941d9381 100644 --- a/app/apps/terminal/terminal-app.worker.ts +++ b/app/apps/terminal/terminal-app.worker.ts @@ -281,6 +281,12 @@ function post(message: WorkerAppReply): void { global.postMessage(message); } +// The host queues messages until this arrives: posts to a worker whose bundle +// is still evaluating can be silently dropped (see WorkerAppHost). Top-level +// evaluation is synchronous, so the handler below is installed before any +// queued message can be delivered. +post({ type: "worker-ready" }); + global.onmessage = (event: { data: WorkerAppMessage }) => { const message = event.data; switch (message.type) { diff --git a/app/apps/timer/timer-app.worker.ts b/app/apps/timer/timer-app.worker.ts index 1859ef63..b12887ce 100644 --- a/app/apps/timer/timer-app.worker.ts +++ b/app/apps/timer/timer-app.worker.ts @@ -118,6 +118,12 @@ function post(message: WorkerAppReply): void { global.postMessage(message); } +// The host queues messages until this arrives: posts to a worker whose bundle +// is still evaluating can be silently dropped (see WorkerAppHost). Top-level +// evaluation is synchronous, so the handler below is installed before any +// queued message can be delivered. +post({ type: "worker-ready" }); + global.onmessage = (event: { data: WorkerAppMessage }) => { const message = event.data; switch (message.type) { diff --git a/app/ui/shell/worker-window.ts b/app/ui/shell/worker-window.ts index 26d7c146..a44bfbca 100644 --- a/app/ui/shell/worker-window.ts +++ b/app/ui/shell/worker-window.ts @@ -24,6 +24,14 @@ export type WorkerAppMessage = | { type: "tool-call"; callId: string; windowId: string; name: string; args: unknown }; export type WorkerAppReply = + | { + /** + * The worker's bundle has evaluated and its onmessage handler is + * installed. Messages posted to a still-loading worker can be silently + * dropped, so the host queues everything until this arrives. + */ + type: "worker-ready"; + } | { type: "yield-focus"; windowId: string } | { /** Foreground and focus one of the app's existing windows. */ @@ -166,12 +174,26 @@ export class WorkerAppHost { private readonly openWindows = new Set(); private readonly pendingToolCalls = new Map(); private nextCallSerial = 1; + /** + * Messages posted before the worker finishes evaluating its bundle can be + * silently dropped (notably the launch-time foreground/render pair, leaving + * a black window until the first input). Queue everything until the worker + * posts worker-ready, then flush in order. + */ + private workerReady = false; + private readonly queuedMessages: WorkerAppMessage[] = []; constructor(private readonly options: WorkerAppHostOptions) { options.worker.onmessage = (event: MessageEvent) => { const message = event.data as WorkerAppReply | undefined; if (!message) return; switch (message.type) { + case "worker-ready": + this.workerReady = true; + for (const queued of this.queuedMessages.splice(0)) { + this.options.worker.postMessage(queued); + } + break; case "yield-focus": // Only the focused window's yield is meaningful. if (shell.foregroundWindow()?.windowId === message.windowId) { @@ -378,6 +400,10 @@ export class WorkerAppHost { } private post(message: WorkerAppMessage): void { + if (!this.workerReady) { + this.queuedMessages.push(message); + return; + } this.options.worker.postMessage(message); } }