@sanity/workbench-cli 1.1.0-beta.0

package/dist/_exports/index.d.ts

@@ -0,0 +1,307 @@
+import { z } from "zod/mini";
+
+/**
+ * User-facing input for `unstable_defineApp`. Excludes the internal
+ * `applicationType` — that field is validated by the schema but is not part of
+ * the public surface (Sanity-owned apps set it via `@ts-expect-error`).
+ * @public
+ */
+export declare type DefineAppInput = Omit<
+  z.output<typeof DefineAppInputSchema>,
+  "applicationType"
+>;
+
+/**
+ * Runtime-validation schema for `unstable_defineApp`. Validates the full shape
+ * including the internal `applicationType`; the user-facing `DefineAppInput`
+ * type below omits that field.
+ * @internal
+ */
+declare const DefineAppInputSchema: z.ZodMiniObject<
+  {
+    applicationType: z.ZodMiniOptional<
+      z.ZodMiniEnum<{
+        coreApp: "coreApp";
+        studio: "studio";
+        canvas: "canvas";
+        dashboard: "dashboard";
+        "media-library": "media-library";
+      }>
+    >;
+    entry: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    group: z.ZodMiniOptional<
+      z.ZodMiniEnum<{
+        "dock.system": "dock.system";
+        "dock.applications": "dock.applications";
+        "dock.user": "dock.user";
+      }>
+    >;
+    icon: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    name: z.ZodMiniString<string>;
+    organizationId: z.ZodMiniString<string>;
+    priority: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    services: z.ZodMiniOptional<
+      z.ZodMiniArray<
+        z.ZodMiniDiscriminatedUnion<
+          [
+            z.ZodMiniObject<
+              {
+                name: z.ZodMiniString<string>;
+                src: z.ZodMiniString<string>;
+                type: z.ZodMiniLiteral<"worker">;
+              },
+              z.core.$strip
+            >,
+          ],
+          "type"
+        >
+      >
+    >;
+    title: z.ZodMiniString<string>;
+    views: z.ZodMiniOptional<
+      z.ZodMiniArray<
+        z.ZodMiniDiscriminatedUnion<
+          [
+            z.ZodMiniObject<
+              {
+                name: z.ZodMiniString<string>;
+                src: z.ZodMiniString<string>;
+                type: z.ZodMiniLiteral<"panel">;
+              },
+              z.core.$strip
+            >,
+          ],
+          "type"
+        >
+      >
+    >;
+  },
+  z.core.$strip
+>;
+
+/**
+ * The branded result of `unstable_defineApp`. Carries the same fields as the
+ * input plus the internal brand — users only ever see `DefineAppInput`.
+ * @public
+ */
+export declare interface DefineAppResult extends DefineAppInput {
+  readonly [WORKBENCH_APP]: true;
+}
+
+/**
+ * The result of `unstable_defineService`: the author's callback, the service
+ * type, and the internal contract version the worker artifact targets.
+ * @public
+ */
+export declare interface DefinedService<
+  TType extends ServiceType = ServiceType,
+> {
+  readonly run: ServiceCallbacksByType[TType];
+  readonly type: TType;
+  /** @internal */
+  readonly version: typeof SERVICE_CONTRACT_VERSION;
+}
+
+/**
+ * The result of `unstable_defineView`: the author's component(s), the view type,
+ * and the internal contract version the build artifact targets.
+ * @public
+ */
+export declare interface DefinedView<
+  TType extends InterfaceType = InterfaceType,
+> {
+  readonly components: ViewComponentsByType[TType];
+  readonly type: TType;
+  /** @internal */
+  readonly version: typeof VIEW_CONTRACT_VERSION;
+}
+
+/**
+ * Dock group identifier. The API does not block a user app from declaring a
+ * reserved group (e.g. `dock.system`); priority conventions keep Sanity-owned
+ * apps ahead.
+ * @public
+ */
+export declare type DockGroup = z.output<typeof DockGroupSchema>;
+
+/** Dock groups an app can place itself into. */
+declare const DockGroupSchema: z.ZodMiniEnum<{
+  "dock.system": "dock.system";
+  "dock.applications": "dock.applications";
+  "dock.user": "dock.user";
+}>;
+
+/**
+ * Every supported interface type — the first argument to `unstable_defineView`.
+ * @public
+ */
+export declare type InterfaceType = keyof typeof VIEW_COMPONENTS;
+
+/**
+ * A panel's view-component slot — the module-federation expose for one island.
+ * @public
+ */
+export declare type PanelComponent = keyof PanelViewComponents;
+
+/**
+ * The component slots a `panel` view exposes — each its own module-federation
+ * island, typed with the panel props.
+ * @public
+ */
+export declare interface PanelViewComponents {
+  panel: ViewComponent<PanelViewProps>;
+  title: ViewComponent<PanelViewProps>;
+}
+
+/**
+ * Props a panel component receives: its interface record, minus the
+ * service-assigned `id`/`deployment_id` a local dev server can't provide. Mirrors
+ * the `panel` record the workbench host renders from (the wire format owned by
+ * `@sanity/workbench`); drift is guarded by the stamped contract version.
+ * @public
+ */
+export declare type PanelViewProps = ViewComponentBaseProps<{
+  entry_point: string;
+  interface_type: "panel";
+  name: string;
+}>;
+
+/**
+ * Contract version stamped on every defined service. Lets the workbench host
+ * and the generated worker artifact evolve the service contract without
+ * breaking already-deployed services; bumped only on a breaking change.
+ * @internal
+ */
+declare const SERVICE_CONTRACT_VERSION = 1;
+
+/**
+ * A service callback. Runs once inside the worker on start; returns an optional
+ * disposer the host calls before terminating the worker.
+ * @public
+ */
+export declare type ServiceCallback = (
+  context: ServiceContext,
+) => (() => void) | void;
+
+/** The callback shape each service type defines, keyed by type. */
+declare interface ServiceCallbacksByType {
+  worker: ServiceCallback;
+}
+
+/**
+ * Context every service callback receives when its worker starts. Mirrors how a
+ * view component receives its `view` — the service receives its own `service`.
+ * @public
+ */
+export declare interface ServiceContext {
+  readonly service: ServiceInfo;
+}
+
+/**
+ * The service's own declaration, surfaced to the callback.
+ * @public
+ */
+export declare interface ServiceInfo {
+  readonly name: string;
+  readonly type: string;
+}
+
+/**
+ * Every supported service type — the first argument to `unstable_defineService`.
+ * Add a service type by adding its declaration schema below and registering it
+ * here.
+ * @public
+ */
+export declare type ServiceType = "worker";
+
+/**
+ * Declare a Sanity Workbench application. Identity at runtime — returns the same
+ * object reference, tagged with the workbench brand. Field validation (the
+ * `name` pattern etc.) runs at build time in the CLI via `DefineAppInputSchema`;
+ * this helper stays a thin, pure identity wrapper.
+ * @public
+ */
+export declare function unstable_defineApp(
+  input: DefineAppInput,
+): DefineAppResult;
+
+/**
+ * Define a Sanity Workbench background service. The first argument narrows the
+ * callback shape — `"worker"` runs the callback inside a Web Worker, where it
+ * can emit dock-badge updates and return a disposer.
+ *
+ * Identity at runtime: returns the callback tagged with its type and the contract
+ * version, for the CLI build to generate a worker artifact from. Used as the
+ * default export of a service's `src` file.
+ * @public
+ */
+export declare function unstable_defineService<TType extends ServiceType>(
+  type: TType,
+  run: ServiceCallbacksByType[TType],
+): DefinedService<TType>;
+
+/**
+ * Define a Sanity Workbench view. The first argument narrows the component shape
+ * and the props each component receives — `"panel"` yields a `{title, panel}`
+ * record whose components are typed with the panel props.
+ *
+ * Returns the component(s) tagged with their type and the contract version, for
+ * the CLI build to generate render artifacts from. Used as the default export of
+ * a view's `src` file.
+ * @public
+ */
+export declare function unstable_defineView<TType extends InterfaceType>(
+  type: TType,
+  components: ViewComponentsByType[TType],
+): DefinedView<TType>;
+
+/**
+ * Component slots each interface type exposes, in render order — the source of
+ * truth for {@link InterfaceType} and for the build (the vite plugin expands a
+ * view into one render artifact per component). Add a type by registering it here.
+ * @internal
+ */
+declare const VIEW_COMPONENTS: {
+  readonly panel: readonly ["title", "panel"];
+};
+
+/**
+ * Contract version stamped on every defined view — lets the host and the
+ * generated artifact evolve the contract without breaking deployed views.
+ * @internal
+ */
+declare const VIEW_CONTRACT_VERSION = 1;
+
+/**
+ * A view component. The return is opaque so the runtime helpers carry no React
+ * dependency — the generated artifact renders it with the app's own React.
+ * @public
+ */
+declare type ViewComponent<TProps> = (props: TProps) => unknown;
+
+/**
+ * Props every view component receives, whatever its type. Per-type props
+ * compose from this, so a prop added here reaches every view.
+ * @public
+ */
+declare interface ViewComponentBaseProps<TView> {
+  view: TView;
+}
+
+/**
+ * The components each interface type exposes, keyed by type.
+ * @public
+ */
+export declare interface ViewComponentsByType {
+  panel: PanelViewComponents;
+}
+
+/**
+ * Nominal brand the CLI discriminates on to enable the workbench build/deploy
+ * codepath. Registered via `Symbol.for` so the marker survives module-realm
+ * boundaries — `@sanity/cli-core` re-derives the same global symbol with
+ * `Symbol.for` rather than importing it, so it stays internal to this module.
+ */
+declare const WORKBENCH_APP: unique symbol;
+
+export {};

package/dist/_exports/index.js

@@ -0,0 +1,15 @@
+// Public, browser-safe entry for `@sanity/workbench-cli` — the authoring API app
+// authors call from `sanity.cli.ts` (re-exported by `sanity/cli` and the
+// `sanity` runtime entry). Calling `unstable_defineApp` is the *sole* workbench
+// opt-in: it stamps the global brand `Symbol.for('sanity.workbench.defineApp')`,
+// which the CLI discriminates on (see `isWorkbenchApp` in `@sanity/cli-core`).
+//
+// This module graph must stay browser-safe: zod-only, no `node:*`, no vite, no
+// `@sanity/cli-core`. View/service `src` files bundle to the browser, so anything
+// reachable from here ships in the frontend bundle. The Node-only build glue
+// lives behind the separate `./vite` entry and never leaks in.
+export { unstable_defineApp } from '../defineApp.js';
+export { unstable_defineService } from '../defineService.js';
+export { unstable_defineView } from '../defineView.js';
+
+//# sourceMappingURL=index.js.map

package/dist/_exports/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/_exports/index.ts"],"sourcesContent":["// Public, browser-safe entry for `@sanity/workbench-cli` — the authoring API app\n// authors call from `sanity.cli.ts` (re-exported by `sanity/cli` and the\n// `sanity` runtime entry). Calling `unstable_defineApp` is the *sole* workbench\n// opt-in: it stamps the global brand `Symbol.for('sanity.workbench.defineApp')`,\n// which the CLI discriminates on (see `isWorkbenchApp` in `@sanity/cli-core`).\n//\n// This module graph must stay browser-safe: zod-only, no `node:*`, no vite, no\n// `@sanity/cli-core`. View/service `src` files bundle to the browser, so anything\n// reachable from here ships in the frontend bundle. The Node-only build glue\n// lives behind the separate `./vite` entry and never leaks in.\nexport type {InterfaceType, ServiceType} from '../contract.js'\nexport {unstable_defineApp} from '../defineApp.js'\nexport type {DefineAppInput, DefineAppResult, DockGroup} from '../defineApp.js'\nexport {unstable_defineService} from '../defineService.js'\nexport type {\n  DefinedService,\n  ServiceCallback,\n  ServiceContext,\n  ServiceInfo,\n} from '../defineService.js'\nexport {unstable_defineView} from '../defineView.js'\nexport type {\n  DefinedView,\n  PanelComponent,\n  PanelViewComponents,\n  PanelViewProps,\n  ViewComponentsByType,\n} from '../defineView.js'\n"],"names":["unstable_defineApp","unstable_defineService","unstable_defineView"],"mappings":"AAAA,iFAAiF;AACjF,yEAAyE;AACzE,gFAAgF;AAChF,iFAAiF;AACjF,+EAA+E;AAC/E,EAAE;AACF,+EAA+E;AAC/E,kFAAkF;AAClF,6EAA6E;AAC7E,+DAA+D;AAE/D,SAAQA,kBAAkB,QAAO,kBAAiB;AAElD,SAAQC,sBAAsB,QAAO,sBAAqB;AAO1D,SAAQC,mBAAmB,QAAO,mBAAkB"}

package/dist/_exports/init.d.ts

@@ -0,0 +1,12 @@
+/** App scaffold — `entry` auto-declares the navigable app view. */
+export declare const workbenchAppConfigTemplate =
+  "\nimport {defineCliConfig, unstable_defineApp} from 'sanity/cli'\n\nexport default defineCliConfig({\n  app: unstable_defineApp({\n    name: '%name%',\n    title: '%title%',\n    organizationId: '%organizationId%',\n    entry: '%entry%',\n  }),\n})\n";
+
+/**
+ * Studio scaffold — brands with name/title only, no `entry` (studio app views
+ * aren't implemented yet).
+ */
+export declare const workbenchStudioConfigTemplate =
+  "\nimport {defineCliConfig, unstable_defineApp} from 'sanity/cli'\n\nexport default defineCliConfig({\n  api: {\n    projectId: '%projectId%',\n    dataset: '%dataset%'\n  },\n  app: unstable_defineApp({\n    name: '%name%',\n    title: '%title%',\n    organizationId: '%organizationId%',\n  }),\n  deployment: {\n    /**\n     * Enable auto-updates for studios.\n     * Learn more at https://www.sanity.io/docs/studio/latest-version-of-sanity#k47faf43faf56\n     */\n    autoUpdates: __BOOL__autoUpdates__,\n  },\n})\n";
+
+export {};

package/dist/_exports/init.js

@@ -0,0 +1,5 @@
+// Browser-safe `init` entry: the workbench `sanity.cli.ts` config templates the
+// CLI's init scaffolding fills in. Plain strings — no runtime deps.
+export { workbenchAppConfigTemplate, workbenchStudioConfigTemplate } from '../actions/init/cliConfig.js';
+
+//# sourceMappingURL=init.js.map

package/dist/_exports/init.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/_exports/init.ts"],"sourcesContent":["// Browser-safe `init` entry: the workbench `sanity.cli.ts` config templates the\n// CLI's init scaffolding fills in. Plain strings — no runtime deps.\nexport {\n  workbenchAppConfigTemplate,\n  workbenchStudioConfigTemplate,\n} from '../actions/init/cliConfig.js'\n"],"names":["workbenchAppConfigTemplate","workbenchStudioConfigTemplate"],"mappings":"AAAA,gFAAgF;AAChF,oEAAoE;AACpE,SACEA,0BAA0B,EAC1BC,6BAA6B,QACxB,+BAA8B"}

package/dist/actions/build/artifact.js

@@ -0,0 +1,29 @@
+import { serviceArtifacts } from './services/artifact.js';
+import { viewArtifacts } from './views/artifact.js';
+/**
+ * Map the artifacts the host loads directly (those with an `expose`) to their
+ * runtime-dir paths, for the module-federation `exposes` field. `toExposePath`
+ * turns a runtime-relative artifact path into the value federation wants — the
+ * caller owns the runtime-dir location and any entry resolution.
+ */ export function artifactExposes(artifacts, toExposePath) {
+    const exposes = {};
+    for (const artifact of artifacts){
+        if (artifact.expose) {
+            exposes[artifact.expose] = toExposePath(artifact.path);
+        }
+    }
+    return exposes;
+}
+/**
+ * Expand a workbench app's declared views and services into the flat artifact
+ * set the federation build writes and exposes — the single place that composes
+ * the per-type expanders, so the expose mapping and the file writing read from
+ * one expansion rather than re-deriving it.
+ */ export function workbenchArtifacts(options) {
+    return [
+        ...viewArtifacts(options.views),
+        ...serviceArtifacts(options.services ?? [])
+    ];
+}
+
+//# sourceMappingURL=artifact.js.map

package/dist/actions/build/artifact.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/build/artifact.ts"],"sourcesContent":["import {type ServiceArtifact, serviceArtifacts} from './services/artifact.js'\nimport {type InterfaceArtifact, viewArtifacts} from './views/artifact.js'\n\n/**\n * What a {@link GeneratedArtifact.source} builder receives from the build — the\n * one thing it can't compute on its own, since only the build knows where the\n * runtime dir sits relative to the app's `src`.\n */\ninterface ArtifactContext {\n  /** Import specifier for an app `src` file, relative to this artifact. */\n  resolveImport: (src: string) => string\n}\n\n/**\n * One file the federation build generates into the runtime dir for a declared\n * interface. Each interface type — views, services — expands its declarations\n * into a flat list of these; the build then writes them and maps the ones the\n * host loads directly into the module-federation manifest.\n *\n * Adding an interface type is adding a builder that returns\n * `GeneratedArtifact[]` — the write loop and the expose mapping never change.\n */\nexport interface GeneratedArtifact {\n  /** Path relative to the federation runtime dir, e.g. `views/feed/panel.js`. */\n  path: string\n  /** Build the file's contents. */\n  source: (context: ArtifactContext) => string\n\n  /**\n   * Module-federation expose key when the host loads this artifact directly —\n   * a view component `./views/feed/panel`, a service loader `./services/unread`.\n   * Omitted for a file the host never loads on its own, like a worker bundle\n   * (reached through its sibling loader).\n   */\n  expose?: string\n}\n\n/**\n * Map the artifacts the host loads directly (those with an `expose`) to their\n * runtime-dir paths, for the module-federation `exposes` field. `toExposePath`\n * turns a runtime-relative artifact path into the value federation wants — the\n * caller owns the runtime-dir location and any entry resolution.\n */\nexport function artifactExposes(\n  artifacts: readonly GeneratedArtifact[],\n  toExposePath: (artifactPath: string) => string,\n): Record<string, string> {\n  const exposes: Record<string, string> = {}\n  for (const artifact of artifacts) {\n    if (artifact.expose) {\n      exposes[artifact.expose] = toExposePath(artifact.path)\n    }\n  }\n  return exposes\n}\n\n/**\n * Expand a workbench app's declared views and services into the flat artifact\n * set the federation build writes and exposes — the single place that composes\n * the per-type expanders, so the expose mapping and the file writing read from\n * one expansion rather than re-deriving it.\n */\nexport function workbenchArtifacts(options: {\n  services?: readonly ServiceArtifact[]\n  views: readonly InterfaceArtifact[]\n}): GeneratedArtifact[] {\n  return [...viewArtifacts(options.views), ...serviceArtifacts(options.services ?? [])]\n}\n"],"names":["serviceArtifacts","viewArtifacts","artifactExposes","artifacts","toExposePath","exposes","artifact","expose","path","workbenchArtifacts","options","views","services"],"mappings":"AAAA,SAA8BA,gBAAgB,QAAO,yBAAwB;AAC7E,SAAgCC,aAAa,QAAO,sBAAqB;AAoCzE;;;;;CAKC,GACD,OAAO,SAASC,gBACdC,SAAuC,EACvCC,YAA8C;IAE9C,MAAMC,UAAkC,CAAC;IACzC,KAAK,MAAMC,YAAYH,UAAW;QAChC,IAAIG,SAASC,MAAM,EAAE;YACnBF,OAAO,CAACC,SAASC,MAAM,CAAC,GAAGH,aAAaE,SAASE,IAAI;QACvD;IACF;IACA,OAAOH;AACT;AAEA;;;;;CAKC,GACD,OAAO,SAASI,mBAAmBC,OAGlC;IACC,OAAO;WAAIT,cAAcS,QAAQC,KAAK;WAAMX,iBAAiBU,QAAQE,QAAQ,IAAI,EAAE;KAAE;AACvF"}

package/dist/actions/build/render-remote.js

@@ -0,0 +1,69 @@
+/**
+ * Every entry the federation build generates — the studio/app remote entries
+ * and the per-view-component artifacts — is the same thing: a *render-contract
+ * module* that owns its own React, renders into a host node via
+ * `render(rootElement, props, renderOptions)`, and returns a disposer.
+ *
+ * They differ only in *what* they render. So each module binds an `App` to that
+ * (the SDK app, a `Studio` with config, a view component) and the render body —
+ * identical everywhere — just renders `App`. {@link renderRemote} assembles a
+ * module from a `preamble` (its imports), the `app` expression, and, optionally,
+ * the shared HMR snippet.
+ */ /**
+ * Hot-reload: on an update, re-render every live root through the new module —
+ * so whatever it now binds `App` to (a recompiled component, a new studio
+ * config) takes effect without a full page reload. Stripped from prod builds.
+ */ const HMR_REMOUNT = `if (import.meta.hot) {
+  import.meta.hot.accept((next) => {
+    if (!next) return
+    for (const [rootElement, args] of renderArgs) {
+      rootMap.get(rootElement)?.unmount()
+      rootMap.delete(rootElement)
+      next.render(rootElement, args.props, args.renderOptions)
+    }
+  })
+}`;
+/**
+ * Assemble a render-contract module: its `preamble` (imports), the `App` it
+ * renders, the render body, and — when `hmr` — the shared HMR snippet.
+ *
+ * - `app` is the expression bound to `App`; omit it when the preamble imports an
+ *   `App` directly (the SDK-app entry).
+ * - `version` is an expression the host reads to check contract compatibility;
+ *   omit it when the module carries no version (the studio/app entries).
+ */ export function renderRemote({ app, hmr = false, preamble, version }) {
+    return `\
+// This file is auto-generated on 'sanity build' / 'sanity dev'
+// Modifications to this file are automatically discarded
+import { createElement, StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+${preamble}
+${app ? `\nconst App = ${app}\n` : ''}${version ? `\nexport const version = ${version}\n` : ''}
+const rootMap = new Map()
+const renderArgs = new Map()
+
+function mount(rootElement, args) {
+  let root = rootMap.get(rootElement)
+  if (!root) {
+    root = createRoot(rootElement)
+    rootMap.set(rootElement, root)
+  }
+  const element = createElement(App, args.props)
+  root.render(args?.renderOptions?.reactStrictMode ? createElement(StrictMode, null, element) : element)
+}
+
+export function render(rootElement, props, renderOptions) {
+  const args = { props, renderOptions }
+  renderArgs.set(rootElement, args)
+  mount(rootElement, args)
+  return () => {
+    const root = rootMap.get(rootElement)
+    rootMap.delete(rootElement)
+    renderArgs.delete(rootElement)
+    root?.unmount()
+  }
+}${hmr ? `\n\n${HMR_REMOUNT}` : ''}
+`;
+}
+
+//# sourceMappingURL=render-remote.js.map

package/dist/actions/build/render-remote.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/build/render-remote.ts"],"sourcesContent":["/**\n * Every entry the federation build generates — the studio/app remote entries\n * and the per-view-component artifacts — is the same thing: a *render-contract\n * module* that owns its own React, renders into a host node via\n * `render(rootElement, props, renderOptions)`, and returns a disposer.\n *\n * They differ only in *what* they render. So each module binds an `App` to that\n * (the SDK app, a `Studio` with config, a view component) and the render body —\n * identical everywhere — just renders `App`. {@link renderRemote} assembles a\n * module from a `preamble` (its imports), the `app` expression, and, optionally,\n * the shared HMR snippet.\n */\n\n/**\n * Hot-reload: on an update, re-render every live root through the new module —\n * so whatever it now binds `App` to (a recompiled component, a new studio\n * config) takes effect without a full page reload. Stripped from prod builds.\n */\nconst HMR_REMOUNT = `if (import.meta.hot) {\n  import.meta.hot.accept((next) => {\n    if (!next) return\n    for (const [rootElement, args] of renderArgs) {\n      rootMap.get(rootElement)?.unmount()\n      rootMap.delete(rootElement)\n      next.render(rootElement, args.props, args.renderOptions)\n    }\n  })\n}`\n\n/**\n * Assemble a render-contract module: its `preamble` (imports), the `App` it\n * renders, the render body, and — when `hmr` — the shared HMR snippet.\n *\n * - `app` is the expression bound to `App`; omit it when the preamble imports an\n *   `App` directly (the SDK-app entry).\n * - `version` is an expression the host reads to check contract compatibility;\n *   omit it when the module carries no version (the studio/app entries).\n */\nexport function renderRemote({\n  app,\n  hmr = false,\n  preamble,\n  version,\n}: {\n  app?: string\n  hmr?: boolean\n  preamble: string\n  version?: string\n}): string {\n  return `\\\n// This file is auto-generated on 'sanity build' / 'sanity dev'\n// Modifications to this file are automatically discarded\nimport { createElement, StrictMode } from 'react'\nimport { createRoot } from 'react-dom/client'\n${preamble}\n${app ? `\\nconst App = ${app}\\n` : ''}${version ? `\\nexport const version = ${version}\\n` : ''}\nconst rootMap = new Map()\nconst renderArgs = new Map()\n\nfunction mount(rootElement, args) {\n  let root = rootMap.get(rootElement)\n  if (!root) {\n    root = createRoot(rootElement)\n    rootMap.set(rootElement, root)\n  }\n  const element = createElement(App, args.props)\n  root.render(args?.renderOptions?.reactStrictMode ? createElement(StrictMode, null, element) : element)\n}\n\nexport function render(rootElement, props, renderOptions) {\n  const args = { props, renderOptions }\n  renderArgs.set(rootElement, args)\n  mount(rootElement, args)\n  return () => {\n    const root = rootMap.get(rootElement)\n    rootMap.delete(rootElement)\n    renderArgs.delete(rootElement)\n    root?.unmount()\n  }\n}${hmr ? `\\n\\n${HMR_REMOUNT}` : ''}\n`\n}\n"],"names":["HMR_REMOUNT","renderRemote","app","hmr","preamble","version"],"mappings":"AAAA;;;;;;;;;;;CAWC,GAED;;;;CAIC,GACD,MAAMA,cAAc,CAAC;;;;;;;;;CASpB,CAAC;AAEF;;;;;;;;CAQC,GACD,OAAO,SAASC,aAAa,EAC3BC,GAAG,EACHC,MAAM,KAAK,EACXC,QAAQ,EACRC,OAAO,EAMR;IACC,OAAO,CAAC;;;;;AAKV,EAAED,SAAS;AACX,EAAEF,MAAM,CAAC,cAAc,EAAEA,IAAI,EAAE,CAAC,GAAG,KAAKG,UAAU,CAAC,yBAAyB,EAAEA,QAAQ,EAAE,CAAC,GAAG,GAAG;;;;;;;;;;;;;;;;;;;;;;;;CAwB9F,EAAEF,MAAM,CAAC,IAAI,EAAEH,aAAa,GAAG,GAAG;AACnC,CAAC;AACD"}

package/dist/actions/build/services/artifact.js

@@ -0,0 +1,122 @@
+import { SERVICE_CONTRACT_VERSION } from '../../../contract.js';
+/** Subdirectory under the federation runtime dir where service artifacts live. */ const SERVICES_DIR_NAME = 'services';
+const SERVICE_TYPES = [
+    'worker'
+];
+/**
+ * Expand each service into its two generated artifacts: a self-contained worker
+ * bundle (imports the user's `src`, runs the callback) and a loader module the
+ * host loads to read the worker's URL. Only the loader is a federation expose —
+ * the host reaches the worker bundle through it, never directly.
+ */ export function serviceArtifacts(services) {
+    return services.filter((service)=>SERVICE_TYPES.includes(service.type)).flatMap((service)=>{
+        const dir = `${SERVICES_DIR_NAME}/${service.name}`;
+        return [
+            {
+                path: `${dir}/worker.js`,
+                source: ({ resolveImport })=>serviceWorkerArtifactSource({
+                        importPath: resolveImport(service.src),
+                        service
+                    })
+            },
+            {
+                expose: `./${dir}`,
+                path: `${dir}/index.js`,
+                source: ()=>serviceLoaderArtifactSource({
+                        service
+                    })
+            }
+        ];
+    });
+}
+/**
+ * Source for one service's **worker** bundle — the Web Worker entry. Imports
+ * the user's `unstable_defineService` result and runs its callback with the
+ * service's own declaration (mirroring how a view component receives its
+ * `view`), then wires the returned disposer to the host's terminate message.
+ * Crashes — and the worker's `console.*`, which is patched to forward to the
+ * host — are surfaced through the host logger (the host owns logging; a worker's
+ * own console isn't visible in the page DevTools anyway).
+ */ function serviceWorkerArtifactSource(input) {
+    return `\
+// This file is auto-generated on 'sanity build' / 'sanity dev'
+// Modifications to this file are automatically discarded
+import service from ${JSON.stringify(input.importPath)}
+
+const SERVICE = { type: ${JSON.stringify(input.service.type)}, name: ${JSON.stringify(input.service.name)} }
+
+// Bridge the worker's console to the host. A worker's own console isn't visible
+// in the page DevTools, so patch console.* to forward each call as a message
+// the host re-emits through the workbench logger — any console.log in the
+// service (or its deps) just shows up in the page console.
+const __format = (arg) => {
+  if (typeof arg === 'string') return arg
+  try { return JSON.stringify(arg) } catch (_) { return String(arg) }
+}
+for (const __level of ['log', 'info', 'warn', 'error', 'debug']) {
+  const __native = typeof console[__level] === 'function' ? console[__level].bind(console) : () => {}
+  console[__level] = (...args) => {
+    __native(...args)
+    try {
+      self.postMessage({ kind: 'workbench.worker.log', payload: { level: __level, message: args.map(__format).join(' ') } })
+    } catch (_) {}
+  }
+}
+
+let dispose
+try {
+  const result = service.run({ service: SERVICE })
+  if (typeof result === 'function') dispose = result
+} catch (error) {
+  self.postMessage({ kind: 'workbench.worker.error', payload: { message: String(error) } })
+}
+
+self.addEventListener('message', (event) => {
+  if (event.data && event.data.kind === 'workbench.worker.terminate') {
+    try { dispose && dispose() } finally { self.close() }
+  }
+})
+
+self.addEventListener('error', (event) => {
+  self.postMessage({ kind: 'workbench.worker.error', payload: { message: String(event.message || event) } })
+})
+
+// An async run callback (or async work it kicks off) rejects without hitting
+// the synchronous try/catch above; module workers surface that as
+// 'unhandledrejection' on self, not 'error'. Forward it so the crash reaches
+// the host either way.
+self.addEventListener('unhandledrejection', (event) => {
+  self.postMessage({ kind: 'workbench.worker.error', payload: { message: String(event.reason) } })
+})
+`;
+}
+/**
+ * Source for one service's **loader** — the module-federation expose. Hands the
+ * host the worker bundle's URL (via Vite `?worker&url`) plus the service's
+ * type/version.
+ *
+ * A URL (not an inlined worker) on purpose: the host can't `new Worker()` it
+ * directly — cross-origin in dev/prod, and `?worker&inline` only self-contains
+ * the worker in a build, not under `sanity dev`. Instead the host bootstraps a
+ * same-origin worker that dynamically `import()`s this URL, so the worker
+ * resolves its own imports against the app origin. Works in dev and build alike.
+ *
+ * No HMR boundary: a worker lives in its own `?worker&url` module graph with no
+ * accepting importer, so Vite full-reloads the page on a `src` edit (which
+ * re-loads the worker with the new code) — in-place worker HMR isn't possible.
+ */ function serviceLoaderArtifactSource(input) {
+    return `\
+// This file is auto-generated on 'sanity build' / 'sanity dev'
+// Modifications to this file are automatically discarded
+import workerUrl from './worker.js?worker&url'
+
+/** URL of the worker bundle, on the app's origin. */
+export const url = workerUrl
+/** Service type and contract version, surfaced for the host to dispatch on. */
+export const type = ${JSON.stringify(input.service.type)}
+export const name = ${JSON.stringify(input.service.name)}
+export const version = ${SERVICE_CONTRACT_VERSION}
+`;
+}
+
+//# sourceMappingURL=artifact.js.map

package/dist/actions/build/services/artifact.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/build/services/artifact.ts"],"sourcesContent":["import {SERVICE_CONTRACT_VERSION, type ServiceType} from '../../../contract.js'\nimport {type GeneratedArtifact} from '../artifact.js'\n\n/** Subdirectory under the federation runtime dir where service artifacts live. */\nconst SERVICES_DIR_NAME = 'services'\n\nconst SERVICE_TYPES: readonly ServiceType[] = ['worker']\n\n/**\n * A service to generate a worker artifact for. The `src` file default-exports\n * an `unstable_defineService(...)` result; the build emits a self-contained Web\n * Worker bundle plus a loader module that hands the host its URL.\n * @internal\n */\nexport interface ServiceArtifact {\n  /** Service name, unique within the app. */\n  name: string\n  /** Path to the service `src` file, relative to the app root (or absolute). */\n  src: string\n  /** Service type, e.g. `\"worker\"`. */\n  type: string\n}\n\n/**\n * Expand each service into its two generated artifacts: a self-contained worker\n * bundle (imports the user's `src`, runs the callback) and a loader module the\n * host loads to read the worker's URL. Only the loader is a federation expose —\n * the host reaches the worker bundle through it, never directly.\n */\nexport function serviceArtifacts(services: readonly ServiceArtifact[]): GeneratedArtifact[] {\n  return services\n    .filter((service) => (SERVICE_TYPES as readonly string[]).includes(service.type))\n    .flatMap((service): GeneratedArtifact[] => {\n      const dir = `${SERVICES_DIR_NAME}/${service.name}`\n      return [\n        {\n          path: `${dir}/worker.js`,\n          source: ({resolveImport}) =>\n            serviceWorkerArtifactSource({\n              importPath: resolveImport(service.src),\n              service,\n            }),\n        },\n        {\n          expose: `./${dir}`,\n          path: `${dir}/index.js`,\n          source: () => serviceLoaderArtifactSource({service}),\n        },\n      ]\n    })\n}\n\n/**\n * Source for one service's **worker** bundle — the Web Worker entry. Imports\n * the user's `unstable_defineService` result and runs its callback with the\n * service's own declaration (mirroring how a view component receives its\n * `view`), then wires the returned disposer to the host's terminate message.\n * Crashes — and the worker's `console.*`, which is patched to forward to the\n * host — are surfaced through the host logger (the host owns logging; a worker's\n * own console isn't visible in the page DevTools anyway).\n */\nfunction serviceWorkerArtifactSource(input: {\n  importPath: string\n  service: {name: string; type: string}\n}): string {\n  return `\\\n// This file is auto-generated on 'sanity build' / 'sanity dev'\n// Modifications to this file are automatically discarded\nimport service from ${JSON.stringify(input.importPath)}\n\nconst SERVICE = { type: ${JSON.stringify(input.service.type)}, name: ${JSON.stringify(input.service.name)} }\n\n// Bridge the worker's console to the host. A worker's own console isn't visible\n// in the page DevTools, so patch console.* to forward each call as a message\n// the host re-emits through the workbench logger — any console.log in the\n// service (or its deps) just shows up in the page console.\nconst __format = (arg) => {\n  if (typeof arg === 'string') return arg\n  try { return JSON.stringify(arg) } catch (_) { return String(arg) }\n}\nfor (const __level of ['log', 'info', 'warn', 'error', 'debug']) {\n  const __native = typeof console[__level] === 'function' ? console[__level].bind(console) : () => {}\n  console[__level] = (...args) => {\n    __native(...args)\n    try {\n      self.postMessage({ kind: 'workbench.worker.log', payload: { level: __level, message: args.map(__format).join(' ') } })\n    } catch (_) {}\n  }\n}\n\nlet dispose\ntry {\n  const result = service.run({ service: SERVICE })\n  if (typeof result === 'function') dispose = result\n} catch (error) {\n  self.postMessage({ kind: 'workbench.worker.error', payload: { message: String(error) } })\n}\n\nself.addEventListener('message', (event) => {\n  if (event.data && event.data.kind === 'workbench.worker.terminate') {\n    try { dispose && dispose() } finally { self.close() }\n  }\n})\n\nself.addEventListener('error', (event) => {\n  self.postMessage({ kind: 'workbench.worker.error', payload: { message: String(event.message || event) } })\n})\n\n// An async run callback (or async work it kicks off) rejects without hitting\n// the synchronous try/catch above; module workers surface that as\n// 'unhandledrejection' on self, not 'error'. Forward it so the crash reaches\n// the host either way.\nself.addEventListener('unhandledrejection', (event) => {\n  self.postMessage({ kind: 'workbench.worker.error', payload: { message: String(event.reason) } })\n})\n`\n}\n\n/**\n * Source for one service's **loader** — the module-federation expose. Hands the\n * host the worker bundle's URL (via Vite `?worker&url`) plus the service's\n * type/version.\n *\n * A URL (not an inlined worker) on purpose: the host can't `new Worker()` it\n * directly — cross-origin in dev/prod, and `?worker&inline` only self-contains\n * the worker in a build, not under `sanity dev`. Instead the host bootstraps a\n * same-origin worker that dynamically `import()`s this URL, so the worker\n * resolves its own imports against the app origin. Works in dev and build alike.\n *\n * No HMR boundary: a worker lives in its own `?worker&url` module graph with no\n * accepting importer, so Vite full-reloads the page on a `src` edit (which\n * re-loads the worker with the new code) — in-place worker HMR isn't possible.\n */\nfunction serviceLoaderArtifactSource(input: {service: {name: string; type: string}}): string {\n  return `\\\n// This file is auto-generated on 'sanity build' / 'sanity dev'\n// Modifications to this file are automatically discarded\nimport workerUrl from './worker.js?worker&url'\n\n/** URL of the worker bundle, on the app's origin. */\nexport const url = workerUrl\n/** Service type and contract version, surfaced for the host to dispatch on. */\nexport const type = ${JSON.stringify(input.service.type)}\nexport const name = ${JSON.stringify(input.service.name)}\nexport const version = ${SERVICE_CONTRACT_VERSION}\n`\n}\n"],"names":["SERVICE_CONTRACT_VERSION","SERVICES_DIR_NAME","SERVICE_TYPES","serviceArtifacts","services","filter","service","includes","type","flatMap","dir","name","path","source","resolveImport","serviceWorkerArtifactSource","importPath","src","expose","serviceLoaderArtifactSource","input","JSON","stringify"],"mappings":"AAAA,SAAQA,wBAAwB,QAAyB,uBAAsB;AAG/E,gFAAgF,GAChF,MAAMC,oBAAoB;AAE1B,MAAMC,gBAAwC;IAAC;CAAS;AAiBxD;;;;;CAKC,GACD,OAAO,SAASC,iBAAiBC,QAAoC;IACnE,OAAOA,SACJC,MAAM,CAAC,CAACC,UAAY,AAACJ,cAAoCK,QAAQ,CAACD,QAAQE,IAAI,GAC9EC,OAAO,CAAC,CAACH;QACR,MAAMI,MAAM,GAAGT,kBAAkB,CAAC,EAAEK,QAAQK,IAAI,EAAE;QAClD,OAAO;YACL;gBACEC,MAAM,GAAGF,IAAI,UAAU,CAAC;gBACxBG,QAAQ,CAAC,EAACC,aAAa,EAAC,GACtBC,4BAA4B;wBAC1BC,YAAYF,cAAcR,QAAQW,GAAG;wBACrCX;oBACF;YACJ;YACA;gBACEY,QAAQ,CAAC,EAAE,EAAER,KAAK;gBAClBE,MAAM,GAAGF,IAAI,SAAS,CAAC;gBACvBG,QAAQ,IAAMM,4BAA4B;wBAACb;oBAAO;YACpD;SACD;IACH;AACJ;AAEA;;;;;;;;CAQC,GACD,SAASS,4BAA4BK,KAGpC;IACC,OAAO,CAAC;;;oBAGU,EAAEC,KAAKC,SAAS,CAACF,MAAMJ,UAAU,EAAE;;wBAE/B,EAAEK,KAAKC,SAAS,CAACF,MAAMd,OAAO,CAACE,IAAI,EAAE,QAAQ,EAAEa,KAAKC,SAAS,CAACF,MAAMd,OAAO,CAACK,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6C1G,CAAC;AACD;AAEA;;;;;;;;;;;;;;CAcC,GACD,SAASQ,4BAA4BC,KAA8C;IACjF,OAAO,CAAC;;;;;;;;oBAQU,EAAEC,KAAKC,SAAS,CAACF,MAAMd,OAAO,CAACE,IAAI,EAAE;oBACrC,EAAEa,KAAKC,SAAS,CAACF,MAAMd,OAAO,CAACK,IAAI,EAAE;uBAClC,EAAEX,yBAAyB;AAClD,CAAC;AACD"}

package/dist/actions/build/views/artifact.js

@@ -0,0 +1,31 @@
+import { VIEW_COMPONENTS } from '../../../contract.js';
+import { renderRemote } from '../render-remote.js';
+/** Subdirectory under the federation runtime dir where view artifacts are written. */ const VIEWS_DIR_NAME = 'views';
+/**
+ * Expand each view into one generated artifact per component it exposes. A
+ * panel's `title` and `panel` each become their own render-contract module and
+ * module-federation expose, so the host renders each as an independent island.
+ *
+ * Each artifact binds its component as the `App` the render contract renders —
+ * a single-component view exports a bare function, a multi-component one keys by
+ * name — behind an HMR boundary so view edits re-render through the new module.
+ */ export function viewArtifacts(views) {
+    const artifacts = [];
+    for (const view of views){
+        for (const component of VIEW_COMPONENTS[view.type]){
+            artifacts.push({
+                expose: `./${VIEWS_DIR_NAME}/${view.name}/${component}`,
+                path: `${VIEWS_DIR_NAME}/${view.name}/${component}.js`,
+                source: ({ resolveImport })=>renderRemote({
+                        app: `typeof view.components === 'function' ? view.components : view.components[${JSON.stringify(component)}]`,
+                        hmr: true,
+                        preamble: `import view from ${JSON.stringify(resolveImport(view.src))}`,
+                        version: `view.version`
+                    })
+            });
+        }
+    }
+    return artifacts;
+}
+
+//# sourceMappingURL=artifact.js.map

package/dist/actions/build/views/artifact.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/build/views/artifact.ts"],"sourcesContent":["import {type InterfaceType, VIEW_COMPONENTS} from '../../../contract.js'\nimport {type GeneratedArtifact} from '../artifact.js'\nimport {renderRemote} from '../render-remote.js'\n\n/** Subdirectory under the federation runtime dir where view artifacts are written. */\nconst VIEWS_DIR_NAME = 'views'\n\n/**\n * An interface to generate render artifacts for. The `src` file default-exports\n * an `unstable_defineView(...)` result; the build emits one render-contract\n * artifact per component the interface type exposes.\n * @internal\n */\nexport interface InterfaceArtifact {\n  /** Interface name, unique within the app. */\n  name: string\n  /** Path to the interface `src` file, relative to the app root (or absolute). */\n  src: string\n  /** Interface type — selects which components the build expands. */\n  type: InterfaceType\n}\n\n/**\n * Expand each view into one generated artifact per component it exposes. A\n * panel's `title` and `panel` each become their own render-contract module and\n * module-federation expose, so the host renders each as an independent island.\n *\n * Each artifact binds its component as the `App` the render contract renders —\n * a single-component view exports a bare function, a multi-component one keys by\n * name — behind an HMR boundary so view edits re-render through the new module.\n */\nexport function viewArtifacts(views: readonly InterfaceArtifact[]): GeneratedArtifact[] {\n  const artifacts: GeneratedArtifact[] = []\n  for (const view of views) {\n    for (const component of VIEW_COMPONENTS[view.type]) {\n      artifacts.push({\n        expose: `./${VIEWS_DIR_NAME}/${view.name}/${component}`,\n        path: `${VIEWS_DIR_NAME}/${view.name}/${component}.js`,\n        source: ({resolveImport}) =>\n          renderRemote({\n            app: `typeof view.components === 'function' ? view.components : view.components[${JSON.stringify(component)}]`,\n            hmr: true,\n            preamble: `import view from ${JSON.stringify(resolveImport(view.src))}`,\n            version: `view.version`,\n          }),\n      })\n    }\n  }\n  return artifacts\n}\n"],"names":["VIEW_COMPONENTS","renderRemote","VIEWS_DIR_NAME","viewArtifacts","views","artifacts","view","component","type","push","expose","name","path","source","resolveImport","app","JSON","stringify","hmr","preamble","src","version"],"mappings":"AAAA,SAA4BA,eAAe,QAAO,uBAAsB;AAExE,SAAQC,YAAY,QAAO,sBAAqB;AAEhD,oFAAoF,GACpF,MAAMC,iBAAiB;AAiBvB;;;;;;;;CAQC,GACD,OAAO,SAASC,cAAcC,KAAmC;IAC/D,MAAMC,YAAiC,EAAE;IACzC,KAAK,MAAMC,QAAQF,MAAO;QACxB,KAAK,MAAMG,aAAaP,eAAe,CAACM,KAAKE,IAAI,CAAC,CAAE;YAClDH,UAAUI,IAAI,CAAC;gBACbC,QAAQ,CAAC,EAAE,EAAER,eAAe,CAAC,EAAEI,KAAKK,IAAI,CAAC,CAAC,EAAEJ,WAAW;gBACvDK,MAAM,GAAGV,eAAe,CAAC,EAAEI,KAAKK,IAAI,CAAC,CAAC,EAAEJ,UAAU,GAAG,CAAC;gBACtDM,QAAQ,CAAC,EAACC,aAAa,EAAC,GACtBb,aAAa;wBACXc,KAAK,CAAC,0EAA0E,EAAEC,KAAKC,SAAS,CAACV,WAAW,CAAC,CAAC;wBAC9GW,KAAK;wBACLC,UAAU,CAAC,iBAAiB,EAAEH,KAAKC,SAAS,CAACH,cAAcR,KAAKc,GAAG,IAAI;wBACvEC,SAAS,CAAC,YAAY,CAAC;oBACzB;YACJ;QACF;IACF;IACA,OAAOhB;AACT"}

package/dist/actions/build/vite/constants.js

@@ -0,0 +1,5 @@
+export const FEDERATION_FILE_NAME = 'remote-entry';
+export const FEDERATION_DIR_NAME = 'federation';
+export const RUNTIME_DIR = `.sanity/${FEDERATION_DIR_NAME}`;
+
+//# sourceMappingURL=constants.js.map