From 2e64b9fc3bc0c30695c08bf462f2f5945509e5c8 Mon Sep 17 00:00:00 2001 From: Luke Parker <10430890+Hona@users.noreply.github.com> Date: Fri, 30 Oct 2026 14:35:52 +1000 Subject: [PATCH] fix(client): evict missing sessions on 404 instead of retrying or toasting (#60459) --- packages/app/src/runtime/server/data.test.ts | 18 +- packages/app/src/runtime/server/data.ts | 31 +++- .../src/shell/notifications/notification.tsx | 11 +- packages/app/src/shell/titlebar/tab-strip.tsx | 1 + packages/client/src/solid/data.ts | 85 +++++++-- packages/client/test/solid-refresh.test.ts | 162 ++++++++++++++++++ .../src/browser/connection.test.ts | 18 ++ .../gui-plugins/src/browser/connection.ts | 12 +- packages/gui-plugins/src/browser/model.ts | 2 +- packages/gui-plugins/src/browser/pane.ts | 18 +- 10 files changed, 329 insertions(+), 29 deletions(-) diff --git a/packages/app/src/runtime/server/data.test.ts b/packages/app/src/runtime/server/data.test.ts index 48e6a47a8e5..47b8d07998d 100644 --- a/packages/app/src/runtime/server/data.test.ts +++ b/packages/app/src/runtime/server/data.test.ts @@ -2,7 +2,14 @@ import { expect, test } from "bun:test" import type { SessionInfo } from "@opencode/client/promise" import { createSessionMutations } from "./data" -const session = { id: "ses_test" } as SessionInfo +const session: SessionInfo = { + id: "ses_test", + projectID: "project", + cost: 0, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + time: { created: 0, updated: 0 }, + location: { directory: "/project" }, +} test("keeps a removed session hidden after its deletion event, for lists cached before it", async () => { const release = Promise.withResolvers() @@ -38,3 +45,12 @@ test("rolls back a failed removal", async () => { await expect(request).rejects.toThrow("offline") expect(mutation.apply([session])).toEqual([session]) }) + +test("treats SessionNotFoundError on removal as already deleted", async () => { + const mutation = createSessionMutations(async () => { + throw JSON.parse('{"_tag":"SessionNotFoundError","sessionID":"ses_test","message":"Session not found: ses_test"}') + }) + + await expect(mutation.remove(session.id)).resolves.toBeUndefined() + expect(mutation.apply([session])).toEqual([]) +}) diff --git a/packages/app/src/runtime/server/data.ts b/packages/app/src/runtime/server/data.ts index 5c9739a9eb3..2af546ca676 100644 --- a/packages/app/src/runtime/server/data.ts +++ b/packages/app/src/runtime/server/data.ts @@ -1,11 +1,13 @@ import type { Data } from "@opencode/client/solid" -import type { OpenCodeEvent, SessionInfo } from "@opencode/client/promise" +import { isSessionNotFoundError, type OpenCodeEvent, type SessionInfo } from "@opencode/client/promise" import { onCleanup } from "solid-js" import { createStore } from "solid-js/store" import { uuid } from "@/runtime/persistence/uuid" type SessionMutation = { readonly id: string; readonly type: "remove"; readonly sessionID: string } +const REMOVED_SESSION_LIMIT = 512 + // The events on which the server advances a session's `time.updated` to the event's time. const SESSION_ACTIVITY = [ "session.inbox.enqueued", @@ -27,8 +29,13 @@ const SESSION_ACTIVITY = [ export function createDesktopData(input: { data: Data; remove: (sessionID: string) => Promise }) { const mutation = createSessionMutations(input.remove) - const [activity, setActivity] = createStore>({}) - onCleanup(input.data.on("session.deleted", (event) => mutation.deleted(event.data.sessionID))) + const [activity, setActivity] = createStore>({}) + onCleanup( + input.data.on("session.deleted", (event) => { + setActivity(event.data.sessionID, undefined) + mutation.deleted(event.data.sessionID) + }), + ) // Lists loaded earlier (the Home index, the live store, search results) learn each session's newer // `time.updated` from its events, so they rank sessions in the server's order without reloading. @@ -53,7 +60,11 @@ export function createDesktopData(input: { data: Data; remove: (sessionID: strin ...input.data.session, list: () => apply(input.data.session.list()), apply, - remove: mutation.remove, + remove: (sessionID: string) => + mutation.remove(sessionID).then(() => { + setActivity(sessionID, undefined) + input.data.session.forget(sessionID) + }), }, } } @@ -65,6 +76,9 @@ export function createSessionMutations(remove: (sessionID: string) => Promise current.filter((mutation) => mutation.id !== id)) } + const append = (current: readonly SessionMutation[], next: SessionMutation) => + [...current.filter((mutation) => mutation.sessionID !== next.sessionID), next].slice(-REMOVED_SESSION_LIMIT) + return { apply(sessions: readonly SessionInfo[]) { const removed = new Set( @@ -75,21 +89,20 @@ export function createSessionMutations(remove: (sessionID: string) => Promise [...current, mutation]) + setStore("session", (current) => append(current, mutation)) return Promise.resolve() .then(() => remove(sessionID)) .catch((error) => { + if (isSessionNotFoundError(error)) return + clear(mutation.id) throw error }) }, // Keep the deleted session hidden: cached lists such as the Home index still hold it until they refetch. deleted(sessionID: string) { - setStore("session", (current) => [ - ...current.filter((mutation) => mutation.sessionID !== sessionID), - { id: uuid(), type: "remove", sessionID }, - ]) + setStore("session", (current) => append(current, { id: uuid(), type: "remove", sessionID })) }, } } diff --git a/packages/app/src/shell/notifications/notification.tsx b/packages/app/src/shell/notifications/notification.tsx index ecbec3704b8..7804b3ed9cf 100644 --- a/packages/app/src/shell/notifications/notification.tsx +++ b/packages/app/src/shell/notifications/notification.tsx @@ -1,7 +1,7 @@ import { createEffect, createMemo, onCleanup, untrack } from "solid-js" import { createStore } from "solid-js/store" import { Schema } from "effect" -import type { SessionInfo } from "@opencode/client/promise" +import { isSessionNotFoundError, type SessionInfo } from "@opencode/client/promise" import type { ServerSDK } from "@/runtime/server/client" import type { Data } from "@opencode/client/solid" import { usePlatform } from "@/runtime/platform/platform" @@ -208,7 +208,14 @@ export function createServerNotificationState(input: { viewRetryTimer = undefined viewRetryAttempt = 0 }, - () => { + (error) => { + if (isSessionNotFoundError(error)) { + acknowledged.delete(root) + input.data.session.forget(root) + + return + } + if (acknowledged.get(root) !== idle) return acknowledged.delete(root) diff --git a/packages/app/src/shell/titlebar/tab-strip.tsx b/packages/app/src/shell/titlebar/tab-strip.tsx index fc7ea3c07b6..37f1c2296bd 100644 --- a/packages/app/src/shell/titlebar/tab-strip.tsx +++ b/packages/app/src/shell/titlebar/tab-strip.tsx @@ -229,6 +229,7 @@ function SessionTabEntry(props: { pending() || !ctx || props.active || + ctx.data.session.missing(id) || (!session() && !persisted()?.title) || ctx.sdk.connection.status() !== "connected" ) diff --git a/packages/client/src/solid/data.ts b/packages/client/src/solid/data.ts index 30aee439236..6e727d44262 100644 --- a/packages/client/src/solid/data.ts +++ b/packages/client/src/solid/data.ts @@ -47,7 +47,9 @@ import { SessionMessage } from "@opencode/schema/session-message" import { isFormAlreadySettledError, isFormNotFoundError, + isMessageNotFoundError, isPermissionNotFoundError, + isSessionNotFoundError, type SessionPromptInput, } from "../promise" import { createStore, produce, reconcile } from "solid-js/store" @@ -122,6 +124,7 @@ type LocationData = { type Store = { session: { info: Record + missing: Record // Family index keyed by a family's root (or furthest-known-ancestor when the // true root is not yet loaded). The value is a flat deduplicated list of every // session ID in that family, including the key itself once its info arrives. @@ -256,6 +259,7 @@ function createSync() { } const CHILD_PAGE = 200 +const DELETED_SESSION_LIMIT = 512 export function createData(config: CreateDataInput) { const api = config.api @@ -266,6 +270,11 @@ export function createData(config: CreateDataInput) { if (disposed || (config.connection && config.connection.status() !== "connected")) return void load().catch((error) => { if (disposed || (config.connection && config.connection.status() !== "connected")) return + if (isSessionNotFoundError(error)) { + markDeleted(error.sessionID) + return + } + if (isMessageNotFoundError(error)) return if (config.onError) return config.onError(error) console.error("Failed to refresh client data", error) }) @@ -288,6 +297,7 @@ export function createData(config: CreateDataInput) { const [store, setStore] = createStore({ session: { info: {}, + missing: {}, family: {}, active: {}, message: {}, @@ -631,6 +641,36 @@ export function createData(config: CreateDataInput) { ) } + let deletionEpoch = 0 + const deletedAt = new Map() + + function clearDeleted(sessionID: string) { + deletedAt.delete(sessionID) + if (store.session.missing[sessionID]) setStore("session", "missing", sessionID, undefined) + } + + function markDeleted(sessionID: string) { + if (sessionOutbox.has(sessionID)) return + batch(() => { + deletedAt.delete(sessionID) + deletedAt.set(sessionID, ++deletionEpoch) + if (deletedAt.size > DELETED_SESSION_LIMIT) { + const oldest = deletedAt.keys().next().value + if (oldest !== undefined) { + deletedAt.delete(oldest) + setStore("session", "missing", oldest, undefined) + } + } + setStore("session", "missing", sessionID, true) + removeSession(sessionID) + }) + } + + function evictMissing(error: unknown): never { + if (isSessionNotFoundError(error)) markDeleted(error.sessionID) + throw error + } + function removeSession(sessionID: string) { activeUpdates?.set(sessionID, undefined) store.session.pending[sessionID]?.forEach((item) => outbox.delete(item.id)) @@ -705,6 +745,7 @@ export function createData(config: CreateDataInput) { setStore("project", "info", event.data.id, reconcile(event.data)) return case "session.created": + clearDeleted(event.data.sessionID) sessionOutbox.delete(event.data.sessionID) result.session.invalidate(event.data.sessionID) refresh(() => result.session.sync(event.data.sessionID)) @@ -716,7 +757,7 @@ export function createData(config: CreateDataInput) { sync.complete(`session.message:${event.data.sessionID}`) return case "session.deleted": - removeSession(event.data.sessionID) + markDeleted(event.data.sessionID) return case "session.usage.updated": if (store.session.info[event.data.sessionID]) @@ -1462,11 +1503,18 @@ export function createData(config: CreateDataInput) { get(sessionID: string) { return store.session.info[sessionID] }, + missing(sessionID: string) { + return Boolean(store.session.missing[sessionID]) + }, + forget(sessionID: string) { + markDeleted(sessionID) + }, creating(sessionID: string) { return creating.has(sessionID) }, remember(info: SessionInfo) { batch(() => { + clearDeleted(info.id) setStore("session", "info", info.id, reconcile(info)) sync.complete(`session:${info.id}`) registerSession(info.id) @@ -1541,10 +1589,12 @@ export function createData(config: CreateDataInput) { }, sync(sessionID: string) { return sync.run(`session.pending:${sessionID}`, async () => { + const started = deletionEpoch const updates = new Map() pendingUpdates.set(sessionID, updates) try { - const snapshot = await api().session.inbox.list({ sessionID }) + const snapshot = await api().session.inbox.list({ sessionID }).catch(evictMissing) + if ((deletedAt.get(sessionID) ?? 0) > started) return // Events can overtake this HTTP response on a remote connection. // Reconcile them before an older snapshot can resurrect delivered input. const current = new Map(snapshot.map((item) => [item.id, item])) @@ -1600,6 +1650,7 @@ export function createData(config: CreateDataInput) { const id = payload.id ?? SessionID.create() const location = payload.location ?? defaultLocation() const fresh = !store.session.info[id] + clearDeleted(id) if (fresh) { const now = Date.now() sessionOutbox.add(id) @@ -1732,11 +1783,12 @@ export function createData(config: CreateDataInput) { }, sync(sessionID: string, options?: { children?: boolean }) { return sync.run(options?.children ? `session.family:${sessionID}` : `session:${sessionID}`, async () => { + const started = deletionEpoch const [info, children] = await Promise.all([ - api().session.get({ sessionID }), + api().session.get({ sessionID }).catch(evictMissing), options?.children ? listChildren({ parentID: sessionID, order: "desc", limit: CHILD_PAGE }) : [], ]) - const sessions = [info, ...children] + const sessions = [info, ...children].filter((session) => (deletedAt.get(session.id) ?? 0) <= started) batch(() => { setStore( "session", @@ -1746,6 +1798,7 @@ export function createData(config: CreateDataInput) { }), ) for (const session of sessions) { + clearDeleted(session.id) sync.complete(`session:${session.id}`) registerSession(session.id) } @@ -1766,11 +1819,15 @@ export function createData(config: CreateDataInput) { }, sync(sessionID: string) { return sync.run(`session.message:${sessionID}`, async () => { - const response = await api().message.list({ - sessionID, - limit: config.initialMessageLimit?.() ?? messagePageLimit, - order: "desc", - }) + const started = deletionEpoch + const response = await api() + .message.list({ + sessionID, + limit: config.initialMessageLimit?.() ?? messagePageLimit, + order: "desc", + }) + .catch(evictMissing) + if ((deletedAt.get(sessionID) ?? 0) > started) return const fetched = response.data.toReversed().map(stored) // Same protection as the pending sync: a re-fetch racing an // admission must not wipe its local transcript row. @@ -1877,7 +1934,10 @@ export function createData(config: CreateDataInput) { }, sync(sessionID: string) { return sync.run(`session.permission:${sessionID}`, async () => { - setStore("session", "permission", sessionID, await api().permission.list({ sessionID })) + const started = deletionEpoch + const list = await api().permission.list({ sessionID }).catch(evictMissing) + if ((deletedAt.get(sessionID) ?? 0) > started) return + setStore("session", "permission", sessionID, list) }) }, invalidate(sessionID: string) { @@ -1924,7 +1984,10 @@ export function createData(config: CreateDataInput) { ]) return } - setStore("session", "form", sessionID, await api().session.form.list({ sessionID })) + const started = deletionEpoch + const list = await api().session.form.list({ sessionID }).catch(evictMissing) + if ((deletedAt.get(sessionID) ?? 0) > started) return + setStore("session", "form", sessionID, list) }) }, invalidate(sessionID: string, ref?: LocationRef) { diff --git a/packages/client/test/solid-refresh.test.ts b/packages/client/test/solid-refresh.test.ts index e54cb5a1315..3c4439fbacf 100644 --- a/packages/client/test/solid-refresh.test.ts +++ b/packages/client/test/solid-refresh.test.ts @@ -249,4 +249,166 @@ test("invalidations that land before a queued reload starts are absorbed by it", } finally { setup.dispose() } +}) + +test("event-driven session reads evict missing sessions without reporting an error, while explicit reads still reject", async () => { + const listeners = new Set[0]>() + const errors: unknown[] = [] + const session: SessionInfo = { + id: "ses_ephemeral", + projectID: "project", + cost: 0, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + time: { created: 0, updated: 0, idle: 1 }, + location: { directory: "/project" }, + } + const api = OpenCode.make({ + baseUrl: "http://opencode.local", + fetch: async () => + Response.json( + { _tag: "SessionNotFoundError", sessionID: session.id, message: `Session not found: ${session.id}` }, + { status: 404 }, + ), + }) + const setup = createRoot((dispose) => ({ + data: createData({ + api: () => api, + directory: "/project", + event: { + on: () => () => {}, + listen(handler) { + listeners.add(handler) + return () => listeners.delete(handler) + }, + }, + onError: (error) => errors.push(error), + }), + dispose, + })) + const viewed: OpenCodeEvent = { + id: "evt_ephemeral_viewed", + created: 2, + type: "session.viewed", + durable: { aggregateID: session.id, seq: 1, version: 1 }, + data: { sessionID: session.id, idle: 2 }, + } + try { + setup.data.session.remember(session) + expect(setup.data.session.get(session.id)).toBeDefined() + listeners.forEach((listener) => listener({ name: viewed.type, details: viewed })) + const deadline = Date.now() + 2_000 + while (!setup.data.session.missing(session.id)) { + if (Date.now() > deadline) throw new Error("Timed out waiting for missing-session eviction") + await Bun.sleep(5) + } + expect(errors).toEqual([]) + expect(setup.data.session.get(session.id)).toBeUndefined() + expect(setup.data.session.missing(session.id)).toBe(true) + + await expect(setup.data.session.sync(session.id)).rejects.toMatchObject({ + _tag: "SessionNotFoundError", + sessionID: session.id, + }) + expect(errors).toEqual([]) + } finally { + setup.dispose() + } +}) + +test("delayed metadata and family reads do not resurrect sessions deleted while in flight", async () => { + const listeners = new Set[0]>() + const makeSession = (id: string, parentID?: string): SessionInfo => ({ + id, + projectID: "project", + ...(parentID ? { parentID } : {}), + cost: 0, + tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, + time: { created: 0, updated: 0 }, + location: { directory: "/project" }, + }) + const root = makeSession("ses_root") + const child = makeSession("ses_child", root.id) + const ownStarted = Promise.withResolvers() + const ownRelease = Promise.withResolvers() + const familyStarted = Promise.withResolvers() + const familyRelease = Promise.withResolvers() + const requests: string[] = [] + const api = OpenCode.make({ + baseUrl: "http://opencode.local", + fetch: async (input, init) => { + const url = new URL((input instanceof Request ? input : new Request(input, init)).url) + requests.push(`${url.pathname}${url.search}`) + if (url.pathname === `/api/session/${root.id}`) return Response.json({ data: root }) + if (url.pathname === "/api/session" && url.searchParams.get("parentID") === root.id) { + familyStarted.resolve() + await familyRelease.promise + return Response.json({ data: [child], cursor: {} }) + } + if (url.pathname === `/api/session/${child.id}` && requests.filter((item) => item === `/api/session/${child.id}`).length === 1) { + ownStarted.resolve() + await ownRelease.promise + return Response.json({ data: child }) + } + return Response.json( + { _tag: "SessionNotFoundError", sessionID: child.id, message: `Session not found: ${child.id}` }, + { status: 404 }, + ) + }, + }) + const setup = createRoot((dispose) => ({ + data: createData({ + api: () => api, + directory: "/project", + event: { + on: () => () => {}, + listen(handler) { + listeners.add(handler) + return () => listeners.delete(handler) + }, + }, + }), + dispose, + })) + const emitDeleted = (sessionID: string, seq: number) => { + const event: OpenCodeEvent = { + id: `evt_del_${seq}`, + created: seq, + type: "session.deleted", + durable: { aggregateID: sessionID, seq, version: 1 }, + data: { sessionID }, + } + listeners.forEach((listener) => listener({ name: event.type, details: event })) + } + try { + // Own metadata read started before deletion must not republish. + setup.data.session.remember(child) + setup.data.session.invalidate(child.id) + const ownSync = setup.data.session.sync(child.id) + await ownStarted.promise + emitDeleted(child.id, 1) + expect(setup.data.session.get(child.id)).toBeUndefined() + ownRelease.resolve() + await ownSync + expect(setup.data.session.get(child.id)).toBeUndefined() + + // Parent family read started before child deletion must not republish or mark child synced. + setup.data.session.remember(root) + setup.data.session.remember(child) + const familySync = setup.data.session.sync(root.id, { children: true }) + await familyStarted.promise + emitDeleted(child.id, 2) + expect(setup.data.session.get(child.id)).toBeUndefined() + familyRelease.resolve() + await familySync + expect(setup.data.session.get(child.id)).toBeUndefined() + expect(setup.data.session.family(root.id)).toEqual([root.id]) + await expect(setup.data.session.sync(child.id)).rejects.toMatchObject({ + _tag: "SessionNotFoundError", + sessionID: child.id, + }) + } finally { + ownRelease.resolve() + familyRelease.resolve() + setup.dispose() + } }) diff --git a/packages/gui-plugins/src/browser/connection.test.ts b/packages/gui-plugins/src/browser/connection.test.ts index 83d68097ac5..1f7e5904df3 100644 --- a/packages/gui-plugins/src/browser/connection.test.ts +++ b/packages/gui-plugins/src/browser/connection.test.ts @@ -350,3 +350,21 @@ test.each([ app.connection.dispose() } }) + +test("browser.pane.missing stops retry backoff without surfacing an error and wakes only when created", () => { + jest.useFakeTimers() + const app = fixture() + + try { + app.emit(0, { type: "state", state: null, error: "browser.pane.missing" }) + jest.advanceTimersByTime(60_000) + app.connection.wake() + expect(app.calls).toHaveLength(1) + expect(app.states.at(-1)?.error).toBeUndefined() + + app.connection.wake(true) + expect(app.calls).toHaveLength(2) + } finally { + app.connection.dispose() + } +}) diff --git a/packages/gui-plugins/src/browser/connection.ts b/packages/gui-plugins/src/browser/connection.ts index 66998b6ac9d..45252928e74 100644 --- a/packages/gui-plugins/src/browser/connection.ts +++ b/packages/gui-plugins/src/browser/connection.ts @@ -192,14 +192,18 @@ export function createConnection(input: { return publish() } - if (event.error === "browser.pane.unsupported" || event.error === "browser.pane.replaced") { + if ( + event.error === "browser.pane.unsupported" || + event.error === "browser.pane.replaced" || + event.error === "browser.pane.missing" + ) { blocked = true registration.close() state.registration = undefined state.ready = false state.embeds = {} state.browser = null - state.error = event.error + state.error = event.error === "browser.pane.missing" ? undefined : event.error publish() return @@ -246,7 +250,9 @@ export function createConnection(input: { } return { - wake() { + wake(unblock = false) { + if (unblock) blocked = false + // Passive focus, pointer, and key edges wake an idle-evicted pane without bypassing transport backoff. if (retry === undefined) register() }, diff --git a/packages/gui-plugins/src/browser/model.ts b/packages/gui-plugins/src/browser/model.ts index 6029191e7d6..32d312505cd 100644 --- a/packages/gui-plugins/src/browser/model.ts +++ b/packages/gui-plugins/src/browser/model.ts @@ -278,7 +278,7 @@ export function createModel(ctx: SetupContext) { (data) => { onCleanup( data.on("session.created", (event) => { - if (event.data.sessionID === ref.id) entry.connection.wake() + if (event.data.sessionID === ref.id) entry.connection.wake(true) }), ) onCleanup( diff --git a/packages/gui-plugins/src/browser/pane.ts b/packages/gui-plugins/src/browser/pane.ts index 1f5e2397f19..96ad4405629 100644 --- a/packages/gui-plugins/src/browser/pane.ts +++ b/packages/gui-plugins/src/browser/pane.ts @@ -3,7 +3,7 @@ import { Browser } from "@opencode/plugin-browser/rpc" import { OpenCode } from "@opencode/client/effect" import { SessionID } from "@opencode/schema/session-id" import electron, { type BrowserWindow } from "electron" -import { Deferred, Effect, ManagedRuntime, Queue, Schedule, Schema, Stream } from "effect" +import { Deferred, Effect, ManagedRuntime, Predicate, Queue, Schedule, Schema, Stream } from "effect" import { HttpClient, HttpClientRequest } from "effect/http" import type { BuiltinMainStorage } from "@opencode/plugin/gui/builtin" import type { Embeds, Persisted, ServerEndpoints, Windows } from "@opencode/plugin/gui/main" @@ -118,8 +118,15 @@ export function createBrowserPane(input: { .webRequest.onBeforeRequest({ urls: ["file://*/*"] }, (details, callback) => callback({ cancel: !fileURLWithin(details.url, entry.fileRoots) }), ) + // "unsupported" means the server has no browser plugin; the renderer stops retrying. - let reason: "browser.pane.unsupported" | "browser.pane.replaced" | "browser.pane.suspended" | undefined + let reason: + | "browser.pane.unsupported" + | "browser.pane.replaced" + | "browser.pane.suspended" + | "browser.pane.missing" + | undefined + let attached = false const stop = () => close(entry, reason) @@ -293,6 +300,13 @@ export function createBrowserPane(input: { Effect.scoped, Effect.tapError((error) => Effect.sync(() => { + if (Predicate.isTagged(error, "SessionNotFoundError")) { + reason = "browser.pane.missing" + restore.remove(entry.storageKey) + + return + } + const type = error instanceof Object && "type" in error ? error.type : undefined if (type === "rpc.unavailable" && attached) {