@sanity/sdk-react 3.0.0-rc.0 → 3.0.0-rc.1

package/package.json

@@ -1,30 +1,37 @@
 {
   "name": "@sanity/sdk-react",
-  "version": "3.0.0-rc.0",
+  "version": "3.0.0-rc.1",
   "private": false,
   "description": "Sanity SDK React toolkit for Content OS",
   "keywords": [
-    "sanity",
-    "sdk",
-    "content operating system",
     "cms",
+    "content",
+    "content operating system",
     "headless",
     "realtime",
-    "content"
+    "sanity",
+    "sdk"
   ],
   "homepage": "https://github.com/sanity-io/sdk/tree/main/packages/react/README.md",
   "bugs": {
     "url": "https://github.com/sanity-io/sdk/issues"
   },
+  "license": "MIT",
+  "author": "Sanity <developers@sanity.io>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/sanity-io/sdk.git",
     "directory": "packages/react"
   },
-  "license": "MIT",
-  "author": "Sanity <developers@sanity.io>",
-  "sideEffects": false,
+  "files": [
+    "dist",
+    "src"
+  ],
   "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "source": "./src/_exports/index.ts",
@@ -33,71 +40,61 @@
     },
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist",
-    "src"
-  ],
-  "browserslist": "extends @sanity/browserslist-config",
-  "prettier": "@sanity/prettier-config",
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
-    "@sanity/client": "^7.14.1",
-    "@sanity/message-protocol": "^0.18.0",
-    "@sanity/types": "^5.2.0",
-    "@types/lodash-es": "^4.17.12",
-    "lodash-es": "^4.17.21",
-    "react-error-boundary": "^5.0.0",
+    "@sanity/client": "^7.23.2",
+    "@sanity/message-protocol": "^0.23.0",
+    "@sanity/types": "^6.5.0",
+    "@sanity/workbench": "0.1.0-alpha.24",
+    "groq": "3.88.1-typegen-experimental.0",
+    "react-compiler-runtime": "^1.0.0",
+    "react-error-boundary": "^6.1.2",
     "rxjs": "^7.8.2",
-    "@sanity/sdk": "3.0.0-rc.0"
+    "xstate": "^5.31.0",
+    "@sanity/sdk": "3.0.0-rc.1"
   },
   "devDependencies": {
     "@sanity/browserslist-config": "^1.0.5",
-    "@sanity/comlink": "^3.1.1",
-    "@sanity/pkg-utils": "^8.1.29",
-    "@sanity/prettier-config": "^1.0.6",
+    "@sanity/comlink": "^4.0.1",
+    "@sanity/pkg-utils": "^10.9.2",
     "@testing-library/jest-dom": "^6.9.1",
-    "@testing-library/react": "^16.3.0",
-    "@types/node": "^22.19.1",
-    "@types/react": "^19.2.7",
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^24.13.3",
+    "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
-    "@vitejs/plugin-react": "^4.7.0",
-    "@vitest/coverage-v8": "3.2.4",
-    "babel-plugin-react-compiler": "19.1.0-rc.1",
-    "eslint": "^9.22.0",
-    "groq-js": "^1.22.0",
-    "jsdom": "^25.0.1",
-    "prettier": "^3.7.3",
-    "react": "^19.2.1",
-    "react-dom": "^19.2.1",
-    "rollup-plugin-visualizer": "^5.14.0",
-    "typescript": "^5.8.3",
-    "vite": "^6.3.4",
-    "vitest": "^3.2.4",
+    "@vitejs/plugin-react": "^6.0.3",
+    "@vitest/coverage-v8": "^4.1.10",
+    "babel-plugin-react-compiler": "^1.0.0",
+    "eslint": "^10.6.0",
+    "groq-js": "^2.0.0",
+    "jsdom": "^29.1.1",
+    "oxfmt": "^0.58.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "rollup-plugin-visualizer": "^7.0.1",
+    "typescript": "^6.0.3",
+    "vite": "^8.1.5",
+    "vitest": "^4.1.10",
     "@repo/config-eslint": "0.0.0",
     "@repo/config-test": "0.0.1",
     "@repo/package.bundle": "3.82.0",
-    "@repo/tsconfig": "0.0.1",
-    "@repo/package.config": "0.0.1"
+    "@repo/package.config": "0.0.1",
+    "@repo/tsconfig": "0.0.1"
   },
   "peerDependencies": {
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0"
-  },
-  "engines": {
-    "node": ">=20.19"
-  },
-  "publishConfig": {
-    "access": "public"
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
   },
+  "browserslist": "extends @sanity/browserslist-config",
   "scripts": {
     "build": "pkg build --strict --clean --check",
     "build:bundle": "vite build --configLoader runner --config package.bundle.ts",
     "clean": "rimraf dist",
     "dev": "pkg watch",
     "docs": "typedoc --json docs/typedoc.json --tsconfig ./tsconfig.dist.json",
-    "format": "prettier --write --cache --ignore-unknown .",
+    "format": "oxfmt",
     "lint": "eslint .",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",

package/src/_exports/index.ts

@@ -1,6 +1,4 @@
 export * from './sdk-react.ts'
 export * from '@sanity/sdk'
-
-// Explicitly re-export React-layer handle types to resolve ambiguity with @sanity/sdk versions.
-// These shadow the core (strict) versions for @sanity/sdk-react consumers.
-export {type DocumentHandle, type DocumentTypeHandle, type ResourceHandle} from './sdk-react.ts'
+// React-layer handles shadow core equivalents when imported from @sanity/sdk-react
+export type {DocumentHandle, DocumentTypeHandle, ResourceHandle} from './sdk-react.ts'

package/src/_exports/sdk-react.ts

@@ -1,21 +1,19 @@
 /**
  * @module exports
  */
-
-// React-layer handle types (relaxed) — shadow core versions for @sanity/sdk-react consumers.
-// resource is optional and resolved from context when not provided.
 export {AuthBoundary, type AuthBoundaryProps} from '../components/auth/AuthBoundary'
 export {SanityApp, type SanityAppProps} from '../components/SanityApp'
 export {SDKProvider, type SDKProviderProps} from '../components/SDKProvider'
-export {
-  type DocumentHandle as DocumentHandle,
-  type DocumentTypeHandle as DocumentTypeHandle,
-  type ResourceHandle as ResourceHandle,
-} from '../config/handles'
+export {type DocumentHandle, type DocumentTypeHandle, type ResourceHandle} from '../config/handles'
 export {ComlinkTokenRefreshProvider} from '../context/ComlinkTokenRefresh'
 export {renderSanityApp} from '../context/renderSanityApp'
 export {ResourceProvider, type ResourceProviderProps} from '../context/ResourceProvider'
+export {
+  SanityInstanceProvider,
+  type SanityInstanceProviderProps,
+} from '../context/SanityInstanceProvider'
 export {SDKStudioContext, type StudioWorkspaceHandle} from '../context/SDKStudioContext'
+export {useCheckPermissions} from '../hooks/access/useCheckPermissions'
 export {
   useAgentGenerate,
   useAgentPatch,
@@ -27,6 +25,15 @@ export {
   type AgentResourceContextOptions,
   useAgentResourceContext,
 } from '../hooks/agent/useAgentResourceContext'
+export {useApplication} from '../hooks/applications/useApplication'
+export {useApplications} from '../hooks/applications/useApplications'
+export {useCreateUserApplication} from '../hooks/applications/useCreateUserApplication'
+export {useDeleteApplication} from '../hooks/applications/useDeleteApplication'
+export {useDeleteUserApplication} from '../hooks/applications/useDeleteUserApplication'
+export {useUpdateApplication} from '../hooks/applications/useUpdateApplication'
+export {useUpdateUserApplication} from '../hooks/applications/useUpdateUserApplication'
+export {useUserApplication} from '../hooks/applications/useUserApplication'
+export {useUserApplications} from '../hooks/applications/useUserApplications'
 export {useAuthState} from '../hooks/auth/useAuthState'
 export {useAuthToken} from '../hooks/auth/useAuthToken'
 export {useCurrentUser} from '../hooks/auth/useCurrentUser'
@@ -48,10 +55,9 @@ export {
   type WindowConnection,
   type WindowMessageHandler,
 } from '../hooks/comlink/useWindowConnection'
-export {useResource} from '../hooks/context/useDefaultResource'
+export {useResource} from '../hooks/context/useResource'
 export {useSanityInstance} from '../hooks/context/useSanityInstance'
 export {useDashboardNavigate} from '../hooks/dashboard/useDashboardNavigate'
-export {useDispatchIntent} from '../hooks/dashboard/useDispatchIntent'
 export {useManageFavorite} from '../hooks/dashboard/useManageFavorite'
 export {
   type NavigateToStudioResult,
@@ -59,8 +65,10 @@ export {
 } from '../hooks/dashboard/useNavigateToStudioDocument'
 export {useRecordDocumentHistoryEvent} from '../hooks/dashboard/useRecordDocumentHistoryEvent'
 export {useStudioWorkspacesByProjectIdDataset} from '../hooks/dashboard/useStudioWorkspacesByProjectIdDataset'
+export {useWindowTitle} from '../hooks/dashboard/useWindowTitle'
 export {useDatasets} from '../hooks/datasets/useDatasets'
 export {useApplyDocumentActions} from '../hooks/document/useApplyDocumentActions'
+export {type CreateDocumentOverrides, useCreateDocument} from '../hooks/document/useCreateDocument'
 export {useDocument} from '../hooks/document/useDocument'
 export {useDocumentEvent} from '../hooks/document/useDocumentEvent'
 export {useDocumentPermissions} from '../hooks/document/useDocumentPermissions'
@@ -71,6 +79,12 @@ export {
   type DocumentsResponse,
   useDocuments,
 } from '../hooks/documents/useDocuments'
+export {type FetcherHookResult} from '../hooks/helpers/createFetcherHook'
+export {type MutationHookResult} from '../hooks/helpers/createMutationHook'
+export {useInstallation} from '../hooks/installations/useInstallation'
+export {useInstallations} from '../hooks/installations/useInstallations'
+export {useOrganization} from '../hooks/organizations/useOrganization'
+export {useOrganizations} from '../hooks/organizations/useOrganizations'
 export {
   type PaginatedDocumentsOptions,
   type PaginatedDocumentsResponse,
@@ -91,17 +105,12 @@ export {useProject} from '../hooks/projects/useProject'
 export {type ProjectWithoutMembers, useProjects} from '../hooks/projects/useProjects'
 export {useQuery} from '../hooks/query/useQuery'
 export {useActiveReleases} from '../hooks/releases/useActiveReleases'
+export {useAllReleases} from '../hooks/releases/useAllReleases'
+export {useApplyReleaseActions} from '../hooks/releases/useApplyReleaseActions'
 export {usePerspective} from '../hooks/releases/usePerspective'
 export {type UserResult, useUser} from '../hooks/users/useUser'
 export {type UsersResult, useUsers} from '../hooks/users/useUsers'
 export {REACT_SDK_VERSION} from '../version'
 export {type DatasetsResponse, type SanityProjectMember} from '@sanity/client'
 export type {Status as ComlinkStatus} from '@sanity/comlink'
-
-// Strict core versions — available for users who need explicit resource
-export {
-  type DocumentHandle as StrictDocumentHandle,
-  type DocumentTypeHandle as StrictDocumentTypeHandle,
-  type ResourceHandle as StrictResourceHandle,
-} from '@sanity/sdk'
 export {type SanityDocument, type SortOrderingItem} from '@sanity/types'

package/src/components/SDKProvider.test.tsx

@@ -1,68 +1,209 @@
+import {createSanityInstance, type SanityConfig} from '@sanity/sdk'
 import {render} from '@testing-library/react'
 import React from 'react'
-import {describe, expect, it, vi} from 'vitest'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
 
+import {useDashboardOrganizationId} from '../hooks/auth/useDashboardOrganizationId'
+import {resolveOrgResources} from '../utils/resolveOrgResources'
 import {SDKProvider} from './SDKProvider'
 
+const instance = createSanityInstance()
+
+// Returns the same object on every call so the module-level WeakMap cache works across renders.
+vi.mock('../hooks/context/useSanityInstance', () => {
+  return {useSanityInstance: () => instance}
+})
+
+vi.mock('../hooks/auth/useDashboardOrganizationId', () => ({
+  useDashboardOrganizationId: vi.fn(),
+}))
+
+vi.mock('../utils/resolveOrgResources', () => ({
+  resolveOrgResources: vi.fn(),
+}))
+
 vi.mock('../context/ResourceProvider', () => ({
-  ResourceProvider: ({children, resource}: {children: React.ReactNode; resource?: unknown}) => {
-    return (
-      <div data-testid="resource-provider" data-resource={JSON.stringify(resource ?? null)}>
-        {children}
-      </div>
-    )
-  },
+  ResourceProvider: ({
+    children,
+    // exclude fallback: it's a real ResourceProvider prop but not part of config
+    fallback: _fallback,
+    resource,
+    ...config
+  }: {
+    children: React.ReactNode
+    fallback?: React.ReactNode
+    resource?: {projectId?: string; dataset?: string}
+  }) => (
+    <div
+      data-testid="resource-provider"
+      data-config={JSON.stringify(config)}
+      data-resource={JSON.stringify(resource ?? null)}
+    >
+      {children}
+    </div>
+  ),
 }))
 
 vi.mock('./auth/AuthBoundary', () => ({
-  AuthBoundary: ({children}: {children: React.ReactNode}) => {
-    return <div data-testid="auth-boundary">{children}</div>
-  },
+  AuthBoundary: ({children, projectIds}: {children: React.ReactNode; projectIds?: string[]}) => (
+    <div data-testid="auth-boundary" data-project-ids={JSON.stringify(projectIds ?? [])}>
+      {children}
+    </div>
+  ),
 }))
 
+const mockResolveOrgResources = vi.mocked(resolveOrgResources)
+const mockUseDashboardOrganizationId = vi.mocked(useDashboardOrganizationId)
+
 describe('SDKProvider', () => {
-  it('renders a single ResourceProvider with AuthBoundary', () => {
-    const config = {}
-    const resources = {
-      default: {projectId: 'test-project', dataset: 'production'},
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockResolveOrgResources.mockResolvedValue({})
+    mockUseDashboardOrganizationId.mockReturnValue(undefined)
+  })
+
+  it('renders single ResourceProvider with AuthBoundary for a single config', () => {
+    const config = {
+      projectId: 'test-project',
+      dataset: 'production',
     }
 
-    const {getByTestId} = render(
-      <SDKProvider config={config} resources={resources} fallback={<div>Loading...</div>}>
+    const {getAllByTestId, getByTestId} = render(
+      <SDKProvider config={[config]} fallback={<div>Loading...</div>}>
         <div>Child Content</div>
       </SDKProvider>,
     )
 
-    const provider = getByTestId('resource-provider')
-    expect(provider).toBeInTheDocument()
+    // Should create a single ResourceProvider
+    const providers = getAllByTestId('resource-provider')
+    expect(providers.length).toBe(1)
+
+    // Should create an AuthBoundary inside
     expect(getByTestId('auth-boundary')).toBeInTheDocument()
 
-    // resource prop should be the default resource
-    expect(JSON.parse(provider.getAttribute('data-resource') || 'null')).toEqual({
+    // Verify provider has the correct config
+    expect(JSON.parse(providers[0].getAttribute('data-config') || '{}')).toEqual({
       projectId: 'test-project',
       dataset: 'production',
     })
   })
 
-  it('renders with multiple named resources', () => {
-    const config = {}
-    const resources = {
-      default: {projectId: 'project-1', dataset: 'production'},
-      secondary: {projectId: 'project-2', dataset: 'staging'},
-    }
+  it('renders a single ResourceProvider using the first config when multiple configs are provided', () => {
+    const configs = [
+      {
+        projectId: 'project-1',
+        dataset: 'production',
+      },
+      {
+        projectId: 'project-2',
+        dataset: 'staging',
+      },
+    ]
 
-    const {getByTestId} = render(
-      <SDKProvider config={config} resources={resources} fallback={<div>Loading...</div>}>
+    const {getAllByTestId, getByTestId} = render(
+      <SDKProvider config={configs} fallback={<div>Loading...</div>}>
         <div>Child Content</div>
       </SDKProvider>,
     )
 
-    const provider = getByTestId('resource-provider')
-    expect(provider).toBeInTheDocument()
+    // Should create a single ResourceProvider using the first config
+    const providers = getAllByTestId('resource-provider')
+    expect(providers.length).toBe(1)
 
-    expect(JSON.parse(provider.getAttribute('data-resource') || 'null')).toEqual({
+    // Should create an AuthBoundary inside
+    expect(getByTestId('auth-boundary')).toBeInTheDocument()
+
+    // Verify the provider uses the first config
+    expect(JSON.parse(providers[0].getAttribute('data-config') || '{}')).toEqual({
       projectId: 'project-1',
       dataset: 'production',
     })
   })
+
+  it('preserves non-resource config fields (e.g. studio auth, perspective) on the root provider', () => {
+    const tokenSource = {subscribe: () => ({unsubscribe: () => {}})}
+    const config: SanityConfig = {
+      projectId: 'test-project',
+      dataset: 'production',
+      perspective: 'published',
+      studio: {authenticated: true, auth: {token: tokenSource}},
+    }
+
+    const {getAllByTestId} = render(
+      <SDKProvider config={config} fallback={<div>Loading...</div>}>
+        <div>Child Content</div>
+      </SDKProvider>,
+    )
+
+    const providers = getAllByTestId('resource-provider')
+    // The full first config is spread onto the root ResourceProvider so the
+    // root SanityInstance retains auth/perspective/etc. (The token source is a
+    // function and doesn't survive JSON serialization, so assert on the
+    // serializable fields and that the studio config object is carried through.)
+    const spreadConfig = JSON.parse(providers[0].getAttribute('data-config') || '{}')
+    expect(spreadConfig).toMatchObject({
+      projectId: 'test-project',
+      dataset: 'production',
+      perspective: 'published',
+      studio: {authenticated: true},
+    })
+  })
+
+  it('synthesizes the default resource from the first config when none is explicit', () => {
+    const config = {projectId: 'test-project', dataset: 'production'}
+
+    const {getAllByTestId} = render(
+      <SDKProvider config={config} fallback={<div>Loading...</div>}>
+        <div>Child Content</div>
+      </SDKProvider>,
+    )
+
+    const providers = getAllByTestId('resource-provider')
+    expect(JSON.parse(providers[0].getAttribute('data-resource') || 'null')).toEqual({
+      projectId: 'test-project',
+      dataset: 'production',
+    })
+  })
+
+  it('uses an explicitly provided "default" resource over the config-derived one', () => {
+    const config = {projectId: 'config-project', dataset: 'production'}
+    const resources = {default: {projectId: 'explicit-project', dataset: 'staging'}}
+
+    const {getAllByTestId} = render(
+      <SDKProvider config={config} resources={resources} fallback={<div>Loading...</div>}>
+        <div>Child Content</div>
+      </SDKProvider>,
+    )
+
+    const providers = getAllByTestId('resource-provider')
+    // Config fields still flow through for instance creation…
+    expect(JSON.parse(providers[0].getAttribute('data-config') || '{}')).toEqual(config)
+    // …but the explicit default resource wins as the resource context value.
+    expect(JSON.parse(providers[0].getAttribute('data-resource') || 'null')).toEqual(
+      resources.default,
+    )
+  })
+
+  it('collects deduped projectIds from both config and explicit resources', () => {
+    const configs = [
+      {projectId: 'project-1', dataset: 'production'},
+      {projectId: 'project-2', dataset: 'production'},
+    ]
+    const resources = {
+      // duplicates project-1 (should be deduped)
+      default: {projectId: 'project-1', dataset: 'production'},
+      other: {projectId: 'project-3', dataset: 'production'},
+    }
+
+    const {getByTestId} = render(
+      <SDKProvider config={configs} resources={resources} fallback={<div>Loading...</div>}>
+        <div>Child Content</div>
+      </SDKProvider>,
+    )
+
+    const projectIds = JSON.parse(
+      getByTestId('auth-boundary').getAttribute('data-project-ids') || '[]',
+    )
+    expect([...projectIds].sort()).toEqual(['project-1', 'project-2', 'project-3'])
+  })
 })

package/src/components/SDKProvider.tsx

@@ -1,65 +1,124 @@
 import {
-  DEFAULT_RESOURCE_NAME,
   type DocumentResource,
   isDatasetResource,
+  isImportError,
   type SanityConfig,
 } from '@sanity/sdk'
-import {type ReactElement, type ReactNode, useMemo} from 'react'
+import {type ReactElement, type ReactNode, useEffect, useMemo} from 'react'
+import {ErrorBoundary, type FallbackProps} from 'react-error-boundary'
 
+import {DEFAULT_RESOURCE_NAME} from '../constants'
+import {OrganizationResourcesProvider} from '../context/OrganizationResourcesProvider'
 import {ResourceProvider} from '../context/ResourceProvider'
-import {ResourcesContext} from '../context/ResourcesContext'
 import {AuthBoundary, type AuthBoundaryProps} from './auth/AuthBoundary'
+import {ChunkLoadError} from './errors/ChunkLoadError'
+import {clearChunkReloadFlag} from './errors/chunkReloadStorage'
 
 /**
  * @internal
  */
 export interface SDKProviderProps extends AuthBoundaryProps {
   children: ReactNode
-  config: SanityConfig
-  /**
-   * Named document resources map. Provided to `ResourcesContext` for
-   * name-based resource resolution in hooks.
-   */
-  resources?: Record<string, DocumentResource>
+  config: SanityConfig | SanityConfig[]
   fallback: ReactNode
+  resources?: Record<string, DocumentResource>
+  /** When set, automatically fetches and registers the organization's media library and canvas as named resources. */
+  inferMediaLibraryAndCanvas?: boolean
 }
 
 /**
- * Collects unique project IDs from a resources map.
+ * Clears the chunk-reload flag once children render successfully past the
+ * top-level boundary, so a future incident in the same session can trigger
+ * another automatic reload.
  */
-function collectProjectIds(resources: Record<string, DocumentResource>): string[] {
-  const ids = new Set<string>()
-  for (const res of Object.values(resources)) {
-    if (isDatasetResource(res)) ids.add(res.projectId)
-  }
-  return [...ids]
+function ResetChunkReloadFlagOnMount(): null {
+  useEffect(() => {
+    clearChunkReloadFlag()
+  }, [])
+  return null
 }
 
 /**
  * @internal
  *
  * Top-level context provider that provides access to the Sanity SDK.
- *
- * Creates a single `ResourceProvider` (and therefore a single `SanityInstance`)
- * for the given config. Resource resolution is handled by `ResourcesContext`
- * and the `"default"` named resource.
  */
 export function SDKProvider({
   children,
   config,
-  resources = {},
   fallback,
+  inferMediaLibraryAndCanvas,
   ...props
 }: SDKProviderProps): ReactElement {
-  const projectIds = useMemo(() => collectProjectIds(resources), [resources])
+  // For legacy config support, extract the first config object as a default resource,
+  // matching the legacy behavior nesting ResourceProviders with the first config closest to users' application code.
+  // This should be removed when we remove legacy config support.
+  const defaultConfig = Array.isArray(config) ? config[0] : config
+  const defaultProjectId = defaultConfig?.projectId
+  const defaultDataset = defaultConfig?.dataset
 
-  const rootResource = useMemo(() => resources[DEFAULT_RESOURCE_NAME], [resources])
+  const resourcesValue = useMemo(() => {
+    const explicit = props.resources ?? {}
+    if (defaultProjectId && defaultDataset && !Object.hasOwn(explicit, DEFAULT_RESOURCE_NAME)) {
+      return {
+        [DEFAULT_RESOURCE_NAME]: {
+          projectId: defaultProjectId,
+          dataset: defaultDataset,
+        },
+        ...explicit,
+      }
+    }
+    return explicit
+  }, [defaultProjectId, defaultDataset, props.resources])
+
+  // Collect all projectIds from both resources and config, deduped so
+  // AuthBoundary doesn't verify the same project more than once.
+  const projectIds = useMemo(
+    () =>
+      Array.from(
+        new Set(
+          [
+            ...Object.values(resourcesValue)
+              .filter(isDatasetResource)
+              .map((resource) => resource.projectId),
+            ...(Array.isArray(config) ? config : [config]).map((configObj) => configObj.projectId),
+          ].filter((id): id is string => !!id),
+        ),
+      ),
+    [resourcesValue, config],
+  )
 
   return (
-    <ResourceProvider {...config} resource={rootResource} fallback={fallback}>
-      <AuthBoundary {...props} projectIds={projectIds}>
-        <ResourcesContext.Provider value={resources}>{children}</ResourcesContext.Provider>
-      </AuthBoundary>
-    </ResourceProvider>
+    <ErrorBoundary FallbackComponent={ChunkAwareFallback}>
+      <ResetChunkReloadFlagOnMount />
+      {/* Spread the first config so SanityInstance can use the auth,
+        perspective, and other config fields; `resource` lets an explicitly
+        provided `default` resource override the config-derived resource. */}
+      <ResourceProvider
+        {...defaultConfig}
+        resource={resourcesValue[DEFAULT_RESOURCE_NAME]}
+        fallback={fallback}
+      >
+        <AuthBoundary {...props} projectIds={projectIds}>
+          {/* OrganizationResourcesProvider wraps ResourcesContext.
+            It merges explicit resources with lazily inferred org resources (media
+            library, canvas) and provides the combined map to the subtree. */}
+          <OrganizationResourcesProvider
+            resources={resourcesValue}
+            inferMediaLibraryAndCanvas={inferMediaLibraryAndCanvas}
+          >
+            {children}
+          </OrganizationResourcesProvider>
+        </AuthBoundary>
+      </ResourceProvider>
+    </ErrorBoundary>
   )
 }
+
+function ChunkAwareFallback(fallbackProps: FallbackProps): ReactElement {
+  if (isImportError(fallbackProps.error)) {
+    return <ChunkLoadError {...fallbackProps} />
+  }
+  // Re-throw so downstream boundaries (e.g. AuthBoundary) handle other errors.
+  throw fallbackProps.error
+}