@sanity/workbench 0.1.0-alpha.19 → 0.1.0-alpha.20

package/dist/system.d.ts

@@ -41,20 +41,59 @@ export declare function createOSOptions(input: OSInput): {
 };
 
 /**
+ * A module exposed by an application's federation remote.
+ *
  * @public
  */
-export declare interface LoadedRemoteModule {
-  render: (
-    rootElement: HTMLElement,
-    options?: RemoteRenderOptions,
-  ) => () => void;
+export declare interface FederatedModuleRef {
+  /**
+   * Fully-qualified module id — `${appId}/${expose}`, e.g.
+   * `studio-1/views/feed/panel` (a view component) or `studio-1/App` (the
+   * full-page view). The remote's name is its first segment.
+   */
+  moduleId: string;
+  /** The remote's `mf-manifest.json` URL (served from the app's origin). */
+  entry: string;
+}
+
+/**
+ * A loaded render-contract module. `TProps` is what its `render` accepts —
+ * `RemoteRenderOptions` for an application's full-page view, the view's props
+ * for a dock-panel component.
+ * @public
+ */
+export declare interface LoadedRemoteModule<TProps = RemoteRenderOptions> {
+  render: (rootElement: HTMLElement, props?: TProps) => () => void;
 }
 
+/**
+ * {@link loadRemoteModule} with the render-empty-on-failure policy: any failure
+ * resolves to `null` (and logs), so every caller handles a missing interface
+ * the same way — a panel renders empty, a worker doesn't spawn.
+ *
+ * @public
+ */
+export declare function loadFederatedModule<T>(
+  instance: FederationInstance,
+  ref: FederatedModuleRef,
+): Promise<T | null>;
+
 /**
  * @internal
  */
 export declare interface LogoutInput extends OSBaseInput {}
 
+/**
+ * Thrown by a render consumer (e.g. the island) when a loaded module doesn't
+ * expose a `render` function. Render-specific — `remoteLogic` itself is
+ * shape-agnostic, so this lives with the consumer that needs the contract, not
+ * the loader. Surfaced via `RemoteError.cause` for consumers that discriminate.
+ * @public
+ */
+export declare class ModuleShapeError extends Error {
+  constructor(remoteId: string);
+}
+
 /**
  * The sanity OS machine, responsible for managing the global state of the OS.
  * @public
@@ -92,12 +131,12 @@ export declare const os: StateMachine<
             },
             | {
                 type: "remote.load.request";
-                id: string;
+                moduleId: string;
                 entry: string;
               }
             | {
                 type: "remote.settled";
-                id: string;
+                moduleId: string;
                 status: "loaded" | "error";
               },
             {
@@ -105,7 +144,7 @@ export declare const os: StateMachine<
                 | ActorRefFromLogic<
                     StateMachine<
                       RemoteInput & {
-                        module: LoadedRemoteModule | null;
+                        module: unknown;
                         error: RemoteError | null;
                       },
                       AnyEventObject,
@@ -113,7 +152,7 @@ export declare const os: StateMachine<
                         [x: string]:
                           | ActorRefFromLogic<
                               PromiseActorLogic<
-                                LoadedRemoteModule,
+                                unknown,
                                 RemoteInput,
                                 EventObject
                               >
@@ -123,7 +162,7 @@ export declare const os: StateMachine<
                       {
                         src: "load";
                         logic: PromiseActorLogic<
-                          LoadedRemoteModule,
+                          unknown,
                           RemoteInput,
                           EventObject
                         >;
@@ -132,7 +171,7 @@ export declare const os: StateMachine<
                       | {
                           type: "setModule";
                           params: {
-                            module: LoadedRemoteModule;
+                            module: unknown;
                           };
                         }
                       | {
@@ -165,34 +204,26 @@ export declare const os: StateMachine<
               src: "remote";
               logic: StateMachine<
                 RemoteInput & {
-                  module: LoadedRemoteModule | null;
+                  module: unknown;
                   error: RemoteError | null;
                 },
                 AnyEventObject,
                 {
                   [x: string]:
                     | ActorRefFromLogic<
-                        PromiseActorLogic<
-                          LoadedRemoteModule,
-                          RemoteInput,
-                          EventObject
-                        >
+                        PromiseActorLogic<unknown, RemoteInput, EventObject>
                       >
                     | undefined;
                 },
                 {
                   src: "load";
-                  logic: PromiseActorLogic<
-                    LoadedRemoteModule,
-                    RemoteInput,
-                    EventObject
-                  >;
+                  logic: PromiseActorLogic<unknown, RemoteInput, EventObject>;
                   id: string | undefined;
                 },
                 | {
                     type: "setModule";
                     params: {
-                      module: LoadedRemoteModule;
+                      module: unknown;
                     };
                   }
                 | {
@@ -223,20 +254,22 @@ export declare const os: StateMachine<
             {
               type: "spawnRemote";
               params: {
-                id: string;
+                moduleId: string;
                 entry: string;
               };
             },
             {
               type: "remoteNotKnown";
               params: {
-                id: string;
+                moduleId: string;
               };
             },
             never,
             {},
             string,
-            NonReducibleUnknown,
+            {
+              instance: FederationInstance;
+            },
             NonReducibleUnknown,
             EventObject,
             MetaObject,
@@ -246,6 +279,393 @@ export declare const os: StateMachine<
           >
         >
       | undefined;
+    services?:
+      | ActorRefFromLogic<
+          StateMachine<
+            {
+              instance: FederationInstance;
+              children: Map<string, ActorRefFrom<serviceLogic>>;
+            },
+            {
+              type: "services.sync";
+              services: ReadonlyArray<{
+                appId: string;
+                serviceName: string;
+                entry: string;
+              }>;
+            },
+            {
+              [x: string]:
+                | ActorRefFromLogic<
+                    StateMachine<
+                      ServiceInput & {
+                        workerUrl: string | null;
+                      },
+                      AnyEventObject,
+                      {
+                        [x: string]:
+                          | ActorRefFromLogic<
+                              StateMachine<
+                                RemoteInput & {
+                                  module: unknown;
+                                  error: RemoteError | null;
+                                },
+                                AnyEventObject,
+                                {
+                                  [x: string]:
+                                    | ActorRefFromLogic<
+                                        PromiseActorLogic<
+                                          unknown,
+                                          RemoteInput,
+                                          EventObject
+                                        >
+                                      >
+                                    | undefined;
+                                },
+                                {
+                                  src: "load";
+                                  logic: PromiseActorLogic<
+                                    unknown,
+                                    RemoteInput,
+                                    EventObject
+                                  >;
+                                  id: string | undefined;
+                                },
+                                | {
+                                    type: "setModule";
+                                    params: {
+                                      module: unknown;
+                                    };
+                                  }
+                                | {
+                                    type: "setError";
+                                    params: {
+                                      error: unknown;
+                                    };
+                                  },
+                                never,
+                                never,
+                                "error" | "loading" | "loaded",
+                                "loading" | "ready" | "failed",
+                                RemoteInput,
+                                NonReducibleUnknown,
+                                EventObject,
+                                MetaObject,
+                                {
+                                  id: "remote";
+                                  states: {
+                                    readonly loading: {};
+                                    readonly loaded: {};
+                                    readonly error: {};
+                                  };
+                                }
+                              >
+                            >
+                          | ActorRefFromLogic<
+                              CallbackActorLogic<
+                                {
+                                  type: string;
+                                },
+                                {
+                                  key: string;
+                                  serviceName: string;
+                                  workerUrl: string;
+                                },
+                                EventObject
+                              >
+                            >
+                          | undefined;
+                      },
+                      | {
+                          src: "loadInterface";
+                          logic: StateMachine<
+                            RemoteInput & {
+                              module: unknown;
+                              error: RemoteError | null;
+                            },
+                            AnyEventObject,
+                            {
+                              [x: string]:
+                                | ActorRefFromLogic<
+                                    PromiseActorLogic<
+                                      unknown,
+                                      RemoteInput,
+                                      EventObject
+                                    >
+                                  >
+                                | undefined;
+                            },
+                            {
+                              src: "load";
+                              logic: PromiseActorLogic<
+                                unknown,
+                                RemoteInput,
+                                EventObject
+                              >;
+                              id: string | undefined;
+                            },
+                            | {
+                                type: "setModule";
+                                params: {
+                                  module: unknown;
+                                };
+                              }
+                            | {
+                                type: "setError";
+                                params: {
+                                  error: unknown;
+                                };
+                              },
+                            never,
+                            never,
+                            "error" | "loading" | "loaded",
+                            "loading" | "ready" | "failed",
+                            RemoteInput,
+                            NonReducibleUnknown,
+                            EventObject,
+                            MetaObject,
+                            {
+                              id: "remote";
+                              states: {
+                                readonly loading: {};
+                                readonly loaded: {};
+                                readonly error: {};
+                              };
+                            }
+                          >;
+                          id: string | undefined;
+                        }
+                      | {
+                          src: "runWorker";
+                          logic: CallbackActorLogic<
+                            {
+                              type: string;
+                            },
+                            {
+                              key: string;
+                              serviceName: string;
+                              workerUrl: string;
+                            },
+                            EventObject
+                          >;
+                          id: string | undefined;
+                        },
+                      never,
+                      never,
+                      never,
+                      "error" | "loading" | "running",
+                      "loading" | "failed" | "running",
+                      ServiceInput,
+                      NonReducibleUnknown,
+                      EventObject,
+                      MetaObject,
+                      {
+                        id: "service";
+                        states: {
+                          readonly loading: {};
+                          readonly running: {};
+                          readonly error: {};
+                        };
+                      }
+                    >
+                  >
+                | undefined;
+            },
+            {
+              src: "service";
+              logic: StateMachine<
+                ServiceInput & {
+                  workerUrl: string | null;
+                },
+                AnyEventObject,
+                {
+                  [x: string]:
+                    | ActorRefFromLogic<
+                        StateMachine<
+                          RemoteInput & {
+                            module: unknown;
+                            error: RemoteError | null;
+                          },
+                          AnyEventObject,
+                          {
+                            [x: string]:
+                              | ActorRefFromLogic<
+                                  PromiseActorLogic<
+                                    unknown,
+                                    RemoteInput,
+                                    EventObject
+                                  >
+                                >
+                              | undefined;
+                          },
+                          {
+                            src: "load";
+                            logic: PromiseActorLogic<
+                              unknown,
+                              RemoteInput,
+                              EventObject
+                            >;
+                            id: string | undefined;
+                          },
+                          | {
+                              type: "setModule";
+                              params: {
+                                module: unknown;
+                              };
+                            }
+                          | {
+                              type: "setError";
+                              params: {
+                                error: unknown;
+                              };
+                            },
+                          never,
+                          never,
+                          "error" | "loading" | "loaded",
+                          "loading" | "ready" | "failed",
+                          RemoteInput,
+                          NonReducibleUnknown,
+                          EventObject,
+                          MetaObject,
+                          {
+                            id: "remote";
+                            states: {
+                              readonly loading: {};
+                              readonly loaded: {};
+                              readonly error: {};
+                            };
+                          }
+                        >
+                      >
+                    | ActorRefFromLogic<
+                        CallbackActorLogic<
+                          {
+                            type: string;
+                          },
+                          {
+                            key: string;
+                            serviceName: string;
+                            workerUrl: string;
+                          },
+                          EventObject
+                        >
+                      >
+                    | undefined;
+                },
+                | {
+                    src: "loadInterface";
+                    logic: StateMachine<
+                      RemoteInput & {
+                        module: unknown;
+                        error: RemoteError | null;
+                      },
+                      AnyEventObject,
+                      {
+                        [x: string]:
+                          | ActorRefFromLogic<
+                              PromiseActorLogic<
+                                unknown,
+                                RemoteInput,
+                                EventObject
+                              >
+                            >
+                          | undefined;
+                      },
+                      {
+                        src: "load";
+                        logic: PromiseActorLogic<
+                          unknown,
+                          RemoteInput,
+                          EventObject
+                        >;
+                        id: string | undefined;
+                      },
+                      | {
+                          type: "setModule";
+                          params: {
+                            module: unknown;
+                          };
+                        }
+                      | {
+                          type: "setError";
+                          params: {
+                            error: unknown;
+                          };
+                        },
+                      never,
+                      never,
+                      "error" | "loading" | "loaded",
+                      "loading" | "ready" | "failed",
+                      RemoteInput,
+                      NonReducibleUnknown,
+                      EventObject,
+                      MetaObject,
+                      {
+                        id: "remote";
+                        states: {
+                          readonly loading: {};
+                          readonly loaded: {};
+                          readonly error: {};
+                        };
+                      }
+                    >;
+                    id: string | undefined;
+                  }
+                | {
+                    src: "runWorker";
+                    logic: CallbackActorLogic<
+                      {
+                        type: string;
+                      },
+                      {
+                        key: string;
+                        serviceName: string;
+                        workerUrl: string;
+                      },
+                      EventObject
+                    >;
+                    id: string | undefined;
+                  },
+                never,
+                never,
+                never,
+                "error" | "loading" | "running",
+                "loading" | "failed" | "running",
+                ServiceInput,
+                NonReducibleUnknown,
+                EventObject,
+                MetaObject,
+                {
+                  id: "service";
+                  states: {
+                    readonly loading: {};
+                    readonly running: {};
+                    readonly error: {};
+                  };
+                }
+              >;
+              id: string | undefined;
+            },
+            {
+              type: "syncServices";
+              params: NonReducibleUnknown;
+            },
+            never,
+            never,
+            {},
+            string,
+            {
+              instance: FederationInstance;
+            },
+            NonReducibleUnknown,
+            EventObject,
+            MetaObject,
+            {
+              id: "services";
+            }
+          >
+        >
+      | undefined;
     telemetry?:
       | ActorRefFromLogic<
           StateMachine<
@@ -486,12 +906,12 @@ export declare const os: StateMachine<
         },
         | {
             type: "remote.load.request";
-            id: string;
+            moduleId: string;
             entry: string;
           }
         | {
             type: "remote.settled";
-            id: string;
+            moduleId: string;
             status: "loaded" | "error";
           },
         {
@@ -499,34 +919,26 @@ export declare const os: StateMachine<
             | ActorRefFromLogic<
                 StateMachine<
                   RemoteInput & {
-                    module: LoadedRemoteModule | null;
+                    module: unknown;
                     error: RemoteError | null;
                   },
                   AnyEventObject,
                   {
                     [x: string]:
                       | ActorRefFromLogic<
-                          PromiseActorLogic<
-                            LoadedRemoteModule,
-                            RemoteInput,
-                            EventObject
-                          >
+                          PromiseActorLogic<unknown, RemoteInput, EventObject>
                         >
                       | undefined;
                   },
                   {
                     src: "load";
-                    logic: PromiseActorLogic<
-                      LoadedRemoteModule,
-                      RemoteInput,
-                      EventObject
-                    >;
+                    logic: PromiseActorLogic<unknown, RemoteInput, EventObject>;
                     id: string | undefined;
                   },
                   | {
                       type: "setModule";
                       params: {
-                        module: LoadedRemoteModule;
+                        module: unknown;
                       };
                     }
                   | {
@@ -559,34 +971,26 @@ export declare const os: StateMachine<
           src: "remote";
           logic: StateMachine<
             RemoteInput & {
-              module: LoadedRemoteModule | null;
+              module: unknown;
               error: RemoteError | null;
             },
             AnyEventObject,
             {
               [x: string]:
                 | ActorRefFromLogic<
-                    PromiseActorLogic<
-                      LoadedRemoteModule,
-                      RemoteInput,
-                      EventObject
-                    >
+                    PromiseActorLogic<unknown, RemoteInput, EventObject>
                   >
                 | undefined;
             },
             {
               src: "load";
-              logic: PromiseActorLogic<
-                LoadedRemoteModule,
-                RemoteInput,
-                EventObject
-              >;
+              logic: PromiseActorLogic<unknown, RemoteInput, EventObject>;
               id: string | undefined;
             },
             | {
                 type: "setModule";
                 params: {
-                  module: LoadedRemoteModule;
+                  module: unknown;
                 };
               }
             | {
@@ -617,20 +1021,22 @@ export declare const os: StateMachine<
         {
           type: "spawnRemote";
           params: {
-            id: string;
+            moduleId: string;
             entry: string;
           };
         },
         {
           type: "remoteNotKnown";
           params: {
-            id: string;
+            moduleId: string;
           };
         },
         never,
         {},
         string,
-        NonReducibleUnknown,
+        {
+          instance: FederationInstance;
+        },
         NonReducibleUnknown,
         EventObject,
         MetaObject,
@@ -641,48 +1047,427 @@ export declare const os: StateMachine<
       id: "remotes";
     }
   | {
-      src: "telemetry";
+      src: "services";
       logic: StateMachine<
         {
-          instance: SanityInstance;
-          store: TelemetryStore<WorkbenchUserProperties> | null;
-          userProperties: WorkbenchUserProperties;
+          instance: FederationInstance;
+          children: Map<string, ActorRefFrom<serviceLogic>>;
+        },
+        {
+          type: "services.sync";
+          services: ReadonlyArray<{
+            appId: string;
+            serviceName: string;
+            entry: string;
+          }>;
         },
-        | {
-            type: "telemetry.start";
-          }
-        | {
-            type: "telemetry.stop";
-          },
         {
           [x: string]:
             | ActorRefFromLogic<
-                PromiseActorLogic<
-                  {
-                    status: ConsentStatus;
+                StateMachine<
+                  ServiceInput & {
+                    workerUrl: string | null;
                   },
+                  AnyEventObject,
                   {
-                    instance: SanityInstance;
+                    [x: string]:
+                      | ActorRefFromLogic<
+                          StateMachine<
+                            RemoteInput & {
+                              module: unknown;
+                              error: RemoteError | null;
+                            },
+                            AnyEventObject,
+                            {
+                              [x: string]:
+                                | ActorRefFromLogic<
+                                    PromiseActorLogic<
+                                      unknown,
+                                      RemoteInput,
+                                      EventObject
+                                    >
+                                  >
+                                | undefined;
+                            },
+                            {
+                              src: "load";
+                              logic: PromiseActorLogic<
+                                unknown,
+                                RemoteInput,
+                                EventObject
+                              >;
+                              id: string | undefined;
+                            },
+                            | {
+                                type: "setModule";
+                                params: {
+                                  module: unknown;
+                                };
+                              }
+                            | {
+                                type: "setError";
+                                params: {
+                                  error: unknown;
+                                };
+                              },
+                            never,
+                            never,
+                            "error" | "loading" | "loaded",
+                            "loading" | "ready" | "failed",
+                            RemoteInput,
+                            NonReducibleUnknown,
+                            EventObject,
+                            MetaObject,
+                            {
+                              id: "remote";
+                              states: {
+                                readonly loading: {};
+                                readonly loaded: {};
+                                readonly error: {};
+                              };
+                            }
+                          >
+                        >
+                      | ActorRefFromLogic<
+                          CallbackActorLogic<
+                            {
+                              type: string;
+                            },
+                            {
+                              key: string;
+                              serviceName: string;
+                              workerUrl: string;
+                            },
+                            EventObject
+                          >
+                        >
+                      | undefined;
                   },
-                  EventObject
-                >
-              >
-            | undefined;
-        },
-        {
-          src: "checkConsent";
-          logic: PromiseActorLogic<
-            {
-              status: ConsentStatus;
-            },
-            {
-              instance: SanityInstance;
-            },
-            EventObject
-          >;
-          id: string | undefined;
-        },
-        | {
+                  | {
+                      src: "loadInterface";
+                      logic: StateMachine<
+                        RemoteInput & {
+                          module: unknown;
+                          error: RemoteError | null;
+                        },
+                        AnyEventObject,
+                        {
+                          [x: string]:
+                            | ActorRefFromLogic<
+                                PromiseActorLogic<
+                                  unknown,
+                                  RemoteInput,
+                                  EventObject
+                                >
+                              >
+                            | undefined;
+                        },
+                        {
+                          src: "load";
+                          logic: PromiseActorLogic<
+                            unknown,
+                            RemoteInput,
+                            EventObject
+                          >;
+                          id: string | undefined;
+                        },
+                        | {
+                            type: "setModule";
+                            params: {
+                              module: unknown;
+                            };
+                          }
+                        | {
+                            type: "setError";
+                            params: {
+                              error: unknown;
+                            };
+                          },
+                        never,
+                        never,
+                        "error" | "loading" | "loaded",
+                        "loading" | "ready" | "failed",
+                        RemoteInput,
+                        NonReducibleUnknown,
+                        EventObject,
+                        MetaObject,
+                        {
+                          id: "remote";
+                          states: {
+                            readonly loading: {};
+                            readonly loaded: {};
+                            readonly error: {};
+                          };
+                        }
+                      >;
+                      id: string | undefined;
+                    }
+                  | {
+                      src: "runWorker";
+                      logic: CallbackActorLogic<
+                        {
+                          type: string;
+                        },
+                        {
+                          key: string;
+                          serviceName: string;
+                          workerUrl: string;
+                        },
+                        EventObject
+                      >;
+                      id: string | undefined;
+                    },
+                  never,
+                  never,
+                  never,
+                  "error" | "loading" | "running",
+                  "loading" | "failed" | "running",
+                  ServiceInput,
+                  NonReducibleUnknown,
+                  EventObject,
+                  MetaObject,
+                  {
+                    id: "service";
+                    states: {
+                      readonly loading: {};
+                      readonly running: {};
+                      readonly error: {};
+                    };
+                  }
+                >
+              >
+            | undefined;
+        },
+        {
+          src: "service";
+          logic: StateMachine<
+            ServiceInput & {
+              workerUrl: string | null;
+            },
+            AnyEventObject,
+            {
+              [x: string]:
+                | ActorRefFromLogic<
+                    StateMachine<
+                      RemoteInput & {
+                        module: unknown;
+                        error: RemoteError | null;
+                      },
+                      AnyEventObject,
+                      {
+                        [x: string]:
+                          | ActorRefFromLogic<
+                              PromiseActorLogic<
+                                unknown,
+                                RemoteInput,
+                                EventObject
+                              >
+                            >
+                          | undefined;
+                      },
+                      {
+                        src: "load";
+                        logic: PromiseActorLogic<
+                          unknown,
+                          RemoteInput,
+                          EventObject
+                        >;
+                        id: string | undefined;
+                      },
+                      | {
+                          type: "setModule";
+                          params: {
+                            module: unknown;
+                          };
+                        }
+                      | {
+                          type: "setError";
+                          params: {
+                            error: unknown;
+                          };
+                        },
+                      never,
+                      never,
+                      "error" | "loading" | "loaded",
+                      "loading" | "ready" | "failed",
+                      RemoteInput,
+                      NonReducibleUnknown,
+                      EventObject,
+                      MetaObject,
+                      {
+                        id: "remote";
+                        states: {
+                          readonly loading: {};
+                          readonly loaded: {};
+                          readonly error: {};
+                        };
+                      }
+                    >
+                  >
+                | ActorRefFromLogic<
+                    CallbackActorLogic<
+                      {
+                        type: string;
+                      },
+                      {
+                        key: string;
+                        serviceName: string;
+                        workerUrl: string;
+                      },
+                      EventObject
+                    >
+                  >
+                | undefined;
+            },
+            | {
+                src: "loadInterface";
+                logic: StateMachine<
+                  RemoteInput & {
+                    module: unknown;
+                    error: RemoteError | null;
+                  },
+                  AnyEventObject,
+                  {
+                    [x: string]:
+                      | ActorRefFromLogic<
+                          PromiseActorLogic<unknown, RemoteInput, EventObject>
+                        >
+                      | undefined;
+                  },
+                  {
+                    src: "load";
+                    logic: PromiseActorLogic<unknown, RemoteInput, EventObject>;
+                    id: string | undefined;
+                  },
+                  | {
+                      type: "setModule";
+                      params: {
+                        module: unknown;
+                      };
+                    }
+                  | {
+                      type: "setError";
+                      params: {
+                        error: unknown;
+                      };
+                    },
+                  never,
+                  never,
+                  "error" | "loading" | "loaded",
+                  "loading" | "ready" | "failed",
+                  RemoteInput,
+                  NonReducibleUnknown,
+                  EventObject,
+                  MetaObject,
+                  {
+                    id: "remote";
+                    states: {
+                      readonly loading: {};
+                      readonly loaded: {};
+                      readonly error: {};
+                    };
+                  }
+                >;
+                id: string | undefined;
+              }
+            | {
+                src: "runWorker";
+                logic: CallbackActorLogic<
+                  {
+                    type: string;
+                  },
+                  {
+                    key: string;
+                    serviceName: string;
+                    workerUrl: string;
+                  },
+                  EventObject
+                >;
+                id: string | undefined;
+              },
+            never,
+            never,
+            never,
+            "error" | "loading" | "running",
+            "loading" | "failed" | "running",
+            ServiceInput,
+            NonReducibleUnknown,
+            EventObject,
+            MetaObject,
+            {
+              id: "service";
+              states: {
+                readonly loading: {};
+                readonly running: {};
+                readonly error: {};
+              };
+            }
+          >;
+          id: string | undefined;
+        },
+        {
+          type: "syncServices";
+          params: NonReducibleUnknown;
+        },
+        never,
+        never,
+        {},
+        string,
+        {
+          instance: FederationInstance;
+        },
+        NonReducibleUnknown,
+        EventObject,
+        MetaObject,
+        {
+          id: "services";
+        }
+      >;
+      id: "services";
+    }
+  | {
+      src: "telemetry";
+      logic: StateMachine<
+        {
+          instance: SanityInstance;
+          store: TelemetryStore<WorkbenchUserProperties> | null;
+          userProperties: WorkbenchUserProperties;
+        },
+        | {
+            type: "telemetry.start";
+          }
+        | {
+            type: "telemetry.stop";
+          },
+        {
+          [x: string]:
+            | ActorRefFromLogic<
+                PromiseActorLogic<
+                  {
+                    status: ConsentStatus;
+                  },
+                  {
+                    instance: SanityInstance;
+                  },
+                  EventObject
+                >
+              >
+            | undefined;
+        },
+        {
+          src: "checkConsent";
+          logic: PromiseActorLogic<
+            {
+              status: ConsentStatus;
+            },
+            {
+              instance: SanityInstance;
+            },
+            EventObject
+          >;
+          id: string | undefined;
+        },
+        | {
             type: "createStore";
             params: NonReducibleUnknown;
           }
@@ -926,6 +1711,12 @@ declare interface OSBaseInput extends Pick<OSContext, "instance"> {}
 
 declare type OSContext = {
   instance: SanityInstance;
+  /**
+   * The single module-federation instance every interface loads through —
+   * shared by the `remotes` (views) and `services` (workers) supervisors so an
+   * app's remote is registered once for all its interfaces.
+   */
+  federationInstance: FederationInstance;
   userProperties: WorkbenchUserProperties;
   systemPreferencesAdapter: SystemPreferencesAdapter | undefined;
 };
@@ -935,7 +1726,8 @@ declare type OSInput = WorkbenchUserProperties & {
 };
 
 declare type RemoteContext = RemoteInput & {
-  module: LoadedRemoteModule | null;
+  /** The loaded module, shape-agnostic — each consumer narrows it. @see {@link RemoteModuleByInterfaceType} */
+  module: unknown;
   error: RemoteError | null;
 };
 
@@ -951,18 +1743,22 @@ export declare interface RemoteError {
  * @internal
  */
 export declare interface RemoteInput {
-  id: string;
+  /** Fully-qualified module id — `${appId}/${expose}`. One child per moduleId. */
+  moduleId: string;
   entry: string;
   instance: FederationInstance;
 }
 
 /**
- * Lifecycle machine for a single federated application remote.
+ * Lifecycle machine for a single federated interface module — an application's
+ * `App` entry, one view component, or a worker service's loader. Interface-
+ * agnostic: it loads and tracks any module, leaving the shape contract
+ * (render vs. worker URL) to the consumer.
  *
- * Spawned by the {@link remotesLogic} supervisor on demand. Each instance
- * owns one remote's load lifecycle: `loading` → `loaded | error`. Tags
- * (`loading` / `ready` / `failed`) drive the UI contract — state names
- * are internal.
+ * Spawned by the {@link remotesLogic} supervisor on demand, one per remote id
+ * (`${appId}/${moduleId}`). Each instance owns one module's load lifecycle:
+ * `loading` → `loaded | error`. Tags (`loading` / `ready` / `failed`) drive the
+ * UI contract — state names are internal.
  *
  * The machine sends a `remote.settled` event to its parent on entry to
  * either terminal state, reserved for future supervision/retry.
@@ -974,20 +1770,18 @@ declare const remoteLogic: StateMachine<
   AnyEventObject,
   {
     [x: string]:
-      | ActorRefFromLogic<
-          PromiseActorLogic<LoadedRemoteModule, RemoteInput, EventObject>
-        >
+      | ActorRefFromLogic<PromiseActorLogic<unknown, RemoteInput, EventObject>>
       | undefined;
   },
   {
     src: "load";
-    logic: PromiseActorLogic<LoadedRemoteModule, RemoteInput, EventObject>;
+    logic: PromiseActorLogic<unknown, RemoteInput, EventObject>;
     id: string | undefined;
   },
   | {
       type: "setModule";
       params: {
-        module: LoadedRemoteModule;
+        module: unknown;
       };
     }
   | {
@@ -1014,6 +1808,21 @@ declare const remoteLogic: StateMachine<
   }
 >;
 
+/**
+ * The federated-module shape each interface type exposes, keyed by
+ * `interface_type`. Every interface — `panel`, `app`, `worker` — loads through
+ * the same {@link remoteLogic} lifecycle; this maps what its loaded module looks
+ * like so each consumer narrows the machine's shape-agnostic `module` to the
+ * right type: a render contract for `panel`/`app` (rendered by an island), a
+ * worker loader for `worker` (run as a Web Worker, never rendered).
+ * @public
+ */
+export declare interface RemoteModuleByInterfaceType {
+  panel: LoadedRemoteModule;
+  app: LoadedRemoteModule;
+  worker: ServiceLoaderModule;
+}
+
 /**
  * @public
  */
@@ -1027,6 +1836,204 @@ export declare interface RemoteRenderOptions {
   unstable_temporaryToken?: string | null;
 }
 
+declare type ServiceContext = ServiceInput & {
+  /** Resolved worker-bundle URL, absolute on the app origin. */
+  workerUrl: string | null;
+};
+
+/**
+ * @internal
+ */
+declare interface ServiceInput {
+  /** Stable child key, `${appId}:${serviceName}`. */
+  key: string;
+  appId: string;
+  serviceName: string;
+  /** The app's `mf-manifest.json` URL — the federation remote entry. */
+  entry: string;
+  instance: FederationInstance;
+}
+
+/**
+ * A worker service's loader module — the `worker` interface's expose. Carries
+ * the worker bundle URL (root-relative to the app origin) for the host to
+ * bootstrap, not a render function; the services counterpart of
+ * {@link LoadedRemoteModule}.
+ * @public
+ */
+export declare interface ServiceLoaderModule {
+  url: string;
+  type: string;
+  name: string;
+  version: number;
+}
+
+/**
+ * Lifecycle machine for a single background service worker.
+ *
+ * Spawned by the {@link servicesLogic} supervisor, one per `(app, service)`.
+ * `loading` loads the worker's loader module through the shared
+ * {@link remoteLogic} lifecycle — the same machine every interface (panel, app,
+ * worker) loads through — and reads the bundle URL off it. A worker isn't a
+ * render module, so it's never handed to an island; `running` bootstraps it as
+ * a Web Worker from that URL.
+ *
+ * @internal
+ */
+declare const serviceLogic: StateMachine<
+  ServiceContext,
+  AnyEventObject,
+  {
+    [x: string]:
+      | ActorRefFromLogic<
+          StateMachine<
+            RemoteInput & {
+              module: unknown;
+              error: RemoteError | null;
+            },
+            AnyEventObject,
+            {
+              [x: string]:
+                | ActorRefFromLogic<
+                    PromiseActorLogic<unknown, RemoteInput, EventObject>
+                  >
+                | undefined;
+            },
+            {
+              src: "load";
+              logic: PromiseActorLogic<unknown, RemoteInput, EventObject>;
+              id: string | undefined;
+            },
+            | {
+                type: "setModule";
+                params: {
+                  module: unknown;
+                };
+              }
+            | {
+                type: "setError";
+                params: {
+                  error: unknown;
+                };
+              },
+            never,
+            never,
+            "error" | "loading" | "loaded",
+            "loading" | "ready" | "failed",
+            RemoteInput,
+            NonReducibleUnknown,
+            EventObject,
+            MetaObject,
+            {
+              id: "remote";
+              states: {
+                readonly loading: {};
+                readonly loaded: {};
+                readonly error: {};
+              };
+            }
+          >
+        >
+      | ActorRefFromLogic<
+          CallbackActorLogic<
+            {
+              type: string;
+            },
+            {
+              key: string;
+              serviceName: string;
+              workerUrl: string;
+            },
+            EventObject
+          >
+        >
+      | undefined;
+  },
+  | {
+      src: "loadInterface";
+      logic: StateMachine<
+        RemoteInput & {
+          module: unknown;
+          error: RemoteError | null;
+        },
+        AnyEventObject,
+        {
+          [x: string]:
+            | ActorRefFromLogic<
+                PromiseActorLogic<unknown, RemoteInput, EventObject>
+              >
+            | undefined;
+        },
+        {
+          src: "load";
+          logic: PromiseActorLogic<unknown, RemoteInput, EventObject>;
+          id: string | undefined;
+        },
+        | {
+            type: "setModule";
+            params: {
+              module: unknown;
+            };
+          }
+        | {
+            type: "setError";
+            params: {
+              error: unknown;
+            };
+          },
+        never,
+        never,
+        "error" | "loading" | "loaded",
+        "loading" | "ready" | "failed",
+        RemoteInput,
+        NonReducibleUnknown,
+        EventObject,
+        MetaObject,
+        {
+          id: "remote";
+          states: {
+            readonly loading: {};
+            readonly loaded: {};
+            readonly error: {};
+          };
+        }
+      >;
+      id: string | undefined;
+    }
+  | {
+      src: "runWorker";
+      logic: CallbackActorLogic<
+        {
+          type: string;
+        },
+        {
+          key: string;
+          serviceName: string;
+          workerUrl: string;
+        },
+        EventObject
+      >;
+      id: string | undefined;
+    },
+  never,
+  never,
+  never,
+  "error" | "loading" | "running",
+  "loading" | "failed" | "running",
+  ServiceInput,
+  NonReducibleUnknown,
+  EventObject,
+  MetaObject,
+  {
+    id: "service";
+    states: {
+      readonly loading: {};
+      readonly running: {};
+      readonly error: {};
+    };
+  }
+>;
+
 /**
  * Adapter interface the host implements to give the system-preferences
  * machine access to the user's environment (OS color scheme, persistent