@sanity/workbench 0.1.0-alpha.16 → 0.1.0-alpha.18

package/src/system/remotes.machine.ts

@@ -0,0 +1,86 @@
+import {
+  createInstance,
+  type FederationInstance,
+} from "@sanity/federation/runtime";
+import { log } from "@sanity/federation/runtime/plugins/log";
+import { type ActorRefFrom, assign, setup } from "xstate";
+
+import { logger } from "../core/log";
+import { remoteLogic } from "./remote.machine";
+
+type RemotesContext = {
+  instance: FederationInstance;
+  children: Map<string, ActorRefFrom<typeof remoteLogic>>;
+};
+
+type RemotesEvent =
+  | { type: "remote.load.request"; id: string; entry: string }
+  | { type: "remote.settled"; id: string; status: "loaded" | "error" };
+
+/**
+ * Supervisor machine for federated application remotes.
+ *
+ * Owns a single {@link FederationInstance} (the `workbench-applications`
+ * instance) and spawns one {@link remoteLogic} child per requested
+ * remote. The supervisor is invoked at the root of the OS machine for
+ * inspector visibility (`[sanity-workbench:os:remotes]`) — boot does
+ * not gate on it.
+ *
+ * @internal
+ */
+export const remotesLogic = setup({
+  types: {
+    context: {} as RemotesContext,
+    events: {} as RemotesEvent,
+  },
+  actors: {
+    remote: remoteLogic,
+  },
+  guards: {
+    remoteNotKnown: ({ context }, params: { id: string }) =>
+      !context.children.has(params.id),
+  },
+  actions: {
+    spawnRemote: assign({
+      children: ({ context, spawn }, params: { id: string; entry: string }) => {
+        const ref = spawn("remote", {
+          id: params.id,
+          systemId: `remotes.${params.id}`,
+          input: {
+            id: params.id,
+            entry: params.entry,
+            instance: context.instance,
+          },
+        });
+        return new Map(context.children).set(params.id, ref);
+      },
+    }),
+  },
+}).createMachine({
+  id: "remotes",
+  context: () => ({
+    instance: createInstance({
+      name: "workbench-applications",
+      plugins: [log(logger.debug)],
+    }),
+    children: new Map(),
+  }),
+  on: {
+    "remote.load.request": {
+      guard: {
+        type: "remoteNotKnown",
+        params: ({ event }) => ({ id: event.id }),
+      },
+      actions: [
+        {
+          type: "spawnRemote",
+          params: ({ event }) => ({ id: event.id, entry: event.entry }),
+        },
+      ],
+    },
+    // Reserved for future supervision/retry. Forwarded by per-remote
+    // children on entry to `loaded` or `error`; currently a no-op so the
+    // event is part of the typed surface rather than a silent unknown.
+    "remote.settled": {},
+  },
+});

package/src/system/root.machine.ts

@@ -3,6 +3,7 @@ import { raise, sendTo, setup, type ActorOptions } from "xstate";
 
 import { authLogic } from "./auth.machine";
 import { inspect } from "./inspect";
+import { remotesLogic } from "./remotes.machine";
 import {
   type SystemPreferencesAdapter,
   systemPreferencesLogic,
@@ -57,12 +58,14 @@ export const os = setup({
       auth: "auth";
       telemetry: "telemetry";
       "system-preferences": "systemPreferences";
+      remotes: "remotes";
     },
   },
   actors: {
     auth: authLogic,
     telemetry: telemetryLogic,
     systemPreferences: systemPreferencesLogic,
+    remotes: remotesLogic,
   },
   guards: {
     hasTag: (_, params: { hasTag: boolean }) => params.hasTag,
@@ -143,6 +146,11 @@ export const os = setup({
       src: "systemPreferences",
       input: ({ context }) => ({ adapter: context.systemPreferencesAdapter }),
     },
+    {
+      id: "remotes",
+      systemId: "remotes",
+      src: "remotes",
+    },
   ],
   states: {
     booting: {