@sanity/workbench-cli 1.4.0 → 1.6.0

package/dist/_exports/build.d.ts

@@ -1,3 +1,4 @@
+import { AppVisibility } from "@sanity/cli-core";
 import { CliConfig } from "@sanity/cli-core";
 import { PluginOption } from "vite";
 import { z } from "zod/mini";
@@ -86,7 +87,7 @@ declare const DefineAppInputSchema: z.ZodMiniObject<
         >
       >
     >;
-    slug: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    slug: z.ZodMiniString<string>;
     title: z.ZodMiniString<string>;
     views: z.ZodMiniOptional<
       z.ZodMiniArray<
@@ -106,6 +107,13 @@ declare const DefineAppInputSchema: z.ZodMiniObject<
         >
       >
     >;
+    visibility: z.ZodMiniOptional<
+      z.ZodMiniEnum<{
+        default: "default";
+        unlisted: "unlisted";
+        disabled: "disabled";
+      }>
+    >;
   },
   z.core.$strip
 >;
@@ -133,10 +141,14 @@ declare interface ResolvedWorkbenchApp {
   readonly config?: WorkbenchApp["config"];
   /** SDK app-view entrypoint, when declared. */
   readonly entry?: string;
+  /** Path to the app's icon SVG, resolved and shipped to Brett on deploy. */
+  readonly icon?: string;
   /** Explicit singleton flag (a Sanity-owned app); `undefined` when the app doesn't set it. */
   readonly isSingleton?: boolean;
   /** Hostname the application is created at on first deploy. */
   readonly slug?: string;
+  /** Dashboard visibility declared by the app; `undefined` when unset. */
+  readonly visibility?: AppVisibility;
 }
 
 /**
@@ -175,6 +187,39 @@ export declare interface WorkbenchExposes {
   views?: DefineAppInput["views"];
 }
 
+/**
+ * Dep pre-bundling inputs for a workbench app's dev server.
+ *
+ * Vite's dep scanner crawls from the app's HTML entry, which reaches only the
+ * app's `entry` (or a studio's config) — never the federation `exposes` (dock
+ * views, worker services, media-library config fields), which the host loads
+ * dynamically at runtime. So a dep imported only by an exposed module (e.g.
+ * `sanity/workbench` in a service or view) escapes the startup scan; Vite
+ * discovers it on first request, re-optimizes, and full-page reloads — which
+ * flakes Playwright in e2e.
+ *
+ * Point `entries` at the source of every interface: the app `entry` (or, for a
+ * studio, its config), plus each view, service, and installation-config source.
+ * `entries` follows real import statements, so it covers whatever those sources
+ * transitively use — correct subpaths and all — with no hand-maintained dep
+ * list, and never crashes on an unresolvable name the way a bad `include` entry
+ * does. Each source is resolved to its on-disk file so an extensionless path
+ * (like the default `./src/App`) still matches `entries`' filesystem glob.
+ *
+ * @param cwd - Project root; `entries` are returned relative to it.
+ * @param appSources - Absolute paths to the app's `entry` and/or studio config.
+ * @param exposes - The app's declared views/services/config.
+ * @internal
+ */
+export declare function workbenchOptimizeDeps(options: {
+  appSources: readonly string[];
+  cwd: string;
+  exposes?: WorkbenchExposes;
+}): {
+  entries: string[];
+  include: string[];
+};
+
 declare interface WorkbenchViteOptions {
   /** Project root — read for the federation remote name, and the plugin workDir. */
   cwd: string;

package/dist/_exports/build.js

@@ -3,6 +3,7 @@
 // resolver the build reads declared views/services from. The build needs no
 // deploy-time guards, so it takes the bare `resolveWorkbenchApp` — the guarded
 // view (`getWorkbench`) is the deploy entry's export.
+export { workbenchOptimizeDeps } from '../actions/build/vite/optimize-deps.js';
 export { workbenchVitePlugins } from '../actions/build/vite/workbench-vite-plugins.js';
 export { resolveWorkbenchApp } from '../resolveWorkbenchApp.js';
 

package/dist/_exports/build.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/_exports/build.ts"],"sourcesContent":["// Node-only build entry: the module-federation Vite plugins that\n// `@sanity/cli-build`'s `getViteConfig` swaps in for a workbench app, plus the\n// resolver the build reads declared views/services from. The build needs no\n// deploy-time guards, so it takes the bare `resolveWorkbenchApp` — the guarded\n// view (`getWorkbench`) is the deploy entry's export.\n\nexport {workbenchVitePlugins} from '../actions/build/vite/workbench-vite-plugins.js'\nexport {resolveWorkbenchApp, type WorkbenchExposes} from '../resolveWorkbenchApp.js'\n"],"names":["workbenchVitePlugins","resolveWorkbenchApp"],"mappings":"AAAA,iEAAiE;AACjE,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAC/E,sDAAsD;AAEtD,SAAQA,oBAAoB,QAAO,kDAAiD;AACpF,SAAQC,mBAAmB,QAA8B,4BAA2B"}
+{"version":3,"sources":["../../src/_exports/build.ts"],"sourcesContent":["// Node-only build entry: the module-federation Vite plugins that\n// `@sanity/cli-build`'s `getViteConfig` swaps in for a workbench app, plus the\n// resolver the build reads declared views/services from. The build needs no\n// deploy-time guards, so it takes the bare `resolveWorkbenchApp` — the guarded\n// view (`getWorkbench`) is the deploy entry's export.\n\nexport {workbenchOptimizeDeps} from '../actions/build/vite/optimize-deps.js'\nexport {workbenchVitePlugins} from '../actions/build/vite/workbench-vite-plugins.js'\nexport {resolveWorkbenchApp, type WorkbenchExposes} from '../resolveWorkbenchApp.js'\n"],"names":["workbenchOptimizeDeps","workbenchVitePlugins","resolveWorkbenchApp"],"mappings":"AAAA,iEAAiE;AACjE,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAC/E,sDAAsD;AAEtD,SAAQA,qBAAqB,QAAO,yCAAwC;AAC5E,SAAQC,oBAAoB,QAAO,kDAAiD;AACpF,SAAQC,mBAAmB,QAA8B,4BAA2B"}

package/dist/_exports/deploy.d.ts

@@ -1,7 +1,24 @@
+import { AppVisibility } from "@sanity/cli-core";
 import { CliConfig } from "@sanity/cli-core";
 import { Output } from "@sanity/cli-core";
 import { z } from "zod/mini";
 
+/** @internal */
+declare type AppInterfaceMetadata = z.infer<typeof AppInterfaceMetadataSchema>;
+
+/**
+ * The `app` interface's dock-placement metadata. Interface metadata is
+ * discriminated on `type`; `app` is the only type with a shape so far.
+ * @internal
+ */
+declare const AppInterfaceMetadataSchema: z.ZodMiniObject<
+  {
+    group: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    priority: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+  },
+  z.core.$strip
+>;
+
 export declare interface Application {
   id: string;
   organizationId: string;
@@ -13,16 +30,28 @@ export declare interface Application {
 declare type ApplicationType = "coreApp" | "studio";
 
 /**
- * An interface as Brett stores it: the declared `type` (validated server-side,
- * not here) and the remote-relative `moduleId` the workbench loads it by — the
- * host prepends the app's own id.
+ * An interface as Brett stores it, discriminated on `type`. `moduleId` is
+ * remote-relative — the host prepends the app's id. Brett assigns the id.
  * @internal
  */
-export declare interface BrettInterface {
+export declare type BrettInterface =
+  | (BrettInterfaceBase & {
+      metadata: AppInterfaceMetadata | null;
+      type: "app";
+    })
+  | (BrettInterfaceBase & {
+      metadata: null;
+      type: "panel";
+    })
+  | (BrettInterfaceBase & {
+      metadata: null;
+      type: "worker";
+    });
+
+declare interface BrettInterfaceBase {
   moduleId: string;
   name: string;
   title: string;
-  type: string;
   version: string;
 }
 
@@ -148,7 +177,7 @@ declare const DefineAppInputSchema: z.ZodMiniObject<
         >
       >
     >;
-    slug: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    slug: z.ZodMiniString<string>;
     title: z.ZodMiniString<string>;
     views: z.ZodMiniOptional<
       z.ZodMiniArray<
@@ -168,6 +197,13 @@ declare const DefineAppInputSchema: z.ZodMiniObject<
         >
       >
     >;
+    visibility: z.ZodMiniOptional<
+      z.ZodMiniEnum<{
+        default: "default";
+        unlisted: "unlisted";
+        disabled: "disabled";
+      }>
+    >;
   },
   z.core.$strip
 >;
@@ -225,6 +261,7 @@ export declare function deployConfig(options: {
  */
 export declare function deployCoreApp(options: {
   appId: string | undefined;
+  icon?: string;
   interfaces: readonly BrettInterface[];
   isAutoUpdating: boolean;
   isSingleton?: boolean;
@@ -233,6 +270,7 @@ export declare function deployCoreApp(options: {
   sourceDir: string;
   title: string;
   version: string;
+  visibility?: AppVisibility;
 }): Promise<{
   applicationId: string;
 }>;
@@ -253,6 +291,7 @@ export declare interface DeployedExpose {
  */
 export declare function deployStudio(options: {
   appId: string | undefined;
+  icon?: string;
   interfaces: readonly BrettInterface[];
   isAutoUpdating: boolean;
   organizationId: string;
@@ -296,10 +335,14 @@ declare interface ResolvedWorkbenchApp {
   readonly config?: WorkbenchApp["config"];
   /** SDK app-view entrypoint, when declared. */
   readonly entry?: string;
+  /** Path to the app's icon SVG, resolved and shipped to Brett on deploy. */
+  readonly icon?: string;
   /** Explicit singleton flag (a Sanity-owned app); `undefined` when the app doesn't set it. */
   readonly isSingleton?: boolean;
   /** Hostname the application is created at on first deploy. */
   readonly slug?: string;
+  /** Dashboard visibility declared by the app; `undefined` when unset. */
+  readonly visibility?: AppVisibility;
 }
 
 /**

package/dist/_exports/dev.d.ts

@@ -58,15 +58,57 @@ declare const devServerManifestSchema: z.ZodMiniObject<
     id: z.ZodMiniOptional<z.ZodMiniString<string>>;
     interfaces: z.ZodMiniOptional<
       z.ZodMiniArray<
-        z.ZodMiniObject<
-          {
-            name: z.ZodMiniString<string>;
-            src: z.ZodMiniString<string>;
-            title: z.ZodMiniString<string>;
-            type: z.ZodMiniString<string>;
-            version: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-          },
-          z.core.$strip
+        z.ZodMiniDiscriminatedUnion<
+          [
+            z.ZodMiniObject<
+              {
+                metadata: z.ZodMiniNullable<
+                  z.ZodMiniObject<
+                    {
+                      group: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                      priority: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                    },
+                    z.core.$strip
+                  >
+                >;
+                type: z.ZodMiniLiteral<"app">;
+                id: z.ZodMiniString<string>;
+                moduleId: z.ZodMiniString<string>;
+                name: z.ZodMiniString<string>;
+                src: z.ZodMiniString<string>;
+                title: z.ZodMiniString<string>;
+                version: z.ZodMiniOptional<z.ZodMiniString<string>>;
+              },
+              z.core.$strip
+            >,
+            z.ZodMiniObject<
+              {
+                metadata: z.ZodMiniNull;
+                type: z.ZodMiniLiteral<"panel">;
+                id: z.ZodMiniString<string>;
+                moduleId: z.ZodMiniString<string>;
+                name: z.ZodMiniString<string>;
+                src: z.ZodMiniString<string>;
+                title: z.ZodMiniString<string>;
+                version: z.ZodMiniOptional<z.ZodMiniString<string>>;
+              },
+              z.core.$strip
+            >,
+            z.ZodMiniObject<
+              {
+                metadata: z.ZodMiniNull;
+                type: z.ZodMiniLiteral<"worker">;
+                id: z.ZodMiniString<string>;
+                moduleId: z.ZodMiniString<string>;
+                name: z.ZodMiniString<string>;
+                src: z.ZodMiniString<string>;
+                title: z.ZodMiniString<string>;
+                version: z.ZodMiniOptional<z.ZodMiniString<string>>;
+              },
+              z.core.$strip
+            >,
+          ],
+          "type"
         >
       >
     >;
@@ -79,6 +121,7 @@ declare const devServerManifestSchema: z.ZodMiniObject<
               group: z.ZodMiniOptional<z.ZodMiniString<string>>;
               icon: z.ZodMiniOptional<z.ZodMiniString<string>>;
               priority: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+              slug: z.ZodMiniOptional<z.ZodMiniString<string>>;
               title: z.ZodMiniOptional<z.ZodMiniString<string>>;
               version: z.ZodMiniString<string>;
             },

package/dist/_exports/index.d.ts

@@ -84,7 +84,7 @@ declare const DefineAppInputSchema: z.ZodMiniObject<
         >
       >
     >;
-    slug: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    slug: z.ZodMiniString<string>;
     title: z.ZodMiniString<string>;
     views: z.ZodMiniOptional<
       z.ZodMiniArray<
@@ -104,6 +104,13 @@ declare const DefineAppInputSchema: z.ZodMiniObject<
         >
       >
     >;
+    visibility: z.ZodMiniOptional<
+      z.ZodMiniEnum<{
+        default: "default";
+        unlisted: "unlisted";
+        disabled: "disabled";
+      }>
+    >;
   },
   z.core.$strip
 >;

package/dist/_exports/preview.d.ts

@@ -0,0 +1,169 @@
+import { CliConfig } from "@sanity/cli-core";
+import { Output } from "@sanity/cli-core";
+import { z } from "zod/mini";
+
+/**
+ * A manifest describing a running dev server process (studio or app).
+ * Stored as `~/.sanity/dev-servers/<pid>.json`.
+ *
+ * The workbench singleton is tracked separately via the lock file — see
+ * `acquireWorkbenchLock` and `readWorkbenchLock` below.
+ */
+declare type DevServerManifest = z.infer<typeof devServerManifestSchema>;
+
+declare const devServerManifestSchema: z.ZodMiniObject<
+  {
+    configs: z.ZodMiniOptional<
+      z.ZodMiniArray<
+        z.ZodMiniObject<
+          {
+            appType: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            fields: z.ZodMiniArray<
+              z.ZodMiniObject<
+                {
+                  name: z.ZodMiniString<string>;
+                  public: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+                  src: z.ZodMiniString<string>;
+                  title: z.ZodMiniString<string>;
+                },
+                z.core.$strip
+              >
+            >;
+            id: z.ZodMiniString<string>;
+            moduleName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            version: z.ZodMiniNumber<number>;
+          },
+          z.core.$strip
+        >
+      >
+    >;
+    host: z.ZodMiniString<string>;
+    id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    interfaces: z.ZodMiniOptional<
+      z.ZodMiniArray<
+        z.ZodMiniDiscriminatedUnion<
+          [
+            z.ZodMiniObject<
+              {
+                metadata: z.ZodMiniNullable<
+                  z.ZodMiniObject<
+                    {
+                      group: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                      priority: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                    },
+                    z.core.$strip
+                  >
+                >;
+                type: z.ZodMiniLiteral<"app">;
+                id: z.ZodMiniString<string>;
+                moduleId: z.ZodMiniString<string>;
+                name: z.ZodMiniString<string>;
+                src: z.ZodMiniString<string>;
+                title: z.ZodMiniString<string>;
+                version: z.ZodMiniOptional<z.ZodMiniString<string>>;
+              },
+              z.core.$strip
+            >,
+            z.ZodMiniObject<
+              {
+                metadata: z.ZodMiniNull;
+                type: z.ZodMiniLiteral<"panel">;
+                id: z.ZodMiniString<string>;
+                moduleId: z.ZodMiniString<string>;
+                name: z.ZodMiniString<string>;
+                src: z.ZodMiniString<string>;
+                title: z.ZodMiniString<string>;
+                version: z.ZodMiniOptional<z.ZodMiniString<string>>;
+              },
+              z.core.$strip
+            >,
+            z.ZodMiniObject<
+              {
+                metadata: z.ZodMiniNull;
+                type: z.ZodMiniLiteral<"worker">;
+                id: z.ZodMiniString<string>;
+                moduleId: z.ZodMiniString<string>;
+                name: z.ZodMiniString<string>;
+                src: z.ZodMiniString<string>;
+                title: z.ZodMiniString<string>;
+                version: z.ZodMiniOptional<z.ZodMiniString<string>>;
+              },
+              z.core.$strip
+            >,
+          ],
+          "type"
+        >
+      >
+    >;
+    manifest: z.ZodMiniOptional<
+      z.ZodMiniUnion<
+        readonly [
+          z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>,
+          z.ZodMiniObject<
+            {
+              group: z.ZodMiniOptional<z.ZodMiniString<string>>;
+              icon: z.ZodMiniOptional<z.ZodMiniString<string>>;
+              priority: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+              slug: z.ZodMiniOptional<z.ZodMiniString<string>>;
+              title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+              version: z.ZodMiniString<string>;
+            },
+            z.core.$strip
+          >,
+        ]
+      >
+    >;
+    manifestUpdatedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    pid: z.ZodMiniNumber<number>;
+    port: z.ZodMiniNumber<number>;
+    projectId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    startedAt: z.ZodMiniString<string>;
+    type: z.ZodMiniEnum<{
+      coreApp: "coreApp";
+      studio: "studio";
+    }>;
+    version: z.ZodMiniLiteral<1>;
+    workDir: z.ZodMiniString<string>;
+  },
+  z.core.$strip
+>;
+
+/**
+ * `sanity start` for a workbench app: serve a production build the way dev serves
+ * a live one. The same singleton workbench shell renders it and the same registry
+ * advertises it — only the remote differs, static files from the build output
+ * instead of a live Vite dev server. There's no config watcher or rebuild: a
+ * build is fixed, so nothing re-syncs.
+ *
+ * A running workbench claims the configured port, so the built remote binds the
+ * next one. Without one the remote takes the configured port and announces its
+ * own URL.
+ */
+export declare function startWorkbenchPreview(
+  options: StartWorkbenchPreviewOptions,
+): Promise<{
+  close: () => Promise<void>;
+}>;
+
+export declare interface StartWorkbenchPreviewOptions {
+  /** Directory for the workbench Vite server's dependency cache. */
+  cacheDir: string;
+  /** CLI-domain `app.id`/`deployment.appId` deprecation check, run before registering. */
+  checkForDeprecatedAppId: () => void;
+  cliConfig: CliConfig;
+  /** Extract the project manifest to inline into the registry (studio-vs-app handled by the CLI). */
+  extractManifest: (params: {
+    configPath: string;
+    workDir: string;
+  }) => Promise<DevServerManifest["manifest"]>;
+  httpHost: string;
+  httpPort: number;
+  isApp: boolean;
+  /** The built `dist` directory to serve as the federation remote. */
+  outDir: string;
+  output: Output;
+  reactStrictMode: boolean;
+  workDir: string;
+}
+
+export {};

package/dist/_exports/preview.js

@@ -0,0 +1,3 @@
+export { startWorkbenchPreview } from '../actions/preview/startWorkbenchPreview.js';
+
+//# sourceMappingURL=preview.js.map

package/dist/_exports/preview.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/_exports/preview.ts"],"sourcesContent":["export {\n  startWorkbenchPreview,\n  type StartWorkbenchPreviewOptions,\n} from '../actions/preview/startWorkbenchPreview.js'\n"],"names":["startWorkbenchPreview"],"mappings":"AAAA,SACEA,qBAAqB,QAEhB,8CAA6C"}

package/dist/_exports/undeploy.d.ts

@@ -1,3 +1,4 @@
+import { AppVisibility } from "@sanity/cli-core";
 import { UndeployAdapter } from "@sanity/cli-core/undeploy";
 import { UndeployApplicationTarget } from "@sanity/cli-core/undeploy";
 import { UndeployConfigTarget } from "@sanity/cli-core/undeploy";
@@ -101,7 +102,7 @@ declare const DefineAppInputSchema: z.ZodMiniObject<
         >
       >
     >;
-    slug: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    slug: z.ZodMiniString<string>;
     title: z.ZodMiniString<string>;
     views: z.ZodMiniOptional<
       z.ZodMiniArray<
@@ -121,6 +122,13 @@ declare const DefineAppInputSchema: z.ZodMiniObject<
         >
       >
     >;
+    visibility: z.ZodMiniOptional<
+      z.ZodMiniEnum<{
+        default: "default";
+        unlisted: "unlisted";
+        disabled: "disabled";
+      }>
+    >;
   },
   z.core.$strip
 >;
@@ -177,10 +185,14 @@ declare interface ResolvedWorkbenchApp {
   readonly config?: WorkbenchApp["config"];
   /** SDK app-view entrypoint, when declared. */
   readonly entry?: string;
+  /** Path to the app's icon SVG, resolved and shipped to Brett on deploy. */
+  readonly icon?: string;
   /** Explicit singleton flag (a Sanity-owned app); `undefined` when the app doesn't set it. */
   readonly isSingleton?: boolean;
   /** Hostname the application is created at on first deploy. */
   readonly slug?: string;
+  /** Dashboard visibility declared by the app; `undefined` when unset. */
+  readonly visibility?: AppVisibility;
 }
 
 declare type ViewDeploymentPayload = z.infer<

package/dist/actions/build/vite/optimize-deps.js

@@ -0,0 +1,84 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * React APIs only the generated render-contract modules import — the SPA
+ * bootstrap (`getEntryModule`) and every render artifact (`renderRemote`)
+ * `createRoot` from `react-dom/client` and `createElement` from `react`. No
+ * app/interface source imports `react-dom/client` itself, so scanning `entries`
+ * never surfaces it; every workbench app depends on react/react-dom, so both
+ * always resolve.
+ */ const RENDER_CONTRACT_DEPS = [
+    'react',
+    'react-dom/client'
+];
+/** Extensions an import-style source path may omit, in resolution order. */ const SOURCE_EXTENSIONS = [
+    '.tsx',
+    '.ts',
+    '.jsx',
+    '.js',
+    '.mjs',
+    '.cjs'
+];
+/**
+ * Resolve an import-style source path to the file on disk. The app `entry`
+ * defaults to the extensionless `./src/App` (and a user may omit the extension
+ * anywhere), which the runtime imports fine through Vite's resolver — but
+ * `optimizeDeps.entries` is matched against the filesystem, so an extensionless
+ * path never matches and its deps go unscanned. Try the path as-is, then the
+ * common source extensions; fall back to the input so an already-resolved path
+ * (or a genuinely missing one) passes through unchanged.
+ */ function resolveSourceFile(absPath) {
+    if (fs.existsSync(absPath) && fs.statSync(absPath).isFile()) return absPath;
+    for (const extension of SOURCE_EXTENSIONS){
+        if (fs.existsSync(`${absPath}${extension}`)) return `${absPath}${extension}`;
+    }
+    return absPath;
+}
+/**
+ * Dep pre-bundling inputs for a workbench app's dev server.
+ *
+ * Vite's dep scanner crawls from the app's HTML entry, which reaches only the
+ * app's `entry` (or a studio's config) — never the federation `exposes` (dock
+ * views, worker services, media-library config fields), which the host loads
+ * dynamically at runtime. So a dep imported only by an exposed module (e.g.
+ * `sanity/workbench` in a service or view) escapes the startup scan; Vite
+ * discovers it on first request, re-optimizes, and full-page reloads — which
+ * flakes Playwright in e2e.
+ *
+ * Point `entries` at the source of every interface: the app `entry` (or, for a
+ * studio, its config), plus each view, service, and installation-config source.
+ * `entries` follows real import statements, so it covers whatever those sources
+ * transitively use — correct subpaths and all — with no hand-maintained dep
+ * list, and never crashes on an unresolvable name the way a bad `include` entry
+ * does. Each source is resolved to its on-disk file so an extensionless path
+ * (like the default `./src/App`) still matches `entries`' filesystem glob.
+ *
+ * @param cwd - Project root; `entries` are returned relative to it.
+ * @param appSources - Absolute paths to the app's `entry` and/or studio config.
+ * @param exposes - The app's declared views/services/config.
+ * @internal
+ */ export function workbenchOptimizeDeps(options) {
+    const { appSources, cwd, exposes } = options;
+    const interfaceSources = [
+        ...(exposes?.views ?? []).map((view)=>view.src),
+        ...(exposes?.services ?? []).map((service)=>service.src),
+        ...(exposes?.config?.fields ?? []).map((field)=>field.src)
+    ].map((src)=>path.resolve(cwd, src));
+    const entries = [
+        ...appSources,
+        ...interfaceSources
+    ].map((absPath)=>{
+        const resolved = resolveSourceFile(absPath);
+        return path.relative(cwd, resolved).split(path.sep).join('/');
+    });
+    return {
+        entries: [
+            ...new Set(entries)
+        ],
+        include: [
+            ...RENDER_CONTRACT_DEPS
+        ]
+    };
+}
+
+//# sourceMappingURL=optimize-deps.js.map

package/dist/actions/build/vite/optimize-deps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/build/vite/optimize-deps.ts"],"sourcesContent":["import fs from 'node:fs'\nimport path from 'node:path'\n\nimport {type WorkbenchExposes} from '../../../resolveWorkbenchApp.js'\n\n/**\n * React APIs only the generated render-contract modules import — the SPA\n * bootstrap (`getEntryModule`) and every render artifact (`renderRemote`)\n * `createRoot` from `react-dom/client` and `createElement` from `react`. No\n * app/interface source imports `react-dom/client` itself, so scanning `entries`\n * never surfaces it; every workbench app depends on react/react-dom, so both\n * always resolve.\n */\nconst RENDER_CONTRACT_DEPS = ['react', 'react-dom/client']\n\n/** Extensions an import-style source path may omit, in resolution order. */\nconst SOURCE_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs']\n\n/**\n * Resolve an import-style source path to the file on disk. The app `entry`\n * defaults to the extensionless `./src/App` (and a user may omit the extension\n * anywhere), which the runtime imports fine through Vite's resolver — but\n * `optimizeDeps.entries` is matched against the filesystem, so an extensionless\n * path never matches and its deps go unscanned. Try the path as-is, then the\n * common source extensions; fall back to the input so an already-resolved path\n * (or a genuinely missing one) passes through unchanged.\n */\nfunction resolveSourceFile(absPath: string): string {\n  if (fs.existsSync(absPath) && fs.statSync(absPath).isFile()) return absPath\n  for (const extension of SOURCE_EXTENSIONS) {\n    if (fs.existsSync(`${absPath}${extension}`)) return `${absPath}${extension}`\n  }\n  return absPath\n}\n\n/**\n * Dep pre-bundling inputs for a workbench app's dev server.\n *\n * Vite's dep scanner crawls from the app's HTML entry, which reaches only the\n * app's `entry` (or a studio's config) — never the federation `exposes` (dock\n * views, worker services, media-library config fields), which the host loads\n * dynamically at runtime. So a dep imported only by an exposed module (e.g.\n * `sanity/workbench` in a service or view) escapes the startup scan; Vite\n * discovers it on first request, re-optimizes, and full-page reloads — which\n * flakes Playwright in e2e.\n *\n * Point `entries` at the source of every interface: the app `entry` (or, for a\n * studio, its config), plus each view, service, and installation-config source.\n * `entries` follows real import statements, so it covers whatever those sources\n * transitively use — correct subpaths and all — with no hand-maintained dep\n * list, and never crashes on an unresolvable name the way a bad `include` entry\n * does. Each source is resolved to its on-disk file so an extensionless path\n * (like the default `./src/App`) still matches `entries`' filesystem glob.\n *\n * @param cwd - Project root; `entries` are returned relative to it.\n * @param appSources - Absolute paths to the app's `entry` and/or studio config.\n * @param exposes - The app's declared views/services/config.\n * @internal\n */\nexport function workbenchOptimizeDeps(options: {\n  appSources: readonly string[]\n  cwd: string\n  exposes?: WorkbenchExposes\n}): {entries: string[]; include: string[]} {\n  const {appSources, cwd, exposes} = options\n\n  const interfaceSources = [\n    ...(exposes?.views ?? []).map((view) => view.src),\n    ...(exposes?.services ?? []).map((service) => service.src),\n    ...(exposes?.config?.fields ?? []).map((field) => field.src),\n  ].map((src) => path.resolve(cwd, src))\n\n  const entries = [...appSources, ...interfaceSources].map((absPath) => {\n    const resolved = resolveSourceFile(absPath)\n    return path.relative(cwd, resolved).split(path.sep).join('/')\n  })\n\n  return {\n    entries: [...new Set(entries)],\n    include: [...RENDER_CONTRACT_DEPS],\n  }\n}\n"],"names":["fs","path","RENDER_CONTRACT_DEPS","SOURCE_EXTENSIONS","resolveSourceFile","absPath","existsSync","statSync","isFile","extension","workbenchOptimizeDeps","options","appSources","cwd","exposes","interfaceSources","views","map","view","src","services","service","config","fields","field","resolve","entries","resolved","relative","split","sep","join","Set","include"],"mappings":"AAAA,OAAOA,QAAQ,UAAS;AACxB,OAAOC,UAAU,YAAW;AAI5B;;;;;;;CAOC,GACD,MAAMC,uBAAuB;IAAC;IAAS;CAAmB;AAE1D,0EAA0E,GAC1E,MAAMC,oBAAoB;IAAC;IAAQ;IAAO;IAAQ;IAAO;IAAQ;CAAO;AAExE;;;;;;;;CAQC,GACD,SAASC,kBAAkBC,OAAe;IACxC,IAAIL,GAAGM,UAAU,CAACD,YAAYL,GAAGO,QAAQ,CAACF,SAASG,MAAM,IAAI,OAAOH;IACpE,KAAK,MAAMI,aAAaN,kBAAmB;QACzC,IAAIH,GAAGM,UAAU,CAAC,GAAGD,UAAUI,WAAW,GAAG,OAAO,GAAGJ,UAAUI,WAAW;IAC9E;IACA,OAAOJ;AACT;AAEA;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GACD,OAAO,SAASK,sBAAsBC,OAIrC;IACC,MAAM,EAACC,UAAU,EAAEC,GAAG,EAAEC,OAAO,EAAC,GAAGH;IAEnC,MAAMI,mBAAmB;WACpB,AAACD,CAAAA,SAASE,SAAS,EAAE,AAAD,EAAGC,GAAG,CAAC,CAACC,OAASA,KAAKC,GAAG;WAC7C,AAACL,CAAAA,SAASM,YAAY,EAAE,AAAD,EAAGH,GAAG,CAAC,CAACI,UAAYA,QAAQF,GAAG;WACtD,AAACL,CAAAA,SAASQ,QAAQC,UAAU,EAAE,AAAD,EAAGN,GAAG,CAAC,CAACO,QAAUA,MAAML,GAAG;KAC5D,CAACF,GAAG,CAAC,CAACE,MAAQlB,KAAKwB,OAAO,CAACZ,KAAKM;IAEjC,MAAMO,UAAU;WAAId;WAAeG;KAAiB,CAACE,GAAG,CAAC,CAACZ;QACxD,MAAMsB,WAAWvB,kBAAkBC;QACnC,OAAOJ,KAAK2B,QAAQ,CAACf,KAAKc,UAAUE,KAAK,CAAC5B,KAAK6B,GAAG,EAAEC,IAAI,CAAC;IAC3D;IAEA,OAAO;QACLL,SAAS;eAAI,IAAIM,IAAIN;SAAS;QAC9BO,SAAS;eAAI/B;SAAqB;IACpC;AACF"}