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

package/dist/system.js

@@ -0,0 +1,888 @@
+import { fromPromise, setup, assign, sendParent, fromObservable, fromCallback, enqueueActions, sendTo, raise } from "xstate";
+import { logger } from "./_chunks-es/index.js";
+import { createInstance } from "@sanity/federation/runtime";
+import { log } from "@sanity/federation/runtime/plugins/log";
+import { getAuthState, logout, AuthStateType, getClient, createSanityInstance } from "@sanity/sdk";
+import "./_chunks-es/studio.js";
+import { createSessionId, createBatchedStore } from "@sanity/telemetry";
+async function loadRemoteModule(instance, { moduleId, entry }) {
+  const name = moduleId.slice(0, moduleId.indexOf("/"));
+  return instance.registerRemotes([{ name, entry }]), await instance.loadRemote(moduleId) ?? null;
+}
+async function loadFederatedModule(instance, ref) {
+  try {
+    return await loadRemoteModule(instance, ref);
+  } catch (error) {
+    return logger.error(`Failed to load federated module "${ref.moduleId}"`, error), null;
+  }
+}
+class ModuleShapeError extends Error {
+  constructor(remoteId) {
+    super(`Remote "${remoteId}" did not expose a render function`);
+  }
+}
+class ModuleLoadError extends Error {
+  constructor(remoteId) {
+    super(`Remote module "${remoteId}" failed to load`);
+  }
+}
+const loadLogic = fromPromise(async ({ input }) => {
+  const remoteModule = await loadRemoteModule(input.instance, {
+    moduleId: input.moduleId,
+    entry: input.entry
+  });
+  if (remoteModule == null)
+    throw new ModuleLoadError(input.moduleId);
+  return remoteModule;
+}), remoteLogic = setup({
+  types: {
+    input: {},
+    context: {},
+    tags: {}
+  },
+  actors: {
+    load: loadLogic
+  },
+  actions: {
+    setModule: assign({
+      module: (_, params) => params.module,
+      error: () => null
+    }),
+    setError: assign({
+      module: () => null,
+      error: (_, params) => normaliseError(params.error)
+    })
+  }
+}).createMachine({
+  id: "remote",
+  initial: "loading",
+  context: ({ input }) => ({
+    ...input,
+    module: null,
+    error: null
+  }),
+  states: {
+    loading: {
+      tags: ["loading"],
+      invoke: {
+        src: "load",
+        input: ({ context }) => ({
+          moduleId: context.moduleId,
+          entry: context.entry,
+          instance: context.instance
+        }),
+        onDone: {
+          target: "loaded",
+          actions: [
+            {
+              type: "setModule",
+              params: ({ event }) => ({ module: event.output })
+            }
+          ]
+        },
+        onError: {
+          target: "error",
+          actions: [
+            {
+              type: "setError",
+              params: ({ event }) => ({ error: event.error })
+            }
+          ]
+        }
+      }
+    },
+    loaded: {
+      tags: ["ready"],
+      entry: sendParent(({ context }) => ({
+        type: "remote.settled",
+        moduleId: context.moduleId,
+        status: "loaded"
+      }))
+    },
+    error: {
+      tags: ["failed"],
+      entry: sendParent(({ context }) => ({
+        type: "remote.settled",
+        moduleId: context.moduleId,
+        status: "error"
+      }))
+    }
+  }
+});
+function normaliseError(error) {
+  return error instanceof Error ? { message: error.message, cause: error } : { message: String(error), cause: error };
+}
+const authStateLogic = fromObservable(
+  ({ input }) => getAuthState(input.instance).observable
+), logoutActorLogic = fromPromise(async ({ input }) => {
+  await logout(input.instance);
+}), authLogic = setup({
+  types: {
+    input: {},
+    context: {},
+    events: {},
+    tags: {}
+  },
+  actors: {
+    authState: authStateLogic,
+    logoutActor: logoutActorLogic
+  },
+  delays: {
+    authTimeout: 3e4
+  },
+  guards: {
+    isLoggedInComplete: (_, params) => params.state?.type === AuthStateType.LOGGED_IN && !!params.state.token && params.state.currentUser !== null,
+    isAuthState: (_, params) => params.state?.type === params.type
+  },
+  actions: {
+    setLoggedIn: assign({
+      token: (_, params) => params.token,
+      currentUser: (_, params) => params.currentUser,
+      error: () => null
+    }),
+    clearAuth: assign({
+      token: () => null,
+      currentUser: () => null,
+      error: () => null
+    }),
+    setError: assign({
+      token: () => null,
+      currentUser: () => null,
+      error: (_, params) => params.error
+    })
+  }
+}).createMachine({
+  id: "auth",
+  initial: "init",
+  context: ({ input }) => ({
+    instance: input.instance,
+    token: null,
+    currentUser: null,
+    error: null
+  }),
+  invoke: {
+    src: "authState",
+    input: ({ context }) => ({ instance: context.instance }),
+    onSnapshot: [
+      {
+        guard: {
+          type: "isLoggedInComplete",
+          params: ({ event }) => ({
+            state: event.snapshot.context
+          })
+        },
+        actions: [
+          {
+            type: "setLoggedIn",
+            params: ({ event }) => {
+              const state = event.snapshot.context;
+              return {
+                token: state.token,
+                currentUser: state.currentUser
+              };
+            }
+          }
+        ],
+        target: `.${AuthStateType.LOGGED_IN}`
+      },
+      {
+        guard: {
+          type: "isAuthState",
+          params: ({ event }) => ({
+            state: event.snapshot.context,
+            type: AuthStateType.LOGGING_IN
+          })
+        },
+        actions: [{ type: "clearAuth" }],
+        target: `.${AuthStateType.LOGGING_IN}`
+      },
+      {
+        guard: {
+          type: "isAuthState",
+          params: ({ event }) => ({
+            state: event.snapshot.context,
+            type: AuthStateType.ERROR
+          })
+        },
+        actions: [
+          {
+            type: "setError",
+            params: ({ event }) => ({
+              error: event.snapshot.context?.type === AuthStateType.ERROR ? event.snapshot.context.error : null
+            })
+          }
+        ],
+        target: `.${AuthStateType.ERROR}`
+      },
+      {
+        guard: {
+          type: "isAuthState",
+          params: ({ event }) => ({
+            state: event.snapshot.context,
+            type: AuthStateType.LOGGED_OUT
+          })
+        },
+        actions: [{ type: "clearAuth" }],
+        target: `.${AuthStateType.LOGGED_OUT}`
+      }
+    ]
+  },
+  states: {
+    init: {
+      tags: ["authenticating"],
+      after: {
+        authTimeout: {
+          actions: [
+            {
+              type: "setError",
+              params: () => ({
+                error: new Error("Authentication timed out")
+              })
+            }
+          ],
+          target: AuthStateType.ERROR
+        }
+      }
+    },
+    [AuthStateType.LOGGING_IN]: {
+      tags: ["authenticating"],
+      after: {
+        authTimeout: {
+          actions: [
+            {
+              type: "setError",
+              params: () => ({
+                error: new Error("Authentication timed out")
+              })
+            }
+          ],
+          target: AuthStateType.ERROR
+        }
+      }
+    },
+    [AuthStateType.LOGGED_IN]: {
+      tags: ["authenticated"],
+      on: {
+        "auth.logout": { target: "logging-out" }
+      }
+    },
+    "logging-out": {
+      invoke: {
+        src: "logoutActor",
+        input: ({ context }) => ({ instance: context.instance }),
+        onDone: {
+          target: AuthStateType.LOGGED_OUT
+        },
+        onError: {
+          actions: [
+            {
+              type: "setError",
+              params: ({ event }) => ({ error: event.error })
+            }
+          ],
+          target: AuthStateType.ERROR
+        }
+      }
+    },
+    [AuthStateType.LOGGED_OUT]: {},
+    [AuthStateType.ERROR]: { tags: ["error"] }
+  }
+}), actorPath = (ref) => {
+  const segments = [];
+  let current = ref;
+  for (; current; )
+    segments.unshift(current.id ?? current.sessionId), current = current._parent;
+  return segments.join(":");
+}, inspect = (event) => {
+  const ref = event.actorRef, log2 = logger.child(actorPath(ref));
+  switch (event.type) {
+    case "@xstate.snapshot": {
+      log2.debug("snapshot", event.snapshot);
+      break;
+    }
+    case "@xstate.event":
+      log2.debug("event", event.event);
+      break;
+    case "@xstate.action":
+      log2.debug("action", event.action);
+      break;
+  }
+}, remotesLogic = setup({
+  types: {
+    input: {},
+    context: {},
+    events: {}
+  },
+  actors: {
+    remote: remoteLogic
+  },
+  guards: {
+    remoteNotKnown: ({ context }, params) => !context.children.has(params.moduleId)
+  },
+  actions: {
+    spawnRemote: assign({
+      children: ({ context, spawn }, params) => {
+        const ref = spawn("remote", {
+          id: params.moduleId,
+          systemId: `remotes.${params.moduleId}`,
+          input: {
+            moduleId: params.moduleId,
+            entry: params.entry,
+            instance: context.instance
+          }
+        });
+        return new Map(context.children).set(params.moduleId, ref);
+      }
+    })
+  }
+}).createMachine({
+  id: "remotes",
+  context: ({ input }) => ({
+    instance: input.instance,
+    children: /* @__PURE__ */ new Map()
+  }),
+  on: {
+    "remote.load.request": {
+      guard: {
+        type: "remoteNotKnown",
+        params: ({ event }) => ({ moduleId: event.moduleId })
+      },
+      actions: [
+        {
+          type: "spawnRemote",
+          params: ({ event }) => ({
+            moduleId: event.moduleId,
+            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": {}
+  }
+}), SERVICES_MODULE = "services", runWorker = fromCallback(({ input }) => {
+  let worker, blobUrl;
+  try {
+    const bootstrap = `import(${JSON.stringify(input.workerUrl)})`;
+    blobUrl = URL.createObjectURL(
+      new Blob([bootstrap], { type: "text/javascript" })
+    ), worker = new Worker(blobUrl, { type: "module" }), worker.addEventListener("message", (event) => {
+      if (event.data?.kind === "workbench.worker.error")
+        logger.error(
+          `Service "${input.key}" worker error`,
+          event.data.payload?.message
+        );
+      else if (event.data?.kind === "workbench.worker.log") {
+        const { level, message } = event.data.payload ?? {};
+        ({
+          warn: logger.warn,
+          error: logger.error,
+          debug: logger.debug
+        }[level] ?? logger.info)(
+          `[service:${input.serviceName}] ${message ?? ""}`
+        );
+      }
+    }), worker.addEventListener("error", (event) => {
+      logger.error(
+        `Service "${input.key}" worker error: ${event.message || String(event)}`
+      );
+    });
+  } catch (error) {
+    logger.error(`Service "${input.key}" failed to start its worker`, error);
+  }
+  return () => {
+    try {
+      worker?.postMessage({ kind: "workbench.worker.terminate" });
+    } finally {
+      worker?.terminate(), blobUrl && URL.revokeObjectURL(blobUrl);
+    }
+  };
+}), serviceLogic = setup({
+  types: {
+    input: {},
+    context: {},
+    tags: {}
+  },
+  actors: {
+    loadInterface: remoteLogic,
+    runWorker
+  }
+}).createMachine({
+  id: "service",
+  initial: "loading",
+  context: ({ input }) => ({ ...input, workerUrl: null }),
+  // The invoked loader `sendParent`s a `remote.settled` on settle; this machine
+  // reacts via `onSnapshot` instead, so the event is a no-op here.
+  on: { "remote.settled": {} },
+  states: {
+    loading: {
+      tags: ["loading"],
+      invoke: {
+        id: "loader",
+        src: "loadInterface",
+        input: ({ context }) => ({
+          moduleId: `${context.appId}/${SERVICES_MODULE}/${context.serviceName}`,
+          entry: context.entry,
+          instance: context.instance
+        }),
+        onSnapshot: [
+          {
+            // Loaded and exposing a bundle URL → run it.
+            guard: ({ event }) => {
+              const module = event.snapshot.context.module;
+              return event.snapshot.hasTag("ready") && typeof module?.url == "string";
+            },
+            target: "running",
+            actions: assign({
+              workerUrl: ({ context, event }) => {
+                const module = event.snapshot.context.module;
+                return new URL(module.url, new URL(context.entry).origin).href;
+              }
+            })
+          },
+          {
+            // Load failed, or loaded without a usable URL → no worker.
+            guard: ({ event }) => {
+              const module = event.snapshot.context.module;
+              return event.snapshot.hasTag("failed") || event.snapshot.hasTag("ready") && typeof module?.url != "string";
+            },
+            target: "error",
+            // A worker has no UI surface (unlike a view's error boundary), so a
+            // failed load would otherwise be silent — log it through the host.
+            actions: ({ context, event }) => {
+              const cause = event.snapshot.context.error?.message;
+              logger.error(
+                `Service "${context.key}" failed to load its worker${cause ? `: ${cause}` : ""}`
+              );
+            }
+          }
+        ]
+      }
+    },
+    running: {
+      tags: ["running"],
+      invoke: {
+        src: "runWorker",
+        input: ({ context }) => ({
+          key: context.key,
+          serviceName: context.serviceName,
+          // `workerUrl` is set on entry to `running` from `loading`'s output.
+          workerUrl: context.workerUrl
+        })
+      }
+    },
+    error: {
+      tags: ["failed"]
+    }
+  }
+});
+function serviceKey(appId, serviceName) {
+  return `${appId}:${serviceName}`;
+}
+const servicesLogic = setup({
+  types: {
+    input: {},
+    context: {},
+    events: {}
+  },
+  actors: {
+    service: serviceLogic
+  },
+  actions: {
+    /**
+     * Reconcile the running workers against the desired set: spawn the ones not
+     * yet running, stop (and forget) the ones no longer declared.
+     */
+    syncServices: enqueueActions(({ context, event, enqueue }) => {
+      const desired = new Map(
+        event.services.map((service) => [
+          serviceKey(service.appId, service.serviceName),
+          service
+        ])
+      );
+      for (const [key, ref] of context.children)
+        desired.has(key) || enqueue.stopChild(ref);
+      enqueue.assign({
+        children: ({ context: ctx, spawn }) => {
+          const next = /* @__PURE__ */ new Map();
+          for (const [key, ref] of ctx.children)
+            desired.has(key) && next.set(key, ref);
+          for (const [key, service] of desired)
+            next.has(key) || next.set(
+              key,
+              spawn("service", {
+                id: key,
+                systemId: `services.${key}`,
+                input: {
+                  key,
+                  appId: service.appId,
+                  serviceName: service.serviceName,
+                  entry: service.entry,
+                  instance: ctx.instance
+                }
+              })
+            );
+          return next;
+        }
+      });
+    })
+  }
+}).createMachine({
+  id: "services",
+  context: ({ input }) => ({
+    instance: input.instance,
+    children: /* @__PURE__ */ new Map()
+  }),
+  on: {
+    "services.sync": { actions: "syncServices" }
+  }
+}), DEFAULT_PREFERRED_COLOR_SCHEME = "system", DEFAULT_OS_COLOR_SCHEME = "light", resolveColorScheme = (preferred, osColorScheme) => preferred === "system" ? osColorScheme : preferred, adapterBridgeLogic = fromCallback(({ input: adapter, sendBack, receive }) => {
+  if (!adapter) return;
+  const unsubscribePreferredColorScheme = adapter.subscribePreferredColorScheme(
+    (next) => {
+      sendBack({
+        type: "preferredColorScheme.set",
+        preferredColorScheme: next ?? "system"
+      });
+    }
+  ), unsubscribeOs = adapter.subscribeOsColorScheme((next) => {
+    sendBack({ type: "osColorScheme.set", osColorScheme: next });
+  });
+  return receive((event) => {
+    adapter.getPreferredColorScheme() !== event.preferredColorScheme && adapter.persistPreferredColorScheme(event.preferredColorScheme);
+  }), () => {
+    unsubscribePreferredColorScheme(), unsubscribeOs();
+  };
+}), systemPreferencesLogic = setup({
+  types: {
+    input: {},
+    context: {},
+    events: {}
+  },
+  actors: {
+    adapterBridge: adapterBridgeLogic
+  },
+  actions: {
+    setPreferredColorScheme: assign({
+      preferredColorScheme: (_, params) => params.preferredColorScheme,
+      colorScheme: ({ context }, params) => resolveColorScheme(params.preferredColorScheme, context.osColorScheme)
+    }),
+    setOsColorScheme: assign({
+      osColorScheme: (_, params) => params.osColorScheme,
+      colorScheme: ({ context }, params) => resolveColorScheme(context.preferredColorScheme, params.osColorScheme)
+    })
+  }
+}).createMachine({
+  id: "system-preferences",
+  initial: "ready",
+  context: ({ input }) => {
+    const adapter = input.adapter, preferredColorScheme = adapter?.getPreferredColorScheme() ?? DEFAULT_PREFERRED_COLOR_SCHEME, osColorScheme = adapter?.getOsColorScheme() ?? DEFAULT_OS_COLOR_SCHEME;
+    return {
+      adapter,
+      preferredColorScheme,
+      osColorScheme,
+      colorScheme: resolveColorScheme(preferredColorScheme, osColorScheme)
+    };
+  },
+  invoke: {
+    id: "adapter",
+    src: "adapterBridge",
+    input: ({ context }) => context.adapter
+  },
+  states: {
+    ready: {
+      on: {
+        "preferredColorScheme.set": {
+          actions: [
+            {
+              type: "setPreferredColorScheme",
+              params: ({ event }) => ({
+                preferredColorScheme: event.preferredColorScheme
+              })
+            },
+            // Forward to the adapter bridge so it can persist the user's
+            // choice. The bridge guards against redundant writes, so
+            // round-tripping a `preferredColorScheme.set` it sourced itself
+            // (e.g. from a `storage` event in another tab) is a no-op.
+            sendTo("adapter", ({ event }) => event)
+          ]
+        },
+        "osColorScheme.set": {
+          actions: [
+            {
+              type: "setOsColorScheme",
+              params: ({ event }) => ({
+                osColorScheme: event.osColorScheme
+              })
+            }
+          ]
+        }
+      }
+    }
+  }
+}), TELEMETRY_API_VERSION = "2024-11-12", FLUSH_INTERVAL_MS = 3e4, checkConsentLogic = fromPromise(async ({ input, signal }) => {
+  try {
+    return await getClient(input.instance, {
+      apiVersion: TELEMETRY_API_VERSION
+    }).request({
+      uri: "/intake/telemetry-status",
+      tag: "telemetry-consent",
+      signal
+    });
+  } catch {
+    return { status: "undetermined" };
+  }
+}), telemetryLogic = setup({
+  types: {
+    input: {},
+    context: {},
+    events: {}
+  },
+  actors: {
+    checkConsent: checkConsentLogic
+  },
+  guards: {
+    isConsentGranted: (_, params) => params.status === "granted"
+  },
+  actions: {
+    createStore: assign({
+      store: ({ context }) => {
+        const sessionId = createSessionId(), client = getClient(context.instance, {
+          apiVersion: TELEMETRY_API_VERSION
+        }), store = createBatchedStore(sessionId, {
+          flushInterval: FLUSH_INTERVAL_MS,
+          resolveConsent: () => client.request({
+            uri: "/intake/telemetry-status",
+            tag: "telemetry-consent"
+          }),
+          sendEvents: (batch) => client.request({
+            uri: "/intake/batch",
+            method: "POST",
+            body: { batch },
+            tag: "telemetry.batch"
+          }),
+          sendBeacon: (batch) => typeof navigator > "u" ? !1 : navigator.sendBeacon(
+            client.getUrl("/intake/batch"),
+            JSON.stringify({ batch })
+          )
+        });
+        return store.logger.updateUserProperties(context.userProperties), store;
+      }
+    }),
+    teardownStore: ({ context }) => {
+      context.store?.end();
+    }
+  }
+}).createMachine({
+  id: "telemetry",
+  initial: "idle",
+  context: ({ input }) => ({
+    instance: input.instance,
+    store: null,
+    userProperties: {
+      version: input.version,
+      organizationId: input.organizationId,
+      environment: input.environment,
+      userAgent: input.userAgent
+    }
+  }),
+  states: {
+    idle: {
+      on: {
+        "telemetry.start": {
+          target: "checkingConsent"
+        }
+      }
+    },
+    checkingConsent: {
+      invoke: {
+        src: "checkConsent",
+        input: ({ context }) => ({
+          instance: context.instance
+        }),
+        onDone: [
+          {
+            guard: {
+              type: "isConsentGranted",
+              params: ({ event }) => ({
+                status: event.output.status
+              })
+            },
+            actions: [{ type: "createStore" }],
+            target: "active"
+          },
+          {
+            target: "denied"
+          }
+        ]
+      }
+    },
+    active: {
+      tags: ["telemetry-resolved"],
+      exit: [{ type: "teardownStore" }],
+      on: {
+        "telemetry.stop": { target: "stopped" }
+      }
+    },
+    stopped: {
+      type: "final"
+    },
+    denied: {
+      tags: ["telemetry-resolved"]
+    }
+  }
+}), os = setup({
+  types: {
+    input: {},
+    context: {},
+    events: {},
+    // https://github.com/statelyai/xstate/issues/5515
+    children: {}
+  },
+  actors: {
+    auth: authLogic,
+    telemetry: telemetryLogic,
+    systemPreferences: systemPreferencesLogic,
+    remotes: remotesLogic,
+    services: servicesLogic
+  },
+  guards: {
+    hasTag: (_, params) => params.hasTag
+  },
+  actions: {
+    raiseAuthReady: raise({ type: "boot.auth.ready" }),
+    raiseAuthFailed: raise({ type: "boot.auth.failed" }),
+    raiseTelemetryReady: raise({
+      type: "boot.telemetry.ready"
+    }),
+    startTelemetry: sendTo("telemetry", {
+      type: "telemetry.start"
+    })
+  }
+}).createMachine({
+  id: "os",
+  context: ({ input }) => ({
+    instance: createSanityInstance(),
+    federationInstance: createInstance({
+      name: "workbench-applications",
+      plugins: [log(logger.debug)]
+    }),
+    userProperties: {
+      version: input.version,
+      organizationId: input.organizationId,
+      environment: input.environment,
+      userAgent: input.userAgent
+    },
+    systemPreferencesAdapter: input.systemPreferencesAdapter
+  }),
+  initial: "booting",
+  invoke: [
+    {
+      id: "auth",
+      systemId: "auth",
+      src: "auth",
+      input: ({ context }) => ({ instance: context.instance }),
+      onSnapshot: [
+        {
+          guard: {
+            type: "hasTag",
+            params: ({ event }) => ({
+              hasTag: event.snapshot.hasTag("authenticated")
+            })
+          },
+          actions: [{ type: "raiseAuthReady" }]
+        },
+        {
+          guard: {
+            type: "hasTag",
+            params: ({ event }) => ({
+              hasTag: event.snapshot.hasTag("error")
+            })
+          },
+          actions: [{ type: "raiseAuthFailed" }]
+        }
+      ]
+    },
+    {
+      id: "telemetry",
+      systemId: "telemetry",
+      src: "telemetry",
+      input: ({ context }) => ({
+        instance: context.instance,
+        ...context.userProperties
+      }),
+      onSnapshot: [
+        {
+          guard: {
+            type: "hasTag",
+            params: ({ event }) => ({
+              hasTag: event.snapshot.hasTag("telemetry-resolved")
+            })
+          },
+          actions: [{ type: "raiseTelemetryReady" }]
+        }
+      ]
+    },
+    {
+      id: "system-preferences",
+      systemId: "system-preferences",
+      src: "systemPreferences",
+      input: ({ context }) => ({ adapter: context.systemPreferencesAdapter })
+    },
+    {
+      id: "remotes",
+      systemId: "remotes",
+      src: "remotes",
+      input: ({ context }) => ({ instance: context.federationInstance })
+    },
+    {
+      id: "services",
+      systemId: "services",
+      src: "services",
+      input: ({ context }) => ({ instance: context.federationInstance })
+    }
+  ],
+  states: {
+    booting: {
+      initial: "auth",
+      states: {
+        auth: {
+          on: {
+            "boot.auth.ready": {
+              target: "telemetry",
+              actions: [{ type: "startTelemetry" }]
+            },
+            "boot.auth.failed": { target: "error" }
+          }
+        },
+        telemetry: {
+          on: {
+            "boot.telemetry.ready": { target: "done" }
+          }
+        },
+        error: {},
+        done: { type: "final" }
+      },
+      onDone: { target: "running" }
+    },
+    running: {
+      type: "parallel"
+    }
+  }
+});
+function createOSOptions(input) {
+  return {
+    id: "os",
+    input,
+    inspect
+  };
+}
+export {
+  ModuleShapeError,
+  createOSOptions,
+  loadFederatedModule,
+  os
+};
+//# sourceMappingURL=system.js.map