@sanity/sdk 3.3.0-rc.1 → 3.4.0-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/sdk",
-  "version": "3.3.0-rc.1",
+  "version": "3.4.0-rc.0",
   "private": false,
   "description": "Sanity SDK",
   "keywords": [
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@sanity/bifur-client": "^1.0.0",
-    "@sanity/client": "^8.6.1",
+    "@sanity/client": "^8.6.2",
     "@sanity/comlink": "^4.0.3",
     "@sanity/diff-match-patch": "^3.2.0",
     "@sanity/diff-patch": "^6.0.0",
@@ -55,7 +55,7 @@
     "@sanity/message-protocol": "^0.24.0",
     "@sanity/mutate": "^0.18.2",
     "@sanity/telemetry": "^1.1.0",
-    "@sanity/types": "^6.13.2",
+    "@sanity/types": "^6.14.1",
     "groq": "^6.13.2",
     "groq-js": "^2.0.0",
     "reselect": "^5.1.1",
@@ -70,14 +70,14 @@
     "@repo/tsconfig": "0.0.1",
     "@sanity/browserslist-config": "^1.0.5",
     "@sanity/pkg-utils": "^13.0.0",
-    "@types/node": "^24.13.4",
-    "@vitest/coverage-v8": "^5.0.0",
+    "@types/node": "^24.13.5",
+    "@vitest/coverage-v8": "^5.0.1",
     "eslint": "^10.10.0",
-    "oxfmt": "^0.67.0",
+    "oxfmt": "^0.68.0",
     "rolldown": "^1.2.8",
     "typescript": "^6.0.3",
     "vite": "^8.3.0",
-    "vitest": "^5.0.0"
+    "vitest": "^5.0.1"
   },
   "browserslist": "extends @sanity/browserslist-config",
   "scripts": {

package/src/_exports/_internal.ts

@@ -1,3 +1,4 @@
+export {getApplicationOrigin} from '../applications/applicationOrigin'
 export {isStudioConfig} from '../auth/authMode'
 export {
   type ApiErrorBody,
@@ -17,6 +18,7 @@ export {
   isDashboardEnvironment,
   requireDashboardMessageBus,
 } from '../dashboard/messageBus/store'
+export type {ApplicationStatus, ApplicationStatusUpdate} from '../dashboard/messageBus/topics'
 export {getTopicState, resolveTopic} from '../dashboard/messageBus/topicStore'
 export {PREVIEW_PROJECTION} from '../preview/previewConstants'
 export {transformProjectionToPreview} from '../preview/previewProjectionUtils'

package/src/applications/applicationOrigin.test.ts

@@ -0,0 +1,51 @@
+import {afterEach, describe, expect, it, vi} from 'vitest'
+
+import {getApplicationOrigin} from './applicationOrigin'
+import {type ApplicationBase} from './applications'
+
+const application: ApplicationBase = {
+  id: 'application-1',
+  type: 'coreApp',
+  title: 'Inbox',
+  name: 'inbox',
+  reference: 'sanity/inbox',
+  icon: null,
+  isSingleton: true,
+  visibility: 'default',
+  slug: 'inbox',
+  externalUrl: null,
+  organizationId: 'organization-1',
+  createdAt: '2026-01-01T00:00:00.000Z',
+  updatedAt: '2026-01-02T00:00:00.000Z',
+}
+
+describe('getApplicationOrigin', () => {
+  afterEach(() => vi.unstubAllGlobals())
+
+  it('derives singleton and organization origins from the slug', () => {
+    expect(getApplicationOrigin(application)).toBe('https://inbox-apps-organization-1.sanity.run')
+    expect(getApplicationOrigin({...application, isSingleton: false, slug: 'canvas'})).toBe(
+      'https://canvas.sanity.studio',
+    )
+  })
+
+  it('uses the staging domains when the host sets the runtime flag', () => {
+    vi.stubGlobal('__SANITY_STAGING__', true)
+    expect(getApplicationOrigin(application)).toBe(
+      'https://inbox-apps-organization-1.run.sanity.work',
+    )
+    expect(getApplicationOrigin({...application, isSingleton: false})).toBe(
+      'https://inbox.studio.sanity.work',
+    )
+  })
+
+  it('prefers the external URL origin and returns null without slug or URL', () => {
+    expect(
+      getApplicationOrigin({
+        ...application,
+        externalUrl: 'https://apps.example.com/external/index.html',
+      }),
+    ).toBe('https://apps.example.com')
+    expect(getApplicationOrigin({...application, slug: null})).toBeNull()
+  })
+})

package/src/applications/applicationOrigin.ts

@@ -0,0 +1,26 @@
+import {type ApplicationBase} from './applications'
+
+type SanityGlobal = typeof globalThis & {__SANITY_STAGING__?: boolean}
+
+/**
+ * The origin an application is served from, or `null` when it has neither an external URL nor
+ * a slug to derive one from. Callers treat `null` as "nothing to load" rather than failing the
+ * whole list on one bad record.
+ *
+ * @internal
+ */
+export function getApplicationOrigin(application: ApplicationBase): string | null {
+  if (application.externalUrl !== null) return new URL(application.externalUrl).origin
+  if (application.slug === null) return null
+
+  // Read at runtime, not via a bundler define: a remote is built once and runs in whichever
+  // host page loaded it, and the host sets this flag. Mirrors workbench's `getSanityEnv`.
+  const staging = (globalThis as SanityGlobal).__SANITY_STAGING__ === true
+  if (application.isSingleton) {
+    const domain = staging ? 'run.sanity.work' : 'sanity.run'
+    return `https://${application.slug}-apps-${application.organizationId}.${domain}`
+  }
+
+  const domain = staging ? 'studio.sanity.work' : 'sanity.studio'
+  return `https://${application.slug}.${domain}`
+}

package/src/dashboard/messageBus/bus.test.ts

@@ -500,6 +500,45 @@ describe('application connections', () => {
     expect(app.subscribe('auth.token').getCurrent()).toBe('trusted')
   })
 
+  it('delivers application status events to the host and rejects app responders', () => {
+    const statusHost = createMessageBus('dashboard')
+    const application = connectApplicationToMessageBus(statusHost, {
+      appId: 'favorites',
+    })
+    const responder = vi.fn()
+
+    statusHost.subscribe('applications.status.update', responder)
+    expect(() => application.subscribe('applications.status.update', vi.fn())).toThrowError(
+      expect.objectContaining({code: 'OWNERSHIP_MISMATCH'}),
+    )
+
+    application.emit('applications.status.update', {
+      name: 'list',
+      value: {label: 'Syncing'},
+    })
+    application.emit('applications.status.update', {
+      name: 'list',
+      value: {label: null},
+    })
+
+    expect(responder).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        type: 'applications.status.update',
+        payload: {name: 'list', value: {label: 'Syncing'}},
+        meta: expect.objectContaining({appId: 'favorites'}),
+      }),
+    )
+    expect(responder).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        type: 'applications.status.update',
+        payload: {name: 'list', value: {label: null}},
+        meta: expect.objectContaining({appId: 'favorites'}),
+      }),
+    )
+  })
+
   it('rejects state emits from every connection, including the host', () => {
     const host = createMessageBus('dashboard')
     const panel = {

package/src/dashboard/messageBus/bus.ts

@@ -18,6 +18,7 @@ import {type Application} from '../../applications/applications'
 import {
   DASHBOARD_TOPIC_MANIFEST,
   type EventTopic,
+  type MessageBusTopics,
   type PayloadOf,
   type ReplyOf,
   type StateTopic,
@@ -25,6 +26,7 @@ import {
   type TopicMigration,
   topicMigrations,
   type TopicName,
+  type Topics,
   type ValueOf,
 } from './topics'
 
@@ -78,9 +80,9 @@ export interface MessageBusMeta {
  * A message delivered to an event topic responder.
  * @public
  */
-export interface MessageBusMessage<T, R = never> {
+export interface MessageBusMessage<T, R = never, K extends PropertyKey = TopicName> {
   /** The topic that carries the message. */
-  type: TopicName
+  type: K
   /** The event payload. */
   payload: T
   /** The message provenance. */
@@ -148,39 +150,42 @@ export interface MessageBusEmitResult<R> extends PromiseLike<R> {
  * {@link MessageBusClient.emit}; a connection only ever reads its own values.
  * @public
  */
-export interface MessageBus {
+export interface MessageBus<TTopics = MessageBusTopics> {
   /** Emits an event topic and provides its reply when awaited. */
-  emit<K extends EventTopic>(
+  emit<K extends EventTopic<TTopics>>(
     type: K,
-    ...rest: PayloadOf<K> extends void
+    ...rest: PayloadOf<K, TTopics> extends void
       ? [payload?: void, options?: MessageBusEmitOptions]
-      : [payload: PayloadOf<K>, options?: MessageBusEmitOptions]
-  ): MessageBusEmitResult<ReplyOf<K>>
+      : [payload: PayloadOf<K, TTopics>, options?: MessageBusEmitOptions]
+  ): MessageBusEmitResult<ReplyOf<K, TTopics>>
   /** Reads the current or next value of a state topic. */
-  query<K extends StateTopic>(type: K, options?: MessageBusQueryOptions): Promise<ValueOf<K>>
+  query<K extends StateTopic<TTopics>>(
+    type: K,
+    options?: MessageBusQueryOptions,
+  ): Promise<ValueOf<K, TTopics>>
   /** Runs a responder for each event until its signal aborts. */
-  subscribe<K extends EventTopic>(
+  subscribe<K extends EventTopic<TTopics>>(
     type: K,
-    handler: (message: MessageBusMessage<PayloadOf<K>, ReplyOf<K>>) => void,
+    handler: (message: MessageBusMessage<PayloadOf<K, TTopics>, ReplyOf<K, TTopics>, K>) => void,
     options?: MessageBusAbortOptions,
   ): void
   /** Runs a handler for each state value until its signal aborts. */
-  subscribe<K extends StateTopic>(
+  subscribe<K extends StateTopic<TTopics>>(
     type: K,
-    handler: (value: ValueOf<K>) => void,
+    handler: (value: ValueOf<K, TTopics>) => void,
     options?: MessageBusAbortOptions,
   ): void
   /** Returns a state topic as a `MessageBusStateSource`. */
-  subscribe<K extends StateTopic>(type: K): MessageBusStateSource<ValueOf<K>>
+  subscribe<K extends StateTopic<TTopics>>(type: K): MessageBusStateSource<ValueOf<K, TTopics>>
   /** Returns an event topic as an observable of its payloads. */
-  subscribe<K extends EventTopic>(type: K): Observable<PayloadOf<K>>
+  subscribe<K extends EventTopic<TTopics>>(type: K): Observable<PayloadOf<K, TTopics>>
 }
 
 /**
  * A message bus connection that can be torn down independently of its siblings.
  * @public
  */
-export interface MessageBusConnection extends MessageBus {
+export interface MessageBusConnection<TTopics = MessageBusTopics> extends MessageBus<TTopics> {
   /**
    * Tears down this connection: pending requests reject `ABORTED`, subscriptions
    * complete, and later `emit`, `query`, and `subscribe` calls fail with `ABORTED`.
@@ -214,7 +219,7 @@ export interface MessageBusClient {
  * a snapshot to each new client.
  * @public
  */
-export interface MessageBusHost extends MessageBusConnection {
+export interface MessageBusHost<TTopics = MessageBusTopics> extends MessageBusConnection<TTopics> {
   /**
    * Every open connection other than this one first, then each new one as it joins. The same
    * {@link MessageBusClient} object is handed out for a connection across subscriptions, so it
@@ -641,7 +646,7 @@ export function createIsolatedMessageBus(
   config: {
     migrations?: ReadonlyMap<string, readonly TopicMigration[]>
   } = {},
-): MessageBusHost {
+): MessageBusHost<Topics> {
   if (!appId) throwMissingAppId()
 
   const registry: MessageBusRegistry = {
@@ -658,7 +663,10 @@ export function createIsolatedMessageBus(
 
   mergeTopicManifest(registry, DASHBOARD_TOPIC_MANIFEST)
 
-  return createConnection(registry, {appId, migrations: config.migrations}) as MessageBusHost
+  return createConnection(registry, {
+    appId,
+    migrations: config.migrations,
+  }) as MessageBusHost<Topics>
 }
 
 type TopicVersionAdapter = {
@@ -863,7 +871,7 @@ export interface ConnectApplicationToMessageBusOptions {
 export function connectApplicationToMessageBus(
   installedMessageBus: MessageBus,
   config: ConnectApplicationToMessageBusOptions,
-): MessageBusConnection {
+): MessageBusConnection<Topics> {
   if (!config.appId) throwMissingAppId()
 
   const {appId} = config
@@ -902,7 +910,7 @@ export function connectApplicationToMessageBus(
     return createRejectedConnection(() => error)
   }
 
-  return createConnection(registry, config)
+  return createConnection(registry, config) as MessageBusConnection<Topics>
 }
 
 // Hands the host the same client object for a connection across `connections` subscriptions.
@@ -1202,7 +1210,7 @@ export interface InstallMessageBusOptions {
  * connection it would get has no `connections`.
  * @internal
  */
-export function installMessageBus(options: InstallMessageBusOptions = {}): MessageBusHost {
+export function installMessageBus(options: InstallMessageBusOptions = {}): MessageBusHost<Topics> {
   const appId = resolveAppId(options.appId) ?? throwMissingAppId()
   const installedMessageBus = getInstalledMessageBus()
   if (installedMessageBus) {
@@ -1214,7 +1222,9 @@ export function installMessageBus(options: InstallMessageBusOptions = {}): Messa
         `Cannot install the message bus as "${appId}": it is already installed by "${installedAppId}". Applications connect with connectMessageBus().`,
       )
     }
-    return connectApplicationToMessageBus(installedMessageBus, {appId}) as MessageBusHost
+    return connectApplicationToMessageBus(installedMessageBus, {
+      appId,
+    }) as MessageBusHost<Topics>
   }
 
   const globals = globalThis as {[MESSAGE_BUS_KEY]?: MessageBus}

package/src/dashboard/messageBus/topics.test.ts

@@ -1,13 +1,18 @@
-import {describe, expectTypeOf, it} from 'vitest'
+import {describe, expect, expectTypeOf, it} from 'vitest'
 
 import {type Application, type ApplicationInclude} from '../../applications/applications'
 import {type MessageBus} from './bus'
 import {
   type ApplicationConfig,
   type ApplicationConfigAppType,
+  type ApplicationStatusUpdate,
+  DASHBOARD_TOPIC_MANIFEST,
+  type DashboardTopics,
+  type EventTopic,
   type PayloadOf,
   type ReplyOf,
   type StateTopic,
+  type TopicName,
   type TopicResult,
   type ValueOf,
 } from './topics'
@@ -28,7 +33,26 @@ describe('dashboard topic types', () => {
     expectTypeOf<Parameters<MessageBus['query']>[0]>().toEqualTypeOf<StateTopic>()
   })
 
+  it('keeps application status internal', () => {
+    expectTypeOf<ApplicationStatusUpdate>().toEqualTypeOf<{
+      name: string
+      value: {label: string | null}
+    }>()
+    expect(DASHBOARD_TOPIC_MANIFEST['applications.status.update']).toEqual({
+      kind: 'event',
+      ownership: {type: 'same_app'},
+    })
+    expectTypeOf<'applications.status.update'>().toMatchTypeOf<TopicName>()
+    expectTypeOf<'applications.status.update'>().not.toMatchTypeOf<EventTopic>()
+    expectTypeOf<PayloadOf<'applications.status.update'>>().toEqualTypeOf<ApplicationStatusUpdate>()
+    expectTypeOf<ReplyOf<'applications.status.update'>>().toBeNever()
+  })
+
   it('exposes application state values', () => {
+    expectTypeOf<ValueOf<'applications.base-path'>>().toEqualTypeOf<TopicResult<string>>()
+    expectTypeOf<ValueOf<'applications.foreground', DashboardTopics>>().toEqualTypeOf<
+      Application['id'] | null
+    >()
     expectTypeOf<ValueOf<'applications.config'>>().toEqualTypeOf<ApplicationConfig[] | null>()
     expectTypeOf<ValueOf<'applications.list'>>().toEqualTypeOf<TopicResult<
       Application<ApplicationInclude>[]
@@ -60,12 +84,22 @@ describe('dashboard topic types', () => {
   })
 
   it('requires payloads only for events that declare one', () => {
-    const messageBus = {emit: () => undefined} as unknown as MessageBus
+    const messageBus = {
+      emit: () => undefined,
+      query: () => undefined,
+      subscribe: () => undefined,
+    } as unknown as MessageBus
 
     messageBus.emit('auth.token.refresh')
     messageBus.emit('auth.token.refresh', undefined, {timeout: null})
     messageBus.emit('navigation.location.update', {url: '/'})
     // @ts-expect-error navigation.location.update requires a payload
     messageBus.emit('navigation.location.update')
+    // @ts-expect-error applications.status.update is internal
+    messageBus.emit('applications.status.update', {name: 'media', value: {label: null}})
+    // @ts-expect-error applications.status.update is internal
+    messageBus.subscribe('applications.status.update')
+    // @ts-expect-error applications.status.update is internal
+    messageBus.subscribe('applications.status.update', () => {})
   })
 })

package/src/dashboard/messageBus/topics.ts

@@ -31,6 +31,23 @@ export interface ApplicationConfig extends RemoteModuleRef {
   readonly appType: ApplicationConfigAppType
 }
 
+/**
+ * A label rendered for an application interface; `null` clears it.
+ * @internal
+ */
+export type ApplicationStatus = {label: string | null}
+
+/**
+ * Updates the status rendered for an application interface.
+ * @internal
+ */
+export type ApplicationStatusUpdate = {
+  /** The application interface name. */
+  name: string
+  /** The status to render. */
+  value: ApplicationStatus
+}
+
 /**
  * Declares a topic that stores and replays its current value.
  * @public
@@ -83,12 +100,19 @@ export type NavigationLocation = NavigationTarget & {
  * @public
  */
 export interface DashboardTopics {
+  /**
+   * The base path for an application.
+   *
+   * An unknown application returns `{ok: false}`.
+   */
+  'applications.base-path': StateTopicDef<TopicResult<string>>
   /** The available application configuration modules. */
   'applications.config': StateTopicDef<ApplicationConfig[] | null>
   /** The foreground application ID, or `null` on dashboard-level routes. */
   'applications.foreground': StateTopicDef<Application['id'] | null>
   /** The dashboard applications available to the current user. */
   'applications.list': StateTopicDef<TopicResult<Application<ApplicationInclude>[]> | null>
+  'applications.status.update': EventTopicDef<ApplicationStatusUpdate>
   /**
    * The session token for the reading connection, or `null` while signed out. The host
    * writes it to each connection separately, so one application never sees another's token.
@@ -130,7 +154,7 @@ export interface DashboardTopics {
   /** Whether the dashboard dock is pinned open. */
   'preferences.dock-locked': StateTopicDef<boolean>
   /** The signed-in user, or `null` while signed out. */
-  'users.current': StateTopicDef<Pick<CurrentUser, 'id' | 'name' | 'email' | 'profileImage'> | null>
+  'users.current': StateTopicDef<CurrentUser | null>
 }
 
 /**
@@ -140,21 +164,27 @@ export interface DashboardTopics {
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type -- Declaration merging extends the SDK manifest.
 export interface Topics extends DashboardTopics {}
 
+/**
+ * Hides provisional topics from the public message bus methods.
+ * @internal
+ */
+export type MessageBusTopics = Omit<Topics, 'applications.status.update'>
+
 /**
  * Every declared topic name.
  * @public
  */
-export type TopicName = keyof Topics
+export type TopicName<TTopics = Topics> = keyof TTopics
 
 type StateTopicsOf<T> = {
   [K in keyof T]: T[K] extends {kind: 'state'} ? K : never
 }[keyof T]
 
 /**
- * Names of all declared state topics.
+ * Names of state topics exposed by message bus methods.
  * @public
  */
-export type StateTopic = StateTopicsOf<Topics>
+export type StateTopic<TTopics = MessageBusTopics> = StateTopicsOf<TTopics>
 
 type TopicOwnership = {readonly type: 'same_app'} | {readonly type: 'any_app'}
 
@@ -169,16 +199,20 @@ const stateTopic = <const V>(seed: V) => ({kind: 'state', seed}) as const
 // `same_app` restricts responding to the application that installed the bus.
 const dashboardEvent = {kind: 'event', ownership: {type: 'same_app'}} as const
 
+type DashboardTopicManifest = {
+  readonly [K in keyof DashboardTopics]: TopicManifestEntry<DashboardTopics[K]>
+}
+
 /**
  * Defines the runtime kind, ownership, and initial value of dashboard topics.
  * @internal
  */
-export const DASHBOARD_TOPIC_MANIFEST: {
-  readonly [K in keyof DashboardTopics]: TopicManifestEntry<DashboardTopics[K]>
-} = {
+export const DASHBOARD_TOPIC_MANIFEST: DashboardTopicManifest = {
+  'applications.base-path': stateTopic(undefined),
   'applications.config': stateTopic(undefined),
   'applications.foreground': stateTopic(undefined),
   'applications.list': stateTopic(undefined),
+  'applications.status.update': dashboardEvent,
   'auth.token': stateTopic(undefined),
   'auth.token.refresh': dashboardEvent,
   'navigation.location': stateTopic(undefined),
@@ -204,32 +238,33 @@ export type TopicManifest = Readonly<
 >
 
 /**
- * Names of all declared event topics.
+ * Names of event topics exposed by message bus methods.
  * @public
  */
-export type EventTopic = {
-  [K in TopicName]: Topics[K] extends {kind: 'event'} ? K : never
-}[TopicName]
+export type EventTopic<TTopics = MessageBusTopics> = {
+  [K in keyof TTopics]: TTopics[K] extends {kind: 'event'} ? K : never
+}[keyof TTopics]
 
 /**
  * The value type of a state topic.
  * @public
  */
-export type ValueOf<K extends StateTopic> = Topics[K] extends StateTopicDef<infer T> ? T : never
+export type ValueOf<K extends StateTopic<TTopics>, TTopics = Topics> =
+  TTopics[K] extends StateTopicDef<infer T> ? T : never
 
 /**
  * The payload type of an event topic.
  * @public
  */
-export type PayloadOf<K extends EventTopic> =
-  Topics[K] extends EventTopicDef<infer P, infer _R> ? P : never
+export type PayloadOf<K extends EventTopic<TTopics>, TTopics = Topics> =
+  TTopics[K] extends EventTopicDef<infer P, infer _R> ? P : never
 
 /**
  * The reply type of an event topic (`never` if it declares none).
  * @public
  */
-export type ReplyOf<K extends EventTopic> =
-  Topics[K] extends EventTopicDef<infer _P, infer R> ? R : never
+export type ReplyOf<K extends EventTopic<TTopics>, TTopics = Topics> =
+  TTopics[K] extends EventTopicDef<infer _P, infer R> ? R : never
 
 /**
  * Converts a topic value between 2 adjacent versions.

package/src/installations/installations.test-d.ts

@@ -27,6 +27,7 @@ test('Installation — no includes: only the base shape', () => {
   expectTypeOf<Installation>().toEqualTypeOf<InstallationBase>()
   expectTypeOf<Installation<never>>().toEqualTypeOf<InstallationBase>()
   expectTypeOf<Extract<keyof Installation, IncludeKeys>>().toEqualTypeOf<never>()
+  expectTypeOf<Extract<keyof Installation['application'], 'config'>>().toEqualTypeOf<never>()
 })
 
 test('InstallationBase — the application sub-object carries name and reference', () => {
@@ -53,11 +54,21 @@ test('Installation — multiple tokens add each field', () => {
   expectTypeOf<Extract<keyof Both, 'activeConfig'>>().toEqualTypeOf<never>()
 })
 
+test('Installation — module federation manifest include adds the manifest', () => {
+  type Item = Installation<'config.mfManifest'>
+  expectTypeOf<Item['application']['config']['mfManifest']>().toEqualTypeOf<unknown>()
+  expectTypeOf<
+    KeyModifier<Item['application']['config'], 'mfManifest'>
+  >().toEqualTypeOf<'optional'>()
+  expectTypeOf<Extract<keyof Item, IncludeKeys>>().toEqualTypeOf<never>()
+})
+
 test('Installation — a wide include array makes the fields optional', () => {
   type Wide = Installation<InstallationInclude>
   expectTypeOf<KeyModifier<Wide, 'access'>>().toEqualTypeOf<'optional'>()
   expectTypeOf<KeyModifier<Wide, 'interfaces'>>().toEqualTypeOf<'optional'>()
   expectTypeOf<KeyModifier<Wide, 'activeConfig'>>().toEqualTypeOf<'optional'>()
+  expectTypeOf<KeyModifier<Wide['application'], 'config'>>().toEqualTypeOf<'optional'>()
 })
 
 test('installations.resolveState — resolves the wide list envelope', () => {

package/src/installations/installations.test.ts

@@ -31,7 +31,7 @@ describe('installations', () => {
 
     const result = await installations.resolveState(instance, {
       organizationId: 'org1',
-      include: ['interfaces'],
+      include: ['interfaces', 'config.mfManifest'],
     })
 
     expect(result).toEqual(response)
@@ -41,7 +41,7 @@ describe('installations', () => {
     })
     expect(request).toHaveBeenCalledWith({
       url: '/installations',
-      query: {organizationId: 'org1', include: 'interfaces'},
+      query: {organizationId: 'org1', include: 'config.mfManifest,interfaces'},
       tag: 'installations.list',
     })
   })
@@ -50,12 +50,14 @@ describe('installations', () => {
     const inst = {id: 'inst1', applicationId: 'app1'}
     request.mockReturnValue(of(inst))
 
-    const result = await installation.resolveState(instance, 'inst1')
+    const result = await installation.resolveState(instance, 'inst1', {
+      include: ['config.mfManifest'],
+    })
 
     expect(result).toEqual(inst)
     expect(request).toHaveBeenCalledWith({
       url: '/installations/inst1',
-      query: {},
+      query: {include: 'config.mfManifest'},
       tag: 'installations.get',
     })
   })

package/src/installations/installations.ts

@@ -1,6 +1,6 @@
 import {switchMap} from 'rxjs'
 
-import {type ApplicationInterface} from '../applications/applications'
+import {type Application, type ApplicationInterface} from '../applications/applications'
 import {getClientState} from '../client/clientStore'
 import {defineFetcher} from '../store/fetcherStore'
 import {buildQuery} from '../utils/buildQuery'
@@ -16,7 +16,7 @@ const API_VERSION = 'vX'
  * @see https://www.sanity.io/docs/http-reference/applications-api
  * @public
  */
-export type InstallationInclude = 'activeConfig' | 'access' | 'interfaces'
+export type InstallationInclude = 'activeConfig' | 'access' | 'interfaces' | 'config.mfManifest'
 
 /**
  * A resource an installation accesses, embedded when `access` is included.
@@ -80,6 +80,17 @@ export interface InstallationBase {
  * @public
  */
 export type Installation<Include extends InstallationInclude = never> = InstallationBase &
+  Included<
+    InstallationInclude,
+    'config.mfManifest',
+    Include,
+    {
+      application: InstallationBase['application'] &
+        ([InstallationInclude] extends [Include]
+          ? Partial<Pick<Application<'config.mfManifest'>, 'config'>>
+          : Pick<Application<'config.mfManifest'>, 'config'>)
+    }
+  > &
   Included<
     InstallationInclude,
     'activeConfig',