@sanity/sdk 2.8.0 → 2.10.0

package/src/auth/studioAuth.ts

@@ -9,7 +9,7 @@ import {refreshStampedToken} from './refreshStampedToken'
 import {checkForCookieAuth, getStudioTokenFromLocalStorage} from './studioModeAuth'
 import {subscribeToStateAndFetchCurrentUser} from './subscribeToStateAndFetchCurrentUser'
 import {subscribeToStorageEventsAndSetToken} from './subscribeToStorageEventsAndSetToken'
-import {getDefaultStorage} from './utils'
+import {createLoggedInAuthState, getDefaultStorage} from './utils'
 
 /**
  * Resolves the initial auth state for Studio mode.
@@ -55,7 +55,7 @@ export function getStudioInitialState(options: AuthStrategyOptions): AuthStrateg
 
   if (providedToken) {
     return {
-      authState: {type: AuthStateType.LOGGED_IN, token: providedToken, currentUser: null},
+      authState: createLoggedInAuthState(providedToken, null),
       storageKey: studioStorageKey,
       storageArea,
       authMethod,
@@ -65,7 +65,7 @@ export function getStudioInitialState(options: AuthStrategyOptions): AuthStrateg
 
   if (token) {
     return {
-      authState: {type: AuthStateType.LOGGED_IN, token, currentUser: null},
+      authState: createLoggedInAuthState(token, null),
       storageKey: studioStorageKey,
       storageArea,
       authMethod: 'localstorage',
@@ -115,14 +115,29 @@ export function initializeStudioAuth(
 
 /**
  * Subscribe to a reactive token source from the Studio workspace.
- * The Studio is the single authority for auth — the SDK does not run
- * its own token refresher or cookie auth checks.
+ *
+ * When the token source emits a non-null token, the SDK uses it directly.
+ * When it emits `null`, the behavior depends on the `authenticated` flag
+ * from the Studio's workspace config:
+ *
+ * - `authenticated: true` — the Studio has already verified the user is
+ *   logged in (e.g. via cookie auth). The SDK treats the null token as
+ *   cookie-based auth and stays in the LOGGED_IN state.
+ *
+ * - `authenticated` absent/false — the user is genuinely not authenticated;
+ *   transition to LOGGED_OUT.
+ *
+ * No async cookie probing is needed here because this code path only runs
+ * when a Studio provides SDKStudioContext, and the Studio's Workspace type
+ * always includes `authenticated`. The async `checkForCookieAuth` fallback
+ * remains in `initializeWithFallback` for the non-Studio path.
  */
 function initializeWithTokenSource(
   context: StoreContext<AuthStoreState>,
   tokenSource: TokenSource,
 ): {dispose: () => void; tokenRefresherStarted: boolean} {
   const subscriptions: Subscription[] = []
+  const studioAuthenticated = context.instance.config.studio?.authenticated === true
 
   // Subscribe to the current user fetcher — runs whenever auth state changes
   subscriptions.push(subscribeToStateAndFetchCurrentUser(context, {useProjectHostname: true}))
@@ -132,11 +147,23 @@ function initializeWithTokenSource(
     next: (token) => {
       const {state} = context
       if (token) {
+        // Studio provided a real token — use it directly
         state.set('studioTokenSource', (prev) => ({
           options: {...prev.options, authMethod: undefined},
-          authState: {type: AuthStateType.LOGGED_IN, token, currentUser: null},
+          authState: createLoggedInAuthState(token, null),
+        }))
+      } else if (studioAuthenticated) {
+        // The Studio says the user is authenticated — null token means
+        // cookie-based auth is in use. Stay logged in with cookie method.
+        state.set('studioTokenSourceCookieAuth', (prev) => ({
+          options: {...prev.options, authMethod: 'cookie'},
+          authState:
+            prev.authState.type === AuthStateType.LOGGED_IN
+              ? prev.authState
+              : createLoggedInAuthState('', null),
         }))
       } else {
+        // No token and Studio doesn't confirm authentication — logged out
         state.set('studioTokenSourceLoggedOut', (prev) => ({
           options: {...prev.options, authMethod: undefined},
           authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},
@@ -193,7 +220,7 @@ function initializeWithFallback(
           authState:
             prev.authState.type === AuthStateType.LOGGED_IN
               ? prev.authState
-              : {type: AuthStateType.LOGGED_IN, token: '', currentUser: null},
+              : createLoggedInAuthState('', null),
         }))
       })
     }

package/src/auth/studioModeAuth.ts

@@ -1,5 +1,6 @@
 import {type ClientConfig, type SanityClient} from '@sanity/client'
 
+import {REQUEST_TAG_PREFIX} from './authConstants'
 import {getTokenFromStorage} from './utils'
 
 /**
@@ -25,7 +26,7 @@ export async function checkForCookieAuth(
     const client = clientFactory({
       projectId,
       useCdn: false,
-      requestTagPrefix: 'sdk',
+      requestTagPrefix: REQUEST_TAG_PREFIX,
       timeout: COOKIE_AUTH_TIMEOUT_MS,
     })
     const user = await client.request({

package/src/auth/subscribeToStateAndFetchCurrentUser.test.ts

@@ -40,7 +40,11 @@ describe('subscribeToStateAndFetchCurrentUser', () => {
       useProjectHostname: false,
       useCdn: false,
     })
-    expect(mockRequest).toHaveBeenCalledWith({method: 'GET', uri: '/users/me'})
+    expect(mockRequest).toHaveBeenCalledWith({
+      method: 'GET',
+      uri: '/users/me',
+      tag: 'users.get-current',
+    })
 
     subscription.unsubscribe()
   })
@@ -76,7 +80,11 @@ describe('subscribeToStateAndFetchCurrentUser', () => {
       useProjectHostname: false,
       useCdn: false,
     })
-    expect(mockRequest).toHaveBeenCalledWith({method: 'GET', uri: '/users/me'})
+    expect(mockRequest).toHaveBeenCalledWith({
+      method: 'GET',
+      uri: '/users/me',
+      tag: 'users.get-current',
+    })
 
     subscription.unsubscribe()
   })

package/src/auth/subscribeToStateAndFetchCurrentUser.ts

@@ -60,7 +60,11 @@ export const subscribeToStateAndFetchCurrentUser = (
         }),
       ),
       switchMap((client) =>
-        client.observable.request<CurrentUser>({uri: '/users/me', method: 'GET'}),
+        client.observable.request<CurrentUser>({
+          uri: '/users/me',
+          method: 'GET',
+          tag: 'users.get-current',
+        }),
       ),
     )
 

package/src/auth/subscribeToStorageEventsAndSetToken.ts

@@ -3,7 +3,7 @@ import {defer, distinctUntilChanged, filter, map, type Subscription} from 'rxjs'
 import {type StoreContext} from '../store/defineStore'
 import {AuthStateType} from './authStateType'
 import {type AuthStoreState} from './authStore'
-import {getStorageEvents, getTokenFromStorage} from './utils'
+import {createLoggedInAuthState, getStorageEvents, getTokenFromStorage} from './utils'
 
 export const subscribeToStorageEventsAndSetToken = ({
   state,
@@ -22,7 +22,7 @@ export const subscribeToStorageEventsAndSetToken = ({
   return tokenFromStorage$.subscribe((token) => {
     state.set('updateTokenFromStorageEvent', {
       authState: token
-        ? {type: AuthStateType.LOGGED_IN, token, currentUser: null}
+        ? createLoggedInAuthState(token, null)
         : {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},
     })
   })

package/src/auth/utils.ts

@@ -1,7 +1,40 @@
 import {type ClientError} from '@sanity/client'
+import {type CurrentUser} from '@sanity/types'
 import {EMPTY, fromEvent, Observable} from 'rxjs'
 
 import {AUTH_CODE_PARAM, DEFAULT_BASE} from './authConstants'
+import {AuthStateType} from './authStateType'
+import {type LoggedInAuthState} from './authStore'
+
+/**
+ * Creates a properly initialized {@link LoggedInAuthState}.
+ *
+ * For stamped tokens (containing `"-st"`), `lastTokenRefresh` is set to
+ * `Date.now()` so that the visibility-change handler in
+ * {@link refreshStampedToken} does not trigger an unnecessary refresh the
+ * first time the tab becomes visible.
+ *
+ * @param token - The auth token.
+ * @param currentUser - The current user, or `null` if not yet fetched.
+ * @param existingLastTokenRefresh - An existing timestamp to preserve
+ *   (e.g. when updating a token while keeping the previous refresh time).
+ * @internal
+ */
+export function createLoggedInAuthState(
+  token: string,
+  currentUser: CurrentUser | null,
+  existingLastTokenRefresh?: number,
+): LoggedInAuthState {
+  const isStampedToken = token.includes('-st')
+  const lastTokenRefresh = existingLastTokenRefresh ?? (isStampedToken ? Date.now() : undefined)
+
+  return {
+    type: AuthStateType.LOGGED_IN,
+    token,
+    currentUser,
+    ...(lastTokenRefresh !== undefined && {lastTokenRefresh}),
+  }
+}
 
 export function getAuthCode(callbackUrl: string | undefined, locationHref: string): string | null {
   const loc = new URL(locationHref, DEFAULT_BASE)

package/src/client/clientStore.test.ts

@@ -68,6 +68,20 @@ describe('clientStore', () => {
       })
     })
 
+    it('should pass staging apiHost when __SANITY_STAGING__ is true and no explicit apiHost', () => {
+      vi.stubGlobal('__SANITY_STAGING__', true)
+
+      getClient(instance, {apiVersion: '2024-11-12'})
+
+      expect(vi.mocked(createClient)).toHaveBeenCalledWith(
+        expect.objectContaining({
+          apiHost: 'https://api.sanity.work',
+        }),
+      )
+
+      vi.unstubAllGlobals()
+    })
+
     it('should throw when using disallowed configuration keys', () => {
       expect(() =>
         getClient(instance, {
@@ -176,17 +190,17 @@ describe('clientStore', () => {
     })
   })
 
-  describe('source handling', () => {
-    it('should create client when source is provided', () => {
+  describe('resource handling', () => {
+    it('should create client when resource is provided', () => {
       const client = getClient(instance, {
         apiVersion: '2024-11-12',
-        source: {projectId: 'source-project', dataset: 'source-dataset'},
+        resource: {projectId: 'source-project', dataset: 'source-dataset'},
       })
 
       expect(vi.mocked(createClient)).toHaveBeenCalledWith(
         expect.objectContaining({
-          'apiVersion': '2024-11-12',
-          '~experimental_resource': {type: 'dataset', id: 'source-project.source-dataset'},
+          apiVersion: '2024-11-12',
+          resource: {type: 'dataset', id: 'source-project.source-dataset'},
         }),
       )
       // Client should be projectless - no projectId/dataset in config
@@ -194,21 +208,21 @@ describe('clientStore', () => {
       expect(client.config()).not.toHaveProperty('dataset')
       expect(client.config()).toEqual(
         expect.objectContaining({
-          '~experimental_resource': {type: 'dataset', id: 'source-project.source-dataset'},
+          resource: {type: 'dataset', id: 'source-project.source-dataset'},
         }),
       )
     })
 
-    it('should create resource when source has array sourceId and be projectless', () => {
+    it('should create resource when resource has array resourceId and be projectless', () => {
       const client = getClient(instance, {
         apiVersion: '2024-11-12',
-        source: {mediaLibraryId: 'media-lib-123'},
+        resource: {mediaLibraryId: 'media-lib-123'},
       })
 
       expect(vi.mocked(createClient)).toHaveBeenCalledWith(
         expect.objectContaining({
-          '~experimental_resource': {type: 'media-library', id: 'media-lib-123'},
-          'apiVersion': '2024-11-12',
+          resource: {type: 'media-library', id: 'media-lib-123'},
+          apiVersion: '2024-11-12',
         }),
       )
       // Client should be projectless - no projectId/dataset in config
@@ -216,21 +230,21 @@ describe('clientStore', () => {
       expect(client.config()).not.toHaveProperty('dataset')
       expect(client.config()).toEqual(
         expect.objectContaining({
-          '~experimental_resource': {type: 'media-library', id: 'media-lib-123'},
+          resource: {type: 'media-library', id: 'media-lib-123'},
         }),
       )
     })
 
-    it('should create resource when canvas source is provided and be projectless', () => {
+    it('should create resource when canvas resource is provided and be projectless', () => {
       const client = getClient(instance, {
         apiVersion: '2024-11-12',
-        source: {canvasId: 'canvas-123'},
+        resource: {canvasId: 'canvas-123'},
       })
 
       expect(vi.mocked(createClient)).toHaveBeenCalledWith(
         expect.objectContaining({
-          '~experimental_resource': {type: 'canvas', id: 'canvas-123'},
-          'apiVersion': '2024-11-12',
+          resource: {type: 'canvas', id: 'canvas-123'},
+          apiVersion: '2024-11-12',
         }),
       )
       // Client should be projectless - no projectId/dataset in config
@@ -238,38 +252,38 @@ describe('clientStore', () => {
       expect(client.config()).not.toHaveProperty('dataset')
       expect(client.config()).toEqual(
         expect.objectContaining({
-          '~experimental_resource': {type: 'canvas', id: 'canvas-123'},
+          resource: {type: 'canvas', id: 'canvas-123'},
         }),
       )
     })
 
-    it('should create projectless client when source is provided, ignoring instance config', () => {
+    it('should create projectless client when resource is provided, ignoring instance config', () => {
       const client = getClient(instance, {
         apiVersion: '2024-11-12',
-        source: {projectId: 'source-project', dataset: 'source-dataset'},
+        resource: {projectId: 'source-project', dataset: 'source-dataset'},
       })
 
-      // Client should be projectless - source takes precedence, instance config is ignored
+      // Client should be projectless - resource takes precedence, instance config is ignored
       expect(client.config()).not.toHaveProperty('projectId')
       expect(client.config()).not.toHaveProperty('dataset')
       expect(client.config()).toEqual(
         expect.objectContaining({
-          '~experimental_resource': {type: 'dataset', id: 'source-project.source-dataset'},
+          resource: {type: 'dataset', id: 'source-project.source-dataset'},
         }),
       )
     })
 
-    it('should warn when both source and explicit projectId/dataset are provided', () => {
+    it('should warn when both resource and explicit projectId/dataset are provided', () => {
       const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
       const client = getClient(instance, {
         apiVersion: '2024-11-12',
-        source: {projectId: 'source-project', dataset: 'source-dataset'},
+        resource: {projectId: 'source-project', dataset: 'source-dataset'},
         projectId: 'explicit-project',
         dataset: 'explicit-dataset',
       })
 
       expect(consoleSpy).toHaveBeenCalledWith(
-        'Both source and explicit projectId/dataset are provided. The source will be used and projectId/dataset will be ignored.',
+        'Both resource and explicit projectId/dataset are provided. The resource will be used and projectId/dataset will be ignored.',
       )
       // Client should still be projectless despite explicit projectId/dataset
       expect(client.config()).not.toHaveProperty('projectId')
@@ -277,18 +291,18 @@ describe('clientStore', () => {
       consoleSpy.mockRestore()
     })
 
-    it('should create different clients for different sources', () => {
+    it('should create different clients for different resources', () => {
       const client1 = getClient(instance, {
         apiVersion: '2024-11-12',
-        source: {projectId: 'source-project', dataset: 'source-dataset'},
+        resource: {projectId: 'source-project', dataset: 'source-dataset'},
       })
       const client2 = getClient(instance, {
         apiVersion: '2024-11-12',
-        source: {mediaLibraryId: 'media-lib-123'},
+        resource: {mediaLibraryId: 'media-lib-123'},
       })
       const client3 = getClient(instance, {
         apiVersion: '2024-11-12',
-        source: {canvasId: 'canvas-123'},
+        resource: {canvasId: 'canvas-123'},
       })
 
       expect(client1).not.toBe(client2)
@@ -297,14 +311,14 @@ describe('clientStore', () => {
       expect(vi.mocked(createClient)).toHaveBeenCalledTimes(3)
     })
 
-    it('should reuse clients with identical source configurations', () => {
+    it('should reuse clients with identical resource configurations', () => {
       const client1 = getClient(instance, {
         apiVersion: '2024-11-12',
-        source: {projectId: 'source-project', dataset: 'source-dataset'},
+        resource: {projectId: 'source-project', dataset: 'source-dataset'},
       })
       const client2 = getClient(instance, {
         apiVersion: '2024-11-12',
-        source: {projectId: 'source-project', dataset: 'source-dataset'},
+        resource: {projectId: 'source-project', dataset: 'source-dataset'},
       })
 
       expect(client1).toBe(client2)

package/src/client/clientStore.ts

@@ -1,16 +1,17 @@
 import {type ClientConfig, createClient, type SanityClient} from '@sanity/client'
-import {pick} from 'lodash-es'
 
 import {getAuthMethodState, getTokenState} from '../auth/authStore'
 import {
-  type DocumentSource,
-  isCanvasSource,
-  isDatasetSource,
-  isMediaLibrarySource,
+  type DocumentResource,
+  isCanvasResource,
+  isDatasetResource,
+  isMediaLibraryResource,
 } from '../config/sanityConfig'
 import {bindActionGlobally} from '../store/createActionBinder'
 import {createStateSourceAction} from '../store/createStateSourceAction'
 import {defineStore, type StoreContext} from '../store/defineStore'
+import {getStagingApiHost} from '../utils/getStagingApiHost'
+import {pickProperties} from '../utils/object'
 
 const DEFAULT_API_VERSION = '2024-11-12'
 const DEFAULT_REQUEST_TAG_PREFIX = 'sanity.sdk'
@@ -30,22 +31,21 @@ type AllowedClientConfigKey =
   | 'useProjectHostname'
 
 const allowedKeys = Object.keys({
-  'apiHost': null,
-  'useCdn': null,
-  'token': null,
-  'perspective': null,
-  'proxy': null,
-  'withCredentials': null,
-  'timeout': null,
-  'maxRetries': null,
-  'dataset': null,
-  'projectId': null,
-  'scope': null,
-  'apiVersion': null,
-  'requestTagPrefix': null,
-  'useProjectHostname': null,
-  '~experimental_resource': null,
-  'source': null,
+  apiHost: null,
+  useCdn: null,
+  token: null,
+  perspective: null,
+  proxy: null,
+  withCredentials: null,
+  timeout: null,
+  maxRetries: null,
+  dataset: null,
+  projectId: null,
+  scope: null,
+  apiVersion: null,
+  requestTagPrefix: null,
+  useProjectHostname: null,
+  resource: null,
 } satisfies Record<keyof ClientOptions, null>) as (keyof ClientOptions)[]
 
 const DEFAULT_CLIENT_CONFIG: ClientConfig = {
@@ -66,11 +66,6 @@ export interface ClientStoreState {
   authMethod?: 'localstorage' | 'cookie'
 }
 
-interface ClientResource {
-  type: 'dataset' | 'media-library' | 'canvas'
-  id: string
-}
-
 /**
  * Options used when retrieving a client instance from the client store.
  *
@@ -93,20 +88,17 @@ export interface ClientOptions extends Pick<ClientConfig, AllowedClientConfigKey
    * and the global client ('global'). When set to `'global'`, the global client
    * is used.
    */
-  'scope'?: 'default' | 'global'
+  scope?: 'default' | 'global'
   /**
    * A required string indicating the API version for the client.
    */
-  'apiVersion': string
-  /**
-   * @internal
-   */
-  '~experimental_resource'?: ClientConfig['~experimental_resource']
+  apiVersion: string
 
   /**
    * @internal
+   * The SDK resource to use for the client -- this will get transformed into a ClientConfig resource.
    */
-  'source'?: DocumentSource
+  resource?: DocumentResource
 }
 
 const clientStore = defineStore<ClientStoreState>({
@@ -143,7 +135,13 @@ const listenToAuthMethod = ({instance, state}: StoreContext<ClientStoreState>) =
   })
 }
 
-const getClientConfigKey = (options: ClientOptions) => JSON.stringify(pick(options, ...allowedKeys))
+type ClientInstanceCacheKeyInput = ClientConfig &
+  Partial<Pick<ClientOptions, 'scope'>> & {
+    apiVersion: string
+  }
+
+const getClientConfigKey = (options: ClientInstanceCacheKeyInput) =>
+  JSON.stringify(pickProperties(options, allowedKeys))
 
 /**
  * Retrieves a Sanity client instance configured with the provided options.
@@ -181,41 +179,44 @@ export const getClient = bindActionGlobally(
     const tokenFromState = state.get().token
     const {clients, authMethod} = state.get()
 
-    let resource: ClientResource | undefined
+    let resource: ClientConfig['resource'] | undefined
 
-    if (options.source) {
-      if (isDatasetSource(options.source)) {
-        resource = {type: 'dataset', id: `${options.source.projectId}.${options.source.dataset}`}
-      } else if (isMediaLibrarySource(options.source)) {
-        resource = {type: 'media-library', id: options.source.mediaLibraryId}
-      } else if (isCanvasSource(options.source)) {
-        resource = {type: 'canvas', id: options.source.canvasId}
+    if (options.resource) {
+      if (isDatasetResource(options.resource)) {
+        resource = {
+          type: 'dataset',
+          id: `${options.resource.projectId}.${options.resource.dataset}`,
+        }
+      } else if (isMediaLibraryResource(options.resource)) {
+        resource = {type: 'media-library', id: options.resource.mediaLibraryId}
+      } else if (isCanvasResource(options.resource)) {
+        resource = {type: 'canvas', id: options.resource.canvasId}
       }
     }
 
     const projectId = options.projectId ?? instance.config.projectId
     const dataset = options.dataset ?? instance.config.dataset
-    const apiHost = options.apiHost ?? instance.config.auth?.apiHost
+    const apiHost = options.apiHost ?? instance.config.auth?.apiHost ?? getStagingApiHost()
 
-    const effectiveOptions: ClientOptions = {
+    const effectiveOptions: ClientConfig & {apiVersion: string} = {
       ...DEFAULT_CLIENT_CONFIG,
       ...((options.scope === 'global' || !projectId || resource) && {useProjectHostname: false}),
       token: authMethod === 'cookie' ? undefined : (tokenFromState ?? undefined),
       ...options,
       ...(projectId && {projectId}),
       ...(dataset && {dataset}),
+      ...(resource ? {resource} : {resource: undefined}),
       ...(apiHost && {apiHost}),
-      ...(resource && {'~experimental_resource': resource}),
     }
 
-    // When a source is provided, don't use projectId/dataset - the client should be "projectless"
-    // The client code itself will ignore the non-source config, so we do this to prevent confusing the user.
+    // When a resource is provided, don't use projectId/dataset - the client should be "projectless"
+    // The client code itself will ignore the non-resource config, so we do this to prevent confusing the user.
     // (ref: https://github.com/sanity-io/client/blob/5c23f81f5ab93a53f5b22b39845c867988508d84/src/data/dataMethods.ts#L691)
     if (resource) {
       if (options.projectId || options.dataset) {
         // eslint-disable-next-line no-console
         console.warn(
-          'Both source and explicit projectId/dataset are provided. The source will be used and projectId/dataset will be ignored.',
+          'Both resource and explicit projectId/dataset are provided. The resource will be used and projectId/dataset will be ignored.',
         )
       }
       delete effectiveOptions.projectId

package/src/comlink/controller/actions/getOrCreateChannel.ts

@@ -1,7 +1,7 @@
 import {type ChannelInput, type ChannelInstance} from '@sanity/comlink'
-import {isEqual} from 'lodash-es'
 
 import {type StoreContext} from '../../../store/defineStore'
+import {isDeepEqual} from '../../../utils/object'
 import {type FrameMessage, type WindowMessage} from '../../types'
 import {type ComlinkControllerState} from '../comlinkControllerStore'
 
@@ -25,7 +25,7 @@ export const getOrCreateChannel = (
 
   // limit channels to one per name
   if (existing) {
-    if (!isEqual(existing.options, options)) {
+    if (!isDeepEqual(existing.options, options)) {
       throw new Error(`Channel "${options.name}" already exists with different options`)
     }
 

package/src/comlink/node/actions/getOrCreateNode.ts

@@ -1,7 +1,7 @@
 import {createNode, type Node, type NodeInput} from '@sanity/comlink'
-import {isEqual} from 'lodash-es'
 
 import {type StoreContext} from '../../../store/defineStore'
+import {isDeepEqual} from '../../../utils/object'
 import {type FrameMessage, type WindowMessage} from '../../types'
 import {type ComlinkNodeState} from '../comlinkNodeStore'
 
@@ -14,7 +14,7 @@ export const getOrCreateNode = (
 
   // limit nodes to one per name
   if (existing) {
-    if (!isEqual(existing.options, options)) {
+    if (!isDeepEqual(existing.options, options)) {
       throw new Error(`Node "${options.name}" already exists with different options`)
     }
 

package/src/comlink/node/getNodeState.ts

@@ -3,6 +3,7 @@ import {createSelector} from 'reselect'
 
 import {bindActionGlobally} from '../../store/createActionBinder'
 import {createStateSourceAction, type SelectorContext} from '../../store/createStateSourceAction'
+import {setCleanupTimeout} from '../../utils/setCleanupTimeout'
 import {type FrameMessage, type WindowMessage} from '../types'
 import {
   type ComlinkNodeState,
@@ -57,7 +58,7 @@ export const getNodeState = bindActionGlobally(
       subs.add(subscriberId)
 
       return () => {
-        setTimeout(() => {
+        setCleanupTimeout(() => {
           const activeSubs = state.get().subscriptions.get(nodeName)
           if (activeSubs) {
             activeSubs.delete(subscriberId)