From 3581a0e380bd925a17d5708d87bde489bc8b7220 Mon Sep 17 00:00:00 2001
From: Diego Imbert <diego@windmill.dev>
Date: Sun, 6 Sep 2026 19:49:10 +0200
Subject: [PATCH] fix(sessions): keep what a released editor was holding, and
 scope the ws selector to the drawer
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

An editor stays editable while its save is in flight, so a tab left in that
window releases a cell that may carry an edit newer than the write — and a
released cell reads as no cell at all, which the settle took for a draft nothing
was watching and deleted. Keep what the last holder let go of, bounded like the
other write markers, and let the settle read that when no handle is left.

The linked-workspace selector follows the hand-off button: a session tab is keyed
to one workspace, so re-pointing the editor at a linked one from inside a tab
acted on an item the session is not about.

A removal marker now also requires the delete to be what landed, as
`flushDraftDelete` does: an upsert queued behind it displaces the delete, and
waiting for the chain then reports idle on a draft that is back.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KcyBRxE8j3ujCYkum9KrC4
---
 .../components/ResourceEditorDrawer.svelte    | 18 +++++---
 .../src/lib/components/VariableEditor.svelte  |  6 ++-
 .../components/copilot/chat/global/core.ts    | 11 +++--
 frontend/src/lib/userDraft.svelte.ts          | 41 +++++++++++++++++--
 4 files changed, 62 insertions(+), 14 deletions(-)

diff --git a/frontend/src/lib/components/ResourceEditorDrawer.svelte b/frontend/src/lib/components/ResourceEditorDrawer.svelte
index 1f570b10fd..56f5c7aea4 100644
--- a/frontend/src/lib/components/ResourceEditorDrawer.svelte
+++ b/frontend/src/lib/components/ResourceEditorDrawer.svelte
@@ -206,12 +206,18 @@
 		>
 			History
 		</Button>
-		<WsSpecificVersions
-			kind="resource"
-			workspaceId={effectiveWorkspace}
-			initialPath={path}
-			bind:selected
-		/>
+		<!-- Drawer-only, for the same reason as the hand-off above: a session tab is
+		     keyed to one workspace — its title, the chat's write targeting and the
+		     deploy set all read it — so re-pointing the editor at a linked workspace
+		     from inside one would act on an item the session is not about. -->
+		{#if useDrawer}
+			<WsSpecificVersions
+				kind="resource"
+				workspaceId={effectiveWorkspace}
+				initialPath={path}
+				bind:selected
+			/>
+		{/if}
 	{/if}
 	<Button
 		variant="accent"
diff --git a/frontend/src/lib/components/VariableEditor.svelte b/frontend/src/lib/components/VariableEditor.svelte
index 391949ee00..a630ce3f28 100644
--- a/frontend/src/lib/components/VariableEditor.svelte
+++ b/frontend/src/lib/components/VariableEditor.svelte
@@ -429,7 +429,11 @@
 	{#if useDrawer}
 		<OpenInSessionButton source={sessionSource} />
 	{/if}
-	{#if edit && curWs}
+	<!-- Drawer-only, for the same reason as the hand-off above: a session tab is
+	     keyed to one workspace — its title, the chat's write targeting and the
+	     deploy set all read it — so re-pointing the editor at a linked workspace
+	     from inside one would act on an item the session is not about. -->
+	{#if edit && curWs && useDrawer}
 		<WsSpecificVersions kind="variable" workspaceId={curWs} {initialPath} bind:selected />
 	{/if}
 	<Button
diff --git a/frontend/src/lib/components/copilot/chat/global/core.ts b/frontend/src/lib/components/copilot/chat/global/core.ts
index 8589dc4945..fd66e6d7c0 100644
--- a/frontend/src/lib/components/copilot/chat/global/core.ts
+++ b/frontend/src/lib/components/copilot/chat/global/core.ts
@@ -6184,10 +6184,13 @@ async function discardLocalDraft(
 	// not leave one standing for a later action to spend, and an edit made across the
 	// delete recreates the draft — leaving the item the marker would report as gone.
 	if (removesItem && discardedKind) {
-		const settled =
-			UserDraftDbSyncer.getState({ workspace, itemKind: discardedKind, path: storagePath })
-				.state === 'none'
-		if (settled) {
+		const query = { workspace, itemKind: discardedKind, path: storagePath }
+		// Settled AND settled on the delete: an upsert queued behind it displaces the
+		// delete, and waiting for the chain then reports idle on a draft that is back.
+		const removed =
+			UserDraftDbSyncer.getState(query).state === 'none' &&
+			UserDraftDbSyncer.lastLandedWasDelete(query)
+		if (removed) {
 			UserDraft.recordDraftOnlyDiscard(discardedKind, storagePath, { workspace })
 		}
 	}
diff --git a/frontend/src/lib/userDraft.svelte.ts b/frontend/src/lib/userDraft.svelte.ts
index 8c681592d7..7624cbf756 100644
--- a/frontend/src/lib/userDraft.svelte.ts
+++ b/frontend/src/lib/userDraft.svelte.ts
@@ -142,6 +142,36 @@ function noteMarker(set: Set<string>, key: string): void {
 		set.delete(oldest)
 	}
 }
+/**
+ * What a cell held when its last holder let go. An editor stays editable while
+ * its save is in flight, so a tab closed in that window releases a cell that may
+ * carry an edit newer than the write — and once released there is no handle left
+ * to read it from. Same cap and reason as the marker sets; taken by whoever asks
+ * (`settleDraftAfterWrite`), and dropped when the key is acquired again, since a
+ * live entry answers for itself.
+ */
+const releasedValues = new Map<string, unknown>()
+/** Read once: what it describes is settled by the caller that reads it. */
+function takeReleasedValue<V>(
+	itemKind: UserDraftItemKind,
+	path: string,
+	opts?: UserDraftOptions
+): V | undefined {
+	const mk = mapKey(resolveWorkspace(opts), itemKind, path)
+	const value = releasedValues.get(mk) as V | undefined
+	releasedValues.delete(mk)
+	return value
+}
+
+function noteReleasedValue(key: string, value: unknown): void {
+	releasedValues.set(key, value)
+	while (releasedValues.size > MAX_WRITE_MARKERS) {
+		const oldest = releasedValues.keys().next().value
+		if (oldest === undefined || oldest === key) break
+		releasedValues.delete(oldest)
+	}
+}
+
 const liveEditorDrafts = new Map<string, LiveEditorDraft>()
 /**
  * Map keys whose entry should start `syncSuspended` on acquire. Lets
@@ -285,9 +315,12 @@ export async function settleDraftAfterWrite<V>(
 	savedPath: string,
 	opts?: UserDraftOptions
 ): Promise<void> {
-	// No cell at all is not a newer edit — the editor has been released, and its
-	// draft is precisely what nothing is watching any more.
-	const diverged = live !== undefined && !draftValuesEqual(live, written)
+	// A released cell reads as no cell at all, and its draft is then precisely what
+	// nothing is watching any more — except when the release itself is what took
+	// the handle away mid-write, in which case what it held still speaks for the
+	// user. Absent both, there is nothing newer to protect.
+	const held = live !== undefined ? live : takeReleasedValue<V>(itemKind, fromPath, opts)
+	const diverged = held !== undefined && !draftValuesEqual(held, written)
 	if (savedPath === fromPath && diverged) return
 	// Sent before this resolves, not left on the keystroke debounce: callers report
 	// the write and remount on it, and both read a cell this has to have finished
@@ -890,6 +923,7 @@ function acquireEntry(
 	canBeDisabled = false
 ): void {
 	const mk = mapKey(workspace, itemKind, path)
+	releasedValues.delete(mk)
 	const existing = entries.get(mk)
 	if (existing) {
 		existing.count++
@@ -1026,6 +1060,7 @@ function releaseEntry(mk: string): void {
 	// only here, once, at refcount 0. This is what lets multiple holders (warm
 	// session previews + the nav editor) share the entry and drop in any order.
 	if (entry.count <= 0) {
+		noteReleasedValue(mk, snapshotDraftValue(entry.state.val))
 		// The live entry was authoritative while mounted; once gone, drop any
 		// cached write for this key so a later read falls back to the server
 		// rather than a value the editor may have changed in the meantime.