@sanity/workbench-cli 1.1.0-beta.0 → 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sanity.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_exports/dev.d.ts

@@ -1,40 +1,23 @@
+import { CliConfig } from "@sanity/cli-core";
+import { Output } from "@sanity/cli-core";
+import { ViteDevServer } from "vite";
 import { z } from "zod/mini";
 
 /**
- * Attempt to acquire an exclusive lock for the workbench process.
- * Uses `O_EXCL` (the `wx` flag) which is atomic at the OS level — only one
- * process can create the file.
- *
- * The lock stores `{pid, host, port}` so other processes can find the
- * running workbench. Call `updatePort` after the Vite server starts to
- * write the actual port (Vite may pick a different one).
- *
- * @returns A {@link WorkbenchLock} if acquired, or `undefined` if another
- *          live process already holds it.
- */
-export declare function acquireWorkbenchLock(
-  info: {
-    host: string;
-    port: number;
-  },
-  retries?: number,
-): WorkbenchLock | undefined;
-
-/**
- * Resolve a directory to its canonical (long) form before handing it to
- * `fs.watch`.
- *
- * On Windows, `fs.watch` aborts with a libuv assertion
- * (`!_wcsnicmp(filename, dir, dirlen)` in `fs-event.c`) when the watched path
- * is an 8.3 short name — e.g. temp dirs under `RUNNER~1` — because the OS
- * reports long-form filenames that fail libuv's prefix check.
- * `realpathSync.native` expands short names to their long form so the
- * prefixes match.
- *
- * Falls back to the original path when it can't be resolved (e.g. it doesn't
- * exist yet), which is no worse than watching it directly.
+ * Minimal shape the supervisor needs back from a started app/studio dev server.
+ * The not-started arm is reserved for expected early exits the server already
+ * reported (e.g. a missing organization id) — a failure to *boot* still throws.
  */
-export declare function canonicalizeWatchDir(dir: string): string;
+declare type AppServerResult =
+  | {
+      close: () => Promise<void>;
+      server: ViteDevServer;
+      started: true;
+    }
+  | {
+      reason: string;
+      started: false;
+    };
 
 /**
  * A manifest describing a running dev server process (studio or app).
@@ -43,7 +26,7 @@ export declare function canonicalizeWatchDir(dir: string): string;
  * The workbench singleton is tracked separately via the lock file — see
  * `acquireWorkbenchLock` and `readWorkbenchLock` below.
  */
-export declare type DevServerManifest = z.infer<typeof devServerManifestSchema>;
+declare type DevServerManifest = z.infer<typeof devServerManifestSchema>;
 
 declare const devServerManifestSchema: z.ZodMiniObject<
   {
@@ -93,74 +76,47 @@ declare const devServerManifestSchema: z.ZodMiniObject<
   z.core.$strip
 >;
 
-declare interface DevServerRegistration {
-  /** Remove the registry entry. */
-  release: () => void;
-  /**
-   * Rewrite the registry entry with partial updates merged in. Also bumps the
-   * file's mtime, which fires `watchRegistry` in any workbench process and
-   * triggers a rebroadcast to connected clients.
-   */
-  update: (
-    patch: Partial<Omit<DevServerManifest, "pid" | "startedAt" | "version">>,
-  ) => void;
-}
-
-/**
- * Read all manifest files from the registry, prune stale entries (dead PIDs),
- * and return the live ones.
- */
-export declare function getRegisteredServers(): DevServerManifest[];
-
-/**
- * Read the workbench lock file and return its contents if the holding
- * process is still alive. Prunes stale locks from crashed processes.
- */
-export declare function readWorkbenchLock():
-  | z.infer<typeof workbenchLockSchema>
-  | undefined;
-
 /**
- * Write a manifest file for the current process and return a handle with a
- * `release` function that removes it plus an `update` function for patching
- * fields post-registration. Uses synchronous I/O so the file exists before
- * any signal handler could fire.
- */
-export declare function registerDevServer(
-  manifest: Omit<DevServerManifest, "pid" | "startedAt" | "version">,
-): DevServerRegistration;
-
-declare interface RegistryWatcher {
-  close(): void;
-}
-
-/**
- * Watch the registry directory for changes and invoke the callback with the
- * current list of live servers whenever a change is detected.
+ * Orchestrate the dev servers a workbench project needs: a singleton workbench
+ * Vite server plus the app/studio dev server it renders, wired to the dev-server
+ * registry so view/service edits re-sync live.
  *
- * Uses `fs.watch` with a debounce to coalesce rapid file changes (e.g. a
- * server starting and writing its manifest triggers multiple FS events).
+ * A running workbench claims the configured port, so the app server binds the
+ * next one. If the workbench can't start (package or port unavailable), the app
+ * server falls back to the configured port and announces its own URL, exactly as
+ * a plain `sanity dev` would.
  */
-export declare function watchRegistry(
-  callback: (servers: DevServerManifest[]) => void,
-): RegistryWatcher;
+export declare function startWorkbenchDev(
+  options: StartWorkbenchDevOptions,
+): Promise<{
+  close: () => Promise<void>;
+}>;
 
-declare interface WorkbenchLock {
-  /** Release the lock file. */
-  release: () => void;
-  /** Update the lock with the actual port after the server starts listening. */
-  updatePort: (port: number) => void;
+export declare interface StartWorkbenchDevOptions {
+  /** Resolved app id for the registry entry (the CLI owns id resolution). */
+  appId: string | undefined;
+  /** 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 | undefined;
+  httpPort: number;
+  isApp: boolean;
+  output: Output;
+  reactStrictMode: boolean;
+  /** Start the app/studio dev server — the CLI owns the server, this orchestrates it. */
+  startAppServer: (params: {
+    announceUrl: boolean;
+    cliConfig: CliConfig;
+    httpPort: number;
+  }) => Promise<AppServerResult>;
+  workDir: string;
 }
 
-declare const workbenchLockSchema: z.ZodMiniObject<
-  {
-    host: z.ZodMiniString<string>;
-    pid: z.ZodMiniNumber<number>;
-    port: z.ZodMiniNumber<number>;
-    startedAt: z.ZodMiniString<string>;
-    version: z.ZodMiniLiteral<1>;
-  },
-  z.core.$strip
->;
-
 export {};

package/dist/_exports/dev.js

@@ -1,10 +1,3 @@
-// Node-only dev entry: the workbench dev-server registry the CLI's dev
-// orchestration drives. It tracks running studio/app dev servers (single
-// instance via a lock + PID-liveness), and the workbench host watches it to
-// render local panels/services without a deploy. The CLI owns the orchestration
-// (starting servers, extracting manifests); this package owns the registry it
-// registers into and watches.
-export { canonicalizeWatchDir } from '../actions/dev/canonicalizeWatchDir.js';
-export { acquireWorkbenchLock, getRegisteredServers, readWorkbenchLock, registerDevServer, watchRegistry } from '../actions/dev/registry.js';
+export { startWorkbenchDev } from '../actions/dev/startWorkbenchDev.js';
 
 //# sourceMappingURL=dev.js.map

package/dist/_exports/dev.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/_exports/dev.ts"],"sourcesContent":["// Node-only dev entry: the workbench dev-server registry the CLI's dev\n// orchestration drives. It tracks running studio/app dev servers (single\n// instance via a lock + PID-liveness), and the workbench host watches it to\n// render local panels/services without a deploy. The CLI owns the orchestration\n// (starting servers, extracting manifests); this package owns the registry it\n// registers into and watches.\nexport {canonicalizeWatchDir} from '../actions/dev/canonicalizeWatchDir.js'\nexport {\n  acquireWorkbenchLock,\n  type DevServerManifest,\n  getRegisteredServers,\n  readWorkbenchLock,\n  registerDevServer,\n  watchRegistry,\n} from '../actions/dev/registry.js'\n"],"names":["canonicalizeWatchDir","acquireWorkbenchLock","getRegisteredServers","readWorkbenchLock","registerDevServer","watchRegistry"],"mappings":"AAAA,uEAAuE;AACvE,yEAAyE;AACzE,4EAA4E;AAC5E,gFAAgF;AAChF,8EAA8E;AAC9E,8BAA8B;AAC9B,SAAQA,oBAAoB,QAAO,yCAAwC;AAC3E,SACEC,oBAAoB,EAEpBC,oBAAoB,EACpBC,iBAAiB,EACjBC,iBAAiB,EACjBC,aAAa,QACR,6BAA4B"}
+{"version":3,"sources":["../../src/_exports/dev.ts"],"sourcesContent":["export {startWorkbenchDev, type StartWorkbenchDevOptions} from '../actions/dev/startWorkbenchDev.js'\n"],"names":["startWorkbenchDev"],"mappings":"AAAA,SAAQA,iBAAiB,QAAsC,sCAAqC"}

package/dist/actions/dev/appServerSupervisor.js

@@ -0,0 +1,66 @@
+import { getCliConfigUncached } from '@sanity/cli-core';
+const noop = async ()=>{};
+/**
+ * Own the app/studio dev server's lifecycle behind the dev-server registry seam.
+ *
+ * Adding or removing a view/service rebuilds the federation remote: its
+ * module-federation `exposes` map and codegen artifacts are computed once at
+ * server start, so a newly-declared interface has no expose until the server is
+ * recreated — `server.restart()` can't do it (it reuses the inline config).
+ * `rebuild` therefore tears the server down and starts a fresh one with a
+ * reloaded config; the registry watcher calls it when the interface set changes.
+ *
+ * Returns the not-started result verbatim when the initial boot is an expected
+ * early exit, so the caller can skip the rest of the orchestration.
+ */ export async function startAppServerSupervisor(options) {
+    const { cliConfig, start, workDir } = options;
+    const initial = await start(cliConfig);
+    if (!initial.started) return {
+        reason: initial.reason,
+        started: false
+    };
+    // `closeCurrent` repoints at the replacement only once a rebuild succeeds, so a
+    // failed rebuild (old server already closed) leaves nothing for close() to re-close.
+    let server = initial.server;
+    let closeCurrent = initial.close;
+    let closed = false;
+    // close() waits on this so a rebuild racing teardown can't orphan the replacement.
+    // Rejections are the watcher's (warn + retry); the tracked copy is swallowed.
+    let rebuildInFlight = Promise.resolve();
+    const runRebuild = async ()=>{
+        // Refuse once shutting down — a config save in the teardown window must not
+        // boot a replacement nobody owns.
+        if (closed) throw new Error('Dev server is shutting down');
+        const freshConfig = await getCliConfigUncached(workDir);
+        await closeCurrent();
+        closeCurrent = noop;
+        const result = await start(freshConfig);
+        if (!result.started) {
+            // The server already reported why (e.g. organizationId was removed).
+            throw new Error('Dev server did not restart after the view/service change');
+        }
+        server = result.server;
+        closeCurrent = result.close;
+        return server;
+    };
+    return {
+        started: true,
+        supervisor: {
+            async close () {
+                closed = true;
+                await rebuildInFlight;
+                await closeCurrent();
+            },
+            rebuild () {
+                const rebuild = runRebuild();
+                rebuildInFlight = rebuild.catch(()=>{});
+                return rebuild;
+            },
+            get server () {
+                return server;
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=appServerSupervisor.js.map

package/dist/actions/dev/appServerSupervisor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/dev/appServerSupervisor.ts"],"sourcesContent":["import {type CliConfig, getCliConfigUncached} from '@sanity/cli-core'\nimport {type ViteDevServer} from 'vite'\n\n/**\n * Minimal shape the supervisor needs back from a started app/studio dev server.\n * The not-started arm is reserved for expected early exits the server already\n * reported (e.g. a missing organization id) — a failure to *boot* still throws.\n */\nexport type AppServerResult =\n  | {close: () => Promise<void>; server: ViteDevServer; started: true}\n  | {reason: string; started: false}\n\n/** Start the app/studio dev server for a given config (port + URL intent baked in by the caller). */\nexport type StartAppServer = (cliConfig: CliConfig) => Promise<AppServerResult>\n\nconst noop = async () => {}\n\nexport interface AppServerSupervisor {\n  /** Stop the server once, waiting out any rebuild already in flight. */\n  close: () => Promise<void>\n  /** Tear down the running server and bring it back up with a freshly-loaded config. */\n  rebuild: () => Promise<ViteDevServer>\n  /** The currently-live dev server; re-points after a rebuild. */\n  readonly server: ViteDevServer\n}\n\n/**\n * Own the app/studio dev server's lifecycle behind the dev-server registry seam.\n *\n * Adding or removing a view/service rebuilds the federation remote: its\n * module-federation `exposes` map and codegen artifacts are computed once at\n * server start, so a newly-declared interface has no expose until the server is\n * recreated — `server.restart()` can't do it (it reuses the inline config).\n * `rebuild` therefore tears the server down and starts a fresh one with a\n * reloaded config; the registry watcher calls it when the interface set changes.\n *\n * Returns the not-started result verbatim when the initial boot is an expected\n * early exit, so the caller can skip the rest of the orchestration.\n */\nexport async function startAppServerSupervisor(options: {\n  cliConfig: CliConfig\n  start: StartAppServer\n  workDir: string\n}): Promise<{reason: string; started: false} | {started: true; supervisor: AppServerSupervisor}> {\n  const {cliConfig, start, workDir} = options\n\n  const initial = await start(cliConfig)\n  if (!initial.started) return {reason: initial.reason, started: false}\n\n  // `closeCurrent` repoints at the replacement only once a rebuild succeeds, so a\n  // failed rebuild (old server already closed) leaves nothing for close() to re-close.\n  let server = initial.server\n  let closeCurrent = initial.close\n  let closed = false\n  // close() waits on this so a rebuild racing teardown can't orphan the replacement.\n  // Rejections are the watcher's (warn + retry); the tracked copy is swallowed.\n  let rebuildInFlight: Promise<unknown> = Promise.resolve()\n\n  const runRebuild = async (): Promise<ViteDevServer> => {\n    // Refuse once shutting down — a config save in the teardown window must not\n    // boot a replacement nobody owns.\n    if (closed) throw new Error('Dev server is shutting down')\n    const freshConfig = await getCliConfigUncached(workDir)\n    await closeCurrent()\n    closeCurrent = noop\n    const result = await start(freshConfig)\n    if (!result.started) {\n      // The server already reported why (e.g. organizationId was removed).\n      throw new Error('Dev server did not restart after the view/service change')\n    }\n    server = result.server\n    closeCurrent = result.close\n    return server\n  }\n\n  return {\n    started: true,\n    supervisor: {\n      async close() {\n        closed = true\n        await rebuildInFlight\n        await closeCurrent()\n      },\n      rebuild() {\n        const rebuild = runRebuild()\n        rebuildInFlight = rebuild.catch(() => {})\n        return rebuild\n      },\n      get server() {\n        return server\n      },\n    },\n  }\n}\n"],"names":["getCliConfigUncached","noop","startAppServerSupervisor","options","cliConfig","start","workDir","initial","started","reason","server","closeCurrent","close","closed","rebuildInFlight","Promise","resolve","runRebuild","Error","freshConfig","result","supervisor","rebuild","catch"],"mappings":"AAAA,SAAwBA,oBAAoB,QAAO,mBAAkB;AAerE,MAAMC,OAAO,WAAa;AAW1B;;;;;;;;;;;;CAYC,GACD,OAAO,eAAeC,yBAAyBC,OAI9C;IACC,MAAM,EAACC,SAAS,EAAEC,KAAK,EAAEC,OAAO,EAAC,GAAGH;IAEpC,MAAMI,UAAU,MAAMF,MAAMD;IAC5B,IAAI,CAACG,QAAQC,OAAO,EAAE,OAAO;QAACC,QAAQF,QAAQE,MAAM;QAAED,SAAS;IAAK;IAEpE,gFAAgF;IAChF,qFAAqF;IACrF,IAAIE,SAASH,QAAQG,MAAM;IAC3B,IAAIC,eAAeJ,QAAQK,KAAK;IAChC,IAAIC,SAAS;IACb,mFAAmF;IACnF,8EAA8E;IAC9E,IAAIC,kBAAoCC,QAAQC,OAAO;IAEvD,MAAMC,aAAa;QACjB,4EAA4E;QAC5E,kCAAkC;QAClC,IAAIJ,QAAQ,MAAM,IAAIK,MAAM;QAC5B,MAAMC,cAAc,MAAMnB,qBAAqBM;QAC/C,MAAMK;QACNA,eAAeV;QACf,MAAMmB,SAAS,MAAMf,MAAMc;QAC3B,IAAI,CAACC,OAAOZ,OAAO,EAAE;YACnB,qEAAqE;YACrE,MAAM,IAAIU,MAAM;QAClB;QACAR,SAASU,OAAOV,MAAM;QACtBC,eAAeS,OAAOR,KAAK;QAC3B,OAAOF;IACT;IAEA,OAAO;QACLF,SAAS;QACTa,YAAY;YACV,MAAMT;gBACJC,SAAS;gBACT,MAAMC;gBACN,MAAMH;YACR;YACAW;gBACE,MAAMA,UAAUL;gBAChBH,kBAAkBQ,QAAQC,KAAK,CAAC,KAAO;gBACvC,OAAOD;YACT;YACA,IAAIZ,UAAS;gBACX,OAAOA;YACT;QACF;IACF;AACF"}

package/dist/actions/dev/deriveInterfaces.js

@@ -0,0 +1,34 @@
+import { isWorkbenchApp } from '@sanity/cli-core';
+/**
+ * Map an app's `unstable_defineApp` config to the interface records forwarded on
+ * its registry entry: `views` → panels, `services` → workers, `entry` → the
+ * navigable `app` view (`entry_point` is the raw `src`, not a resolved URL).
+ * `undefined` for a non-branded app; a studio that declares `entry` is rejected
+ * (studio app views are not implemented yet).
+ */ export function deriveInterfaces(app, options) {
+    if (!isWorkbenchApp(app)) return undefined;
+    if (!options.isApp && app.entry !== undefined) {
+        throw new Error('App views for studios are not implemented yet');
+    }
+    return [
+        ...app.views?.map((view)=>({
+                entry_point: view.src,
+                interface_type: view.type,
+                name: view.name
+            })) ?? [],
+        ...app.services?.map((service)=>({
+                entry_point: service.src,
+                interface_type: service.type,
+                name: service.name
+            })) ?? [],
+        ...app.entry === undefined ? [] : [
+            {
+                entry_point: app.entry,
+                interface_type: 'app',
+                name: app.name
+            }
+        ]
+    ];
+}
+
+//# sourceMappingURL=deriveInterfaces.js.map

package/dist/actions/dev/deriveInterfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/dev/deriveInterfaces.ts"],"sourcesContent":["import {type CliConfig, isWorkbenchApp} from '@sanity/cli-core'\n\nimport {type DevServerManifest} from './registry.js'\n\n/** One forwarded interface record on the dev-server registry entry. */\nexport type DevServerInterface = NonNullable<DevServerManifest['interfaces']>[number]\n\n/**\n * Map an app's `unstable_defineApp` config to the interface records forwarded on\n * its registry entry: `views` → panels, `services` → workers, `entry` → the\n * navigable `app` view (`entry_point` is the raw `src`, not a resolved URL).\n * `undefined` for a non-branded app; a studio that declares `entry` is rejected\n * (studio app views are not implemented yet).\n */\nexport function deriveInterfaces(\n  app: CliConfig['app'],\n  options: {isApp: boolean},\n): DevServerInterface[] | undefined {\n  if (!isWorkbenchApp(app)) return undefined\n\n  if (!options.isApp && app.entry !== undefined) {\n    throw new Error('App views for studios are not implemented yet')\n  }\n\n  return [\n    ...(app.views?.map((view) => ({\n      entry_point: view.src,\n      interface_type: view.type,\n      name: view.name,\n    })) ?? []),\n    ...(app.services?.map((service) => ({\n      entry_point: service.src,\n      interface_type: service.type,\n      name: service.name,\n    })) ?? []),\n    ...(app.entry === undefined\n      ? []\n      : [{entry_point: app.entry, interface_type: 'app' as const, name: app.name}]),\n  ]\n}\n"],"names":["isWorkbenchApp","deriveInterfaces","app","options","undefined","isApp","entry","Error","views","map","view","entry_point","src","interface_type","type","name","services","service"],"mappings":"AAAA,SAAwBA,cAAc,QAAO,mBAAkB;AAO/D;;;;;;CAMC,GACD,OAAO,SAASC,iBACdC,GAAqB,EACrBC,OAAyB;IAEzB,IAAI,CAACH,eAAeE,MAAM,OAAOE;IAEjC,IAAI,CAACD,QAAQE,KAAK,IAAIH,IAAII,KAAK,KAAKF,WAAW;QAC7C,MAAM,IAAIG,MAAM;IAClB;IAEA,OAAO;WACDL,IAAIM,KAAK,EAAEC,IAAI,CAACC,OAAU,CAAA;gBAC5BC,aAAaD,KAAKE,GAAG;gBACrBC,gBAAgBH,KAAKI,IAAI;gBACzBC,MAAML,KAAKK,IAAI;YACjB,CAAA,MAAO,EAAE;WACLb,IAAIc,QAAQ,EAAEP,IAAI,CAACQ,UAAa,CAAA;gBAClCN,aAAaM,QAAQL,GAAG;gBACxBC,gBAAgBI,QAAQH,IAAI;gBAC5BC,MAAME,QAAQF,IAAI;YACpB,CAAA,MAAO,EAAE;WACLb,IAAII,KAAK,KAAKF,YACd,EAAE,GACF;YAAC;gBAACO,aAAaT,IAAII,KAAK;gBAAEO,gBAAgB;gBAAgBE,MAAMb,IAAIa,IAAI;YAAA;SAAE;KAC/E;AACH"}

package/dist/actions/dev/interfaceSetId.js

@@ -0,0 +1,51 @@
+/**
+ * Order-independent identity of an app's interface set. Reordering
+ * `views`/`services` keeps the same id (not a change); adding, removing,
+ * renaming, or repointing one changes it. `undefined` ids to the empty set.
+ */ export function interfaceSetId(interfaces) {
+    if (!interfaces || interfaces.length === 0) return '';
+    return interfaces.map((iface)=>[
+            iface.interface_type,
+            iface.name,
+            iface.entry_point
+        ].join('::')).toSorted().join('|');
+}
+/**
+ * Tracks one app's interface set across config reloads. `changed` and `commit`
+ * are split so the caller commits only after the rebuild that depends on the new
+ * set succeeds — a thrown rebuild leaves it uncommitted, so the next save retries
+ * instead of skipping. Seed with the initially registered set.
+ */ export function trackInterfaceSet(initial) {
+    let lastId = interfaceSetId(initial);
+    return {
+        changed: (interfaces)=>interfaceSetId(interfaces) !== lastId,
+        commit: (interfaces)=>{
+            lastId = interfaceSetId(interfaces);
+        }
+    };
+}
+const serverKey = (server)=>`${server.id ?? ''}@${server.host ?? ''}:${server.port}`;
+/**
+ * Tracks every registered app's interface set across registry snapshots (the
+ * multi-app counterpart to {@link trackInterfaceSet}). `hasChanged` is true when
+ * a *known* app's set changed since the last call — its remote was rebuilt with
+ * new exposes, so the workbench must full-reload to drop the stale remote-entry.
+ * A new/removed app or manifest-only edit isn't a rebuild.
+ */ export function createInterfacesTracker() {
+    let known = new Map();
+    return {
+        hasChanged (servers) {
+            const rebuilt = servers.some((server)=>{
+                const key = serverKey(server);
+                return known.has(key) && known.get(key) !== interfaceSetId(server.interfaces);
+            });
+            known = new Map(servers.map((server)=>[
+                    serverKey(server),
+                    interfaceSetId(server.interfaces)
+                ]));
+            return rebuilt;
+        }
+    };
+}
+
+//# sourceMappingURL=interfaceSetId.js.map

package/dist/actions/dev/interfaceSetId.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/dev/interfaceSetId.ts"],"sourcesContent":["import {type DevServerInterface} from './deriveInterfaces.js'\nimport {type DevServerManifest} from './registry.js'\n\n/**\n * Order-independent identity of an app's interface set. Reordering\n * `views`/`services` keeps the same id (not a change); adding, removing,\n * renaming, or repointing one changes it. `undefined` ids to the empty set.\n */\nexport function interfaceSetId(interfaces: readonly DevServerInterface[] | undefined): string {\n  if (!interfaces || interfaces.length === 0) return ''\n  return interfaces\n    .map((iface) => [iface.interface_type, iface.name, iface.entry_point].join('::'))\n    .toSorted()\n    .join('|')\n}\n\n/**\n * Tracks one app's interface set across config reloads. `changed` and `commit`\n * are split so the caller commits only after the rebuild that depends on the new\n * set succeeds — a thrown rebuild leaves it uncommitted, so the next save retries\n * instead of skipping. Seed with the initially registered set.\n */\nexport function trackInterfaceSet(initial: readonly DevServerInterface[] | undefined): {\n  changed: (interfaces: readonly DevServerInterface[] | undefined) => boolean\n  commit: (interfaces: readonly DevServerInterface[] | undefined) => void\n} {\n  let lastId = interfaceSetId(initial)\n  return {\n    changed: (interfaces) => interfaceSetId(interfaces) !== lastId,\n    commit: (interfaces) => {\n      lastId = interfaceSetId(interfaces)\n    },\n  }\n}\n\nconst serverKey = (server: DevServerManifest): string =>\n  `${server.id ?? ''}@${server.host ?? ''}:${server.port}`\n\n/**\n * Tracks every registered app's interface set across registry snapshots (the\n * multi-app counterpart to {@link trackInterfaceSet}). `hasChanged` is true when\n * a *known* app's set changed since the last call — its remote was rebuilt with\n * new exposes, so the workbench must full-reload to drop the stale remote-entry.\n * A new/removed app or manifest-only edit isn't a rebuild.\n */\nexport function createInterfacesTracker(): {\n  hasChanged: (servers: readonly DevServerManifest[]) => boolean\n} {\n  let known = new Map<string, string>()\n  return {\n    hasChanged(servers) {\n      const rebuilt = servers.some((server) => {\n        const key = serverKey(server)\n        return known.has(key) && known.get(key) !== interfaceSetId(server.interfaces)\n      })\n      known = new Map(\n        servers.map((server) => [serverKey(server), interfaceSetId(server.interfaces)]),\n      )\n      return rebuilt\n    },\n  }\n}\n"],"names":["interfaceSetId","interfaces","length","map","iface","interface_type","name","entry_point","join","toSorted","trackInterfaceSet","initial","lastId","changed","commit","serverKey","server","id","host","port","createInterfacesTracker","known","Map","hasChanged","servers","rebuilt","some","key","has","get"],"mappings":"AAGA;;;;CAIC,GACD,OAAO,SAASA,eAAeC,UAAqD;IAClF,IAAI,CAACA,cAAcA,WAAWC,MAAM,KAAK,GAAG,OAAO;IACnD,OAAOD,WACJE,GAAG,CAAC,CAACC,QAAU;YAACA,MAAMC,cAAc;YAAED,MAAME,IAAI;YAAEF,MAAMG,WAAW;SAAC,CAACC,IAAI,CAAC,OAC1EC,QAAQ,GACRD,IAAI,CAAC;AACV;AAEA;;;;;CAKC,GACD,OAAO,SAASE,kBAAkBC,OAAkD;IAIlF,IAAIC,SAASZ,eAAeW;IAC5B,OAAO;QACLE,SAAS,CAACZ,aAAeD,eAAeC,gBAAgBW;QACxDE,QAAQ,CAACb;YACPW,SAASZ,eAAeC;QAC1B;IACF;AACF;AAEA,MAAMc,YAAY,CAACC,SACjB,GAAGA,OAAOC,EAAE,IAAI,GAAG,CAAC,EAAED,OAAOE,IAAI,IAAI,GAAG,CAAC,EAAEF,OAAOG,IAAI,EAAE;AAE1D;;;;;;CAMC,GACD,OAAO,SAASC;IAGd,IAAIC,QAAQ,IAAIC;IAChB,OAAO;QACLC,YAAWC,OAAO;YAChB,MAAMC,UAAUD,QAAQE,IAAI,CAAC,CAACV;gBAC5B,MAAMW,MAAMZ,UAAUC;gBACtB,OAAOK,MAAMO,GAAG,CAACD,QAAQN,MAAMQ,GAAG,CAACF,SAAS3B,eAAegB,OAAOf,UAAU;YAC9E;YACAoB,QAAQ,IAAIC,IACVE,QAAQrB,GAAG,CAAC,CAACa,SAAW;oBAACD,UAAUC;oBAAShB,eAAegB,OAAOf,UAAU;iBAAE;YAEhF,OAAOwB;QACT;IACF;AACF"}

package/dist/actions/dev/startDevManifestWatcher.js

@@ -0,0 +1,104 @@
+import { watch } from 'node:fs';
+import { basename, dirname } from 'node:path';
+import { findProjectRoot, subdebug } from '@sanity/cli-core';
+import { canonicalizeWatchDir } from './canonicalizeWatchDir.js';
+const devDebug = subdebug('dev');
+/**
+ * Debounce window between config file events and the next manifest
+ * regeneration. Coalesces rapid saves (e.g. editor auto-save) and
+ * atomic-rename bursts emitted by tools like VS Code.
+ */ const DEBOUNCE_MS = 250;
+/**
+ * Generate the project manifest once and then keep it in sync with the
+ * project's config file (`sanity.config.(ts|js)` for studios,
+ * `sanity.cli.(ts|js)` for core-apps) on disk. The initial generation runs
+ * fire-and-forget so it doesn't block dev-server startup; subsequent
+ * file-system events are coalesced behind it, so the extractor never has
+ * overlapping writes to its shared output directory. Each successful
+ * regeneration inlines the new manifest into the registry via the `update`
+ * callback, so any running workbench rebroadcasts to its clients.
+ *
+ * Errors during extraction are logged as warnings and do not crash the dev
+ * server — the previously extracted manifest (if any) stays in the
+ * registry.
+ */ export async function startDevManifestWatcher({ extract, extraWatchFilenames, output, update, workDir }) {
+    const projectRoot = await findProjectRoot(workDir);
+    const configPath = projectRoot.path;
+    let running = false;
+    let pending = false;
+    let closed = false;
+    const regenerate = async ()=>{
+        if (closed) return;
+        if (running) {
+            pending = true;
+            return;
+        }
+        running = true;
+        try {
+            const { interfaces, manifest } = await extract({
+                configPath,
+                workDir
+            });
+            if (closed) return;
+            await update({
+                interfaces,
+                manifest,
+                manifestUpdatedAt: new Date().toISOString()
+            });
+        } catch (err) {
+            // Extractors print their own spinner failure; log the reason here so
+            // the user sees what went wrong alongside the spinner indicator.
+            devDebug('Manifest regeneration failed: %O', err);
+            output.warn(`Could not extract manifest for workbench: ${err instanceof Error ? err.message : String(err)}`);
+        } finally{
+            running = false;
+            if (pending && !closed) {
+                pending = false;
+                void regenerate();
+            }
+        }
+    };
+    // Route the initial extraction through `regenerate` too, so file-system
+    // events arriving before it finishes get coalesced rather than racing it
+    // for the shared output directory.
+    void regenerate();
+    // Watch the config file's parent directory and filter by filename.
+    // Watching the file itself is unreliable across editors that perform
+    // atomic-save (delete + rename) — the watcher loses its target once the
+    // inode changes. Directory watches survive those transitions.
+    // Canonicalize to the real long path so `fs.watch` doesn't abort on Windows
+    // short-path dirs. See `canonicalizeWatchDir`.
+    const configDir = canonicalizeWatchDir(dirname(configPath));
+    const watchFilenames = new Set([
+        basename(configPath),
+        ...extraWatchFilenames ?? []
+    ]);
+    let debounceTimer;
+    const onEvent = (_event, filename)=>{
+        if (!filename) return;
+        const name = typeof filename === 'string' ? filename : filename.toString('utf8');
+        if (!watchFilenames.has(name)) return;
+        clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(()=>{
+            void regenerate();
+        }, DEBOUNCE_MS);
+    };
+    const watcher = watch(configDir, onEvent);
+    watcher.on('error', (err)=>{
+        devDebug('Config watcher error: %O', err);
+        output.warn(`Manifest watcher error: ${err instanceof Error ? err.message : String(err)}`);
+    });
+    return {
+        // Idempotent — a repeat close (e.g. a signal handler racing an explicit
+        // close) is a no-op, so we never clear an already-cleared timer or
+        // double-close the underlying watcher.
+        close: async ()=>{
+            if (closed) return;
+            closed = true;
+            clearTimeout(debounceTimer);
+            watcher.close();
+        }
+    };
+}
+
+//# sourceMappingURL=startDevManifestWatcher.js.map

package/dist/actions/dev/startDevManifestWatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/dev/startDevManifestWatcher.ts"],"sourcesContent":["import {watch} from 'node:fs'\nimport {basename, dirname} from 'node:path'\n\nimport {findProjectRoot, type Output, subdebug} from '@sanity/cli-core'\n\nimport {canonicalizeWatchDir} from './canonicalizeWatchDir.js'\nimport {type DevServerInterface} from './deriveInterfaces.js'\n\nconst devDebug = subdebug('dev')\n\n/**\n * Debounce window between config file events and the next manifest\n * regeneration. Coalesces rapid saves (e.g. editor auto-save) and\n * atomic-rename bursts emitted by tools like VS Code.\n */\nconst DEBOUNCE_MS = 250\n\ninterface DevManifestWatcher {\n  close: () => Promise<void>\n}\n\n/** Subset of registry fields the watcher is allowed to update. */\ninterface ManifestPatch<T> {\n  manifest: T | undefined\n  manifestUpdatedAt: string\n\n  /**\n   * Workbench interfaces (views/services/app view) re-derived from the config\n   * on each change, so editing `views`/`services`/`entry` in `sanity.cli.ts`\n   * re-syncs live like `title`/`icon`. `undefined` only for\n   * non-branded configs — the registry patch is a shallow merge, so extractors\n   * must re-derive rather than omit, or the registered set gets wiped.\n   */\n  interfaces?: DevServerInterface[] | undefined\n}\n\ninterface StartDevManifestWatcherOptions<T> {\n  /**\n   * Run the project-specific extraction and resolve to the inlined manifest\n   * plus the workbench `interfaces[]` (when the project declares them).\n   * Receives the resolved config path (e.g. `sanity.config.ts` for studios,\n   * `sanity.cli.ts` for core-apps) and the working directory.\n   */\n  extract: (params: {\n    configPath: string\n    workDir: string\n  }) => Promise<{interfaces?: DevServerInterface[] | undefined; manifest: T | undefined}>\n  output: Output\n  /**\n   * Called after every successful extraction with the inlined manifest +\n   * interfaces. Awaited, so an interface-set change can rebuild the federation\n   * remote before the registry is patched (which is what reloads the workbench).\n   */\n  update: (patch: ManifestPatch<T>) => Promise<void> | void\n  workDir: string\n\n  /**\n   * Extra config filenames (basenames in the project root directory) that also\n   * trigger a regeneration. Studios resolve their project root via\n   * `sanity.config.*` but declare workbench interfaces in `sanity.cli.*`, so\n   * their watcher needs to react to both files.\n   */\n  extraWatchFilenames?: readonly string[]\n}\n\n/**\n * Generate the project manifest once and then keep it in sync with the\n * project's config file (`sanity.config.(ts|js)` for studios,\n * `sanity.cli.(ts|js)` for core-apps) on disk. The initial generation runs\n * fire-and-forget so it doesn't block dev-server startup; subsequent\n * file-system events are coalesced behind it, so the extractor never has\n * overlapping writes to its shared output directory. Each successful\n * regeneration inlines the new manifest into the registry via the `update`\n * callback, so any running workbench rebroadcasts to its clients.\n *\n * Errors during extraction are logged as warnings and do not crash the dev\n * server — the previously extracted manifest (if any) stays in the\n * registry.\n */\nexport async function startDevManifestWatcher<T>({\n  extract,\n  extraWatchFilenames,\n  output,\n  update,\n  workDir,\n}: StartDevManifestWatcherOptions<T>): Promise<DevManifestWatcher> {\n  const projectRoot = await findProjectRoot(workDir)\n  const configPath = projectRoot.path\n\n  let running = false\n  let pending = false\n  let closed = false\n\n  const regenerate = async () => {\n    if (closed) return\n    if (running) {\n      pending = true\n      return\n    }\n    running = true\n    try {\n      const {interfaces, manifest} = await extract({configPath, workDir})\n      if (closed) return\n      await update({interfaces, manifest, manifestUpdatedAt: new Date().toISOString()})\n    } catch (err) {\n      // Extractors print their own spinner failure; log the reason here so\n      // the user sees what went wrong alongside the spinner indicator.\n      devDebug('Manifest regeneration failed: %O', err)\n      output.warn(\n        `Could not extract manifest for workbench: ${err instanceof Error ? err.message : String(err)}`,\n      )\n    } finally {\n      running = false\n      if (pending && !closed) {\n        pending = false\n        void regenerate()\n      }\n    }\n  }\n\n  // Route the initial extraction through `regenerate` too, so file-system\n  // events arriving before it finishes get coalesced rather than racing it\n  // for the shared output directory.\n  void regenerate()\n\n  // Watch the config file's parent directory and filter by filename.\n  // Watching the file itself is unreliable across editors that perform\n  // atomic-save (delete + rename) — the watcher loses its target once the\n  // inode changes. Directory watches survive those transitions.\n  // Canonicalize to the real long path so `fs.watch` doesn't abort on Windows\n  // short-path dirs. See `canonicalizeWatchDir`.\n  const configDir = canonicalizeWatchDir(dirname(configPath))\n  const watchFilenames = new Set([basename(configPath), ...(extraWatchFilenames ?? [])])\n\n  let debounceTimer: ReturnType<typeof setTimeout> | undefined\n\n  const onEvent = (_event: string, filename: Buffer | string | null) => {\n    if (!filename) return\n    const name = typeof filename === 'string' ? filename : filename.toString('utf8')\n    if (!watchFilenames.has(name)) return\n    clearTimeout(debounceTimer)\n    debounceTimer = setTimeout(() => {\n      void regenerate()\n    }, DEBOUNCE_MS)\n  }\n\n  const watcher = watch(configDir, onEvent)\n\n  watcher.on('error', (err) => {\n    devDebug('Config watcher error: %O', err)\n    output.warn(`Manifest watcher error: ${err instanceof Error ? err.message : String(err)}`)\n  })\n\n  return {\n    // Idempotent — a repeat close (e.g. a signal handler racing an explicit\n    // close) is a no-op, so we never clear an already-cleared timer or\n    // double-close the underlying watcher.\n    close: async () => {\n      if (closed) return\n      closed = true\n      clearTimeout(debounceTimer)\n      watcher.close()\n    },\n  }\n}\n"],"names":["watch","basename","dirname","findProjectRoot","subdebug","canonicalizeWatchDir","devDebug","DEBOUNCE_MS","startDevManifestWatcher","extract","extraWatchFilenames","output","update","workDir","projectRoot","configPath","path","running","pending","closed","regenerate","interfaces","manifest","manifestUpdatedAt","Date","toISOString","err","warn","Error","message","String","configDir","watchFilenames","Set","debounceTimer","onEvent","_event","filename","name","toString","has","clearTimeout","setTimeout","watcher","on","close"],"mappings":"AAAA,SAAQA,KAAK,QAAO,UAAS;AAC7B,SAAQC,QAAQ,EAAEC,OAAO,QAAO,YAAW;AAE3C,SAAQC,eAAe,EAAeC,QAAQ,QAAO,mBAAkB;AAEvE,SAAQC,oBAAoB,QAAO,4BAA2B;AAG9D,MAAMC,WAAWF,SAAS;AAE1B;;;;CAIC,GACD,MAAMG,cAAc;AAkDpB;;;;;;;;;;;;;CAaC,GACD,OAAO,eAAeC,wBAA2B,EAC/CC,OAAO,EACPC,mBAAmB,EACnBC,MAAM,EACNC,MAAM,EACNC,OAAO,EAC2B;IAClC,MAAMC,cAAc,MAAMX,gBAAgBU;IAC1C,MAAME,aAAaD,YAAYE,IAAI;IAEnC,IAAIC,UAAU;IACd,IAAIC,UAAU;IACd,IAAIC,SAAS;IAEb,MAAMC,aAAa;QACjB,IAAID,QAAQ;QACZ,IAAIF,SAAS;YACXC,UAAU;YACV;QACF;QACAD,UAAU;QACV,IAAI;YACF,MAAM,EAACI,UAAU,EAAEC,QAAQ,EAAC,GAAG,MAAMb,QAAQ;gBAACM;gBAAYF;YAAO;YACjE,IAAIM,QAAQ;YACZ,MAAMP,OAAO;gBAACS;gBAAYC;gBAAUC,mBAAmB,IAAIC,OAAOC,WAAW;YAAE;QACjF,EAAE,OAAOC,KAAK;YACZ,qEAAqE;YACrE,iEAAiE;YACjEpB,SAAS,oCAAoCoB;YAC7Cf,OAAOgB,IAAI,CACT,CAAC,0CAA0C,EAAED,eAAeE,QAAQF,IAAIG,OAAO,GAAGC,OAAOJ,MAAM;QAEnG,SAAU;YACRT,UAAU;YACV,IAAIC,WAAW,CAACC,QAAQ;gBACtBD,UAAU;gBACV,KAAKE;YACP;QACF;IACF;IAEA,wEAAwE;IACxE,yEAAyE;IACzE,mCAAmC;IACnC,KAAKA;IAEL,mEAAmE;IACnE,qEAAqE;IACrE,wEAAwE;IACxE,8DAA8D;IAC9D,4EAA4E;IAC5E,+CAA+C;IAC/C,MAAMW,YAAY1B,qBAAqBH,QAAQa;IAC/C,MAAMiB,iBAAiB,IAAIC,IAAI;QAAChC,SAASc;WAAiBL,uBAAuB,EAAE;KAAE;IAErF,IAAIwB;IAEJ,MAAMC,UAAU,CAACC,QAAgBC;QAC/B,IAAI,CAACA,UAAU;QACf,MAAMC,OAAO,OAAOD,aAAa,WAAWA,WAAWA,SAASE,QAAQ,CAAC;QACzE,IAAI,CAACP,eAAeQ,GAAG,CAACF,OAAO;QAC/BG,aAAaP;QACbA,gBAAgBQ,WAAW;YACzB,KAAKtB;QACP,GAAGb;IACL;IAEA,MAAMoC,UAAU3C,MAAM+B,WAAWI;IAEjCQ,QAAQC,EAAE,CAAC,SAAS,CAAClB;QACnBpB,SAAS,4BAA4BoB;QACrCf,OAAOgB,IAAI,CAAC,CAAC,wBAAwB,EAAED,eAAeE,QAAQF,IAAIG,OAAO,GAAGC,OAAOJ,MAAM;IAC3F;IAEA,OAAO;QACL,wEAAwE;QACxE,mEAAmE;QACnE,uCAAuC;QACvCmB,OAAO;YACL,IAAI1B,QAAQ;YACZA,SAAS;YACTsB,aAAaP;YACbS,QAAQE,KAAK;QACf;IACF;AACF"}

package/dist/actions/dev/startDevServerRegistration.js

@@ -0,0 +1,78 @@
+import { getCliConfigUncached } from '@sanity/cli-core';
+import { deriveInterfaces } from './deriveInterfaces.js';
+import { trackInterfaceSet } from './interfaceSetId.js';
+import { registerDevServer } from './registry.js';
+import { startDevManifestWatcher } from './startDevManifestWatcher.js';
+/** The address the server actually bound — the live socket, which can differ from the configured port under non-strict ports. */ function serverAddress(server) {
+    const resolvedHost = server.config.server.host;
+    const addr = server.httpServer?.address();
+    return {
+        host: typeof resolvedHost === 'string' ? resolvedHost : 'localhost',
+        port: typeof addr === 'object' && addr ? addr.port : server.config.server.port
+    };
+}
+/**
+ * Register the dev server in the registry and watch its config for manifest +
+ * interface changes. The workbench reads the entry to locate and render the
+ * server; the watcher keeps it current as `sanity.cli.ts` is edited.
+ */ export async function startDevServerRegistration(options) {
+    const { appId, cliConfig, extractManifest, isApp, onInterfaceSetChange, output, server, workDir } = options;
+    const { host: appHost, port: appPort } = serverAddress(server);
+    // Forwarded alongside (not inside) the manifest so the workbench renders local
+    // panels/workers without a deploy; the watcher re-derives them on each edit.
+    const interfaces = deriveInterfaces(cliConfig.app, {
+        isApp
+    });
+    const registration = registerDevServer({
+        host: appHost,
+        id: appId,
+        interfaces,
+        port: appPort,
+        projectId: cliConfig?.api?.projectId,
+        type: isApp ? 'coreApp' : 'studio',
+        workDir
+    });
+    const interfaceSet = trackInterfaceSet(interfaces);
+    const watcher = await startDevManifestWatcher({
+        // Re-derive interfaces every pass (don't omit): the registry patch is a
+        // shallow merge, so omitting would wipe the registered set.
+        extract: async (params)=>({
+                interfaces: deriveInterfaces((await getCliConfigUncached(params.workDir)).app, {
+                    isApp
+                }),
+                manifest: await extractManifest(params)
+            }),
+        // A studio's root resolves to `sanity.config.*` but its interfaces live in
+        // `sanity.cli.*` — watch that too. Apps already root at `sanity.cli.*`.
+        extraWatchFilenames: isApp ? undefined : [
+            'sanity.cli.js',
+            'sanity.cli.ts'
+        ],
+        output,
+        update: async (patch)=>{
+            if (!interfaceSet.changed(patch.interfaces)) {
+                registration.update(patch);
+                return;
+            }
+            // Rebuild the remote *before* patching the registry — the patch reloads the
+            // page, which must re-fetch a remote that already exposes the new interface.
+            const rebuiltServer = await onInterfaceSetChange?.();
+            // Commit only after a successful rebuild, so a thrown one retries next pass.
+            interfaceSet.commit(patch.interfaces);
+            // The recreated server can bind a different port (non-strict ports).
+            registration.update(rebuiltServer ? {
+                ...patch,
+                ...serverAddress(rebuiltServer)
+            } : patch);
+        },
+        workDir
+    });
+    return {
+        close: async ()=>{
+            registration.release();
+            await watcher.close();
+        }
+    };
+}
+
+//# sourceMappingURL=startDevServerRegistration.js.map

package/dist/actions/dev/startDevServerRegistration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/dev/startDevServerRegistration.ts"],"sourcesContent":["import {type CliConfig, getCliConfigUncached, type Output} from '@sanity/cli-core'\nimport {type ViteDevServer} from 'vite'\n\nimport {deriveInterfaces} from './deriveInterfaces.js'\nimport {trackInterfaceSet} from './interfaceSetId.js'\nimport {type DevServerManifest, registerDevServer} from './registry.js'\nimport {startDevManifestWatcher} from './startDevManifestWatcher.js'\n\ninterface DevServerRegistrationOptions {\n  /** Resolved app id for the registry entry; the caller owns id resolution and the deprecation check. */\n  appId: string | undefined\n  cliConfig: CliConfig\n  /**\n   * Extract the project manifest to inline into the registry. The caller owns the\n   * studio-vs-app split (manifest formats are CLI-domain); registration re-derives\n   * the interface set alongside it.\n   */\n  extractManifest: (params: {\n    configPath: string\n    workDir: string\n  }) => Promise<DevServerManifest['manifest']>\n  isApp: boolean\n  output: Output\n  server: ViteDevServer\n  workDir: string\n\n  /**\n   * Rebuild the app's federation remote when its interface set changes, awaited\n   * *before* the registry patch — the patch reloads the workbench page, which must\n   * re-fetch a remote that already exposes the new interface. Resolves with the\n   * recreated server so the entry gets its actual address (non-strict ports may\n   * shift it); must reject if the restart produces no server, so the set stays\n   * uncommitted and the next save retries instead of advertising a dead port.\n   */\n  onInterfaceSetChange?: () => Promise<ViteDevServer>\n}\n\ninterface DevServerRegistrationHandle {\n  close: () => Promise<void>\n}\n\n/** The address the server actually bound — the live socket, which can differ from the configured port under non-strict ports. */\nfunction serverAddress(server: ViteDevServer) {\n  const resolvedHost = server.config.server.host\n  const addr = server.httpServer?.address()\n  return {\n    host: typeof resolvedHost === 'string' ? resolvedHost : 'localhost',\n    port: typeof addr === 'object' && addr ? addr.port : server.config.server.port,\n  }\n}\n\n/**\n * Register the dev server in the registry and watch its config for manifest +\n * interface changes. The workbench reads the entry to locate and render the\n * server; the watcher keeps it current as `sanity.cli.ts` is edited.\n */\nexport async function startDevServerRegistration(\n  options: DevServerRegistrationOptions,\n): Promise<DevServerRegistrationHandle> {\n  const {appId, cliConfig, extractManifest, isApp, onInterfaceSetChange, output, server, workDir} =\n    options\n\n  const {host: appHost, port: appPort} = serverAddress(server)\n\n  // Forwarded alongside (not inside) the manifest so the workbench renders local\n  // panels/workers without a deploy; the watcher re-derives them on each edit.\n  const interfaces = deriveInterfaces(cliConfig.app, {isApp})\n\n  const registration = registerDevServer({\n    host: appHost,\n    id: appId,\n    interfaces,\n    port: appPort,\n    projectId: cliConfig?.api?.projectId,\n    type: isApp ? 'coreApp' : 'studio',\n    workDir,\n  })\n\n  const interfaceSet = trackInterfaceSet(interfaces)\n\n  const watcher = await startDevManifestWatcher({\n    // Re-derive interfaces every pass (don't omit): the registry patch is a\n    // shallow merge, so omitting would wipe the registered set.\n    extract: async (params) => ({\n      interfaces: deriveInterfaces((await getCliConfigUncached(params.workDir)).app, {isApp}),\n      manifest: await extractManifest(params),\n    }),\n    // A studio's root resolves to `sanity.config.*` but its interfaces live in\n    // `sanity.cli.*` — watch that too. Apps already root at `sanity.cli.*`.\n    extraWatchFilenames: isApp ? undefined : ['sanity.cli.js', 'sanity.cli.ts'],\n    output,\n    update: async (patch) => {\n      if (!interfaceSet.changed(patch.interfaces)) {\n        registration.update(patch)\n        return\n      }\n      // Rebuild the remote *before* patching the registry — the patch reloads the\n      // page, which must re-fetch a remote that already exposes the new interface.\n      const rebuiltServer = await onInterfaceSetChange?.()\n      // Commit only after a successful rebuild, so a thrown one retries next pass.\n      interfaceSet.commit(patch.interfaces)\n      // The recreated server can bind a different port (non-strict ports).\n      registration.update(rebuiltServer ? {...patch, ...serverAddress(rebuiltServer)} : patch)\n    },\n    workDir,\n  })\n\n  return {\n    close: async () => {\n      registration.release()\n      await watcher.close()\n    },\n  }\n}\n"],"names":["getCliConfigUncached","deriveInterfaces","trackInterfaceSet","registerDevServer","startDevManifestWatcher","serverAddress","server","resolvedHost","config","host","addr","httpServer","address","port","startDevServerRegistration","options","appId","cliConfig","extractManifest","isApp","onInterfaceSetChange","output","workDir","appHost","appPort","interfaces","app","registration","id","projectId","api","type","interfaceSet","watcher","extract","params","manifest","extraWatchFilenames","undefined","update","patch","changed","rebuiltServer","commit","close","release"],"mappings":"AAAA,SAAwBA,oBAAoB,QAAoB,mBAAkB;AAGlF,SAAQC,gBAAgB,QAAO,wBAAuB;AACtD,SAAQC,iBAAiB,QAAO,sBAAqB;AACrD,SAAgCC,iBAAiB,QAAO,gBAAe;AACvE,SAAQC,uBAAuB,QAAO,+BAA8B;AAmCpE,+HAA+H,GAC/H,SAASC,cAAcC,MAAqB;IAC1C,MAAMC,eAAeD,OAAOE,MAAM,CAACF,MAAM,CAACG,IAAI;IAC9C,MAAMC,OAAOJ,OAAOK,UAAU,EAAEC;IAChC,OAAO;QACLH,MAAM,OAAOF,iBAAiB,WAAWA,eAAe;QACxDM,MAAM,OAAOH,SAAS,YAAYA,OAAOA,KAAKG,IAAI,GAAGP,OAAOE,MAAM,CAACF,MAAM,CAACO,IAAI;IAChF;AACF;AAEA;;;;CAIC,GACD,OAAO,eAAeC,2BACpBC,OAAqC;IAErC,MAAM,EAACC,KAAK,EAAEC,SAAS,EAAEC,eAAe,EAAEC,KAAK,EAAEC,oBAAoB,EAAEC,MAAM,EAAEf,MAAM,EAAEgB,OAAO,EAAC,GAC7FP;IAEF,MAAM,EAACN,MAAMc,OAAO,EAAEV,MAAMW,OAAO,EAAC,GAAGnB,cAAcC;IAErD,+EAA+E;IAC/E,6EAA6E;IAC7E,MAAMmB,aAAaxB,iBAAiBgB,UAAUS,GAAG,EAAE;QAACP;IAAK;IAEzD,MAAMQ,eAAexB,kBAAkB;QACrCM,MAAMc;QACNK,IAAIZ;QACJS;QACAZ,MAAMW;QACNK,WAAWZ,WAAWa,KAAKD;QAC3BE,MAAMZ,QAAQ,YAAY;QAC1BG;IACF;IAEA,MAAMU,eAAe9B,kBAAkBuB;IAEvC,MAAMQ,UAAU,MAAM7B,wBAAwB;QAC5C,wEAAwE;QACxE,4DAA4D;QAC5D8B,SAAS,OAAOC,SAAY,CAAA;gBAC1BV,YAAYxB,iBAAiB,AAAC,CAAA,MAAMD,qBAAqBmC,OAAOb,OAAO,CAAA,EAAGI,GAAG,EAAE;oBAACP;gBAAK;gBACrFiB,UAAU,MAAMlB,gBAAgBiB;YAClC,CAAA;QACA,2EAA2E;QAC3E,wEAAwE;QACxEE,qBAAqBlB,QAAQmB,YAAY;YAAC;YAAiB;SAAgB;QAC3EjB;QACAkB,QAAQ,OAAOC;YACb,IAAI,CAACR,aAAaS,OAAO,CAACD,MAAMf,UAAU,GAAG;gBAC3CE,aAAaY,MAAM,CAACC;gBACpB;YACF;YACA,4EAA4E;YAC5E,6EAA6E;YAC7E,MAAME,gBAAgB,MAAMtB;YAC5B,6EAA6E;YAC7EY,aAAaW,MAAM,CAACH,MAAMf,UAAU;YACpC,qEAAqE;YACrEE,aAAaY,MAAM,CAACG,gBAAgB;gBAAC,GAAGF,KAAK;gBAAE,GAAGnC,cAAcqC,cAAc;YAAA,IAAIF;QACpF;QACAlB;IACF;IAEA,OAAO;QACLsB,OAAO;YACLjB,aAAakB,OAAO;YACpB,MAAMZ,QAAQW,KAAK;QACrB;IACF;AACF"}