@sanity/cli-core 0.0.0-20260410130107

package/dist/util/environment/getStudioEnvironmentVariables.js

@@ -0,0 +1,36 @@
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { moduleResolve } from 'import-meta-resolve';
+import { doImport } from '../doImport.js';
+/**
+ * Loads the `getStudioEnvironmentVariables` function from the studio's
+ * installed `sanity` package and returns the environment variables.
+ *
+ * This is used to ensure we're using the same version of environment variable
+ * logic as the studio itself.
+ *
+ * @param rootPath - The root path of the Sanity Studio project
+ * @returns Object containing studio environment variables
+ * @internal
+ */ export async function getStudioEnvironmentVariables(rootPath) {
+    // Create a fake config URL - doesn't have to be correct, just need the root path
+    const fakeConfigUrl = pathToFileURL(resolve(rootPath, 'sanity.config.mjs'));
+    // Load `getStudioEnvironmentVariables` from the `sanity/cli` module installed
+    // relative to where the studio is located, instead of resolving from where this CLI is
+    // running, in order to ensure we're using the same version as the studio would.
+    const sanityCliUrl = moduleResolve('sanity/cli', fakeConfigUrl);
+    try {
+        const { getStudioEnvironmentVariables: getEnvVars } = await doImport(sanityCliUrl.href);
+        if (typeof getEnvVars !== 'function') {
+            throw new TypeError('Expected `getStudioEnvironmentVariables` from `sanity/cli` to be a function');
+        }
+        return getEnvVars(rootPath);
+    } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to import getStudioEnvironmentVariables from sanity/cli module: ${message}`, {
+            cause: err
+        });
+    }
+}
+
+//# sourceMappingURL=getStudioEnvironmentVariables.js.map

package/dist/util/environment/getStudioEnvironmentVariables.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/environment/getStudioEnvironmentVariables.ts"],"sourcesContent":["import {resolve} from 'node:path'\nimport {pathToFileURL} from 'node:url'\n\nimport {moduleResolve} from 'import-meta-resolve'\n\nimport {doImport} from '../doImport.js'\n\n/**\n * Loads the `getStudioEnvironmentVariables` function from the studio's\n * installed `sanity` package and returns the environment variables.\n *\n * This is used to ensure we're using the same version of environment variable\n * logic as the studio itself.\n *\n * @param rootPath - The root path of the Sanity Studio project\n * @returns Object containing studio environment variables\n * @internal\n */\nexport async function getStudioEnvironmentVariables(\n  rootPath: string,\n): Promise<Record<string, string>> {\n  // Create a fake config URL - doesn't have to be correct, just need the root path\n  const fakeConfigUrl = pathToFileURL(resolve(rootPath, 'sanity.config.mjs'))\n\n  // Load `getStudioEnvironmentVariables` from the `sanity/cli` module installed\n  // relative to where the studio is located, instead of resolving from where this CLI is\n  // running, in order to ensure we're using the same version as the studio would.\n  const sanityCliUrl = moduleResolve('sanity/cli', fakeConfigUrl)\n  try {\n    const {getStudioEnvironmentVariables: getEnvVars} = await doImport(sanityCliUrl.href)\n    if (typeof getEnvVars !== 'function') {\n      throw new TypeError(\n        'Expected `getStudioEnvironmentVariables` from `sanity/cli` to be a function',\n      )\n    }\n    return getEnvVars(rootPath)\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err)\n    throw new Error(\n      `Failed to import getStudioEnvironmentVariables from sanity/cli module: ${message}`,\n      {cause: err},\n    )\n  }\n}\n"],"names":["resolve","pathToFileURL","moduleResolve","doImport","getStudioEnvironmentVariables","rootPath","fakeConfigUrl","sanityCliUrl","getEnvVars","href","TypeError","err","message","Error","String","cause"],"mappings":"AAAA,SAAQA,OAAO,QAAO,YAAW;AACjC,SAAQC,aAAa,QAAO,WAAU;AAEtC,SAAQC,aAAa,QAAO,sBAAqB;AAEjD,SAAQC,QAAQ,QAAO,iBAAgB;AAEvC;;;;;;;;;;CAUC,GACD,OAAO,eAAeC,8BACpBC,QAAgB;IAEhB,iFAAiF;IACjF,MAAMC,gBAAgBL,cAAcD,QAAQK,UAAU;IAEtD,8EAA8E;IAC9E,uFAAuF;IACvF,gFAAgF;IAChF,MAAME,eAAeL,cAAc,cAAcI;IACjD,IAAI;QACF,MAAM,EAACF,+BAA+BI,UAAU,EAAC,GAAG,MAAML,SAASI,aAAaE,IAAI;QACpF,IAAI,OAAOD,eAAe,YAAY;YACpC,MAAM,IAAIE,UACR;QAEJ;QACA,OAAOF,WAAWH;IACpB,EAAE,OAAOM,KAAK;QACZ,MAAMC,UAAUD,eAAeE,QAAQF,IAAIC,OAAO,GAAGE,OAAOH;QAC5D,MAAM,IAAIE,MACR,CAAC,uEAAuE,EAAED,SAAS,EACnF;YAACG,OAAOJ;QAAG;IAEf;AACF"}

package/dist/util/environment/mockBrowserEnvironment.js

@@ -0,0 +1,47 @@
+// TODO(SDK-983): Consider moving to @sanity/cli — only used there
+import { getStudioEnvironmentVariables } from './getStudioEnvironmentVariables.js';
+import { setupBrowserStubs } from './setupBrowserStubs.js';
+/**
+ * Mocks a browser-like environment for processes in the main thread by:
+ * - Injecting browser globals (window, document, ResizeObserver, etc.)
+ * - Loading studio environment variables from the project's sanity installation into process.env
+ *
+ * This is useful for commands like `sanity exec` that have to run user scripts
+ * in the main thread of the process (but in a child process).
+ *
+ * Be cautious when using this, since it will pollute the global namespace with browser globals.
+ *
+ * If your code can run in a worker thread, you should use the `studioWorkerTask` function instead.
+ *
+ * @param basePath - The root path of the Sanity Studio project
+ * @returns A cleanup function that removes the injected globals and environment variables
+ * @internal
+ */ export async function mockBrowserEnvironment(basePath) {
+    // 1. Setup browser globals
+    const cleanupBrowserStubs = await setupBrowserStubs();
+    // 2. Load and set environment variables into process.env
+    const envVars = await getStudioEnvironmentVariables(basePath);
+    const setEnvKeys = [];
+    const originalEnvValues = {};
+    for (const [key, value] of Object.entries(envVars)){
+        // Store original value (if any) so we can restore it
+        originalEnvValues[key] = process.env[key];
+        process.env[key] = value;
+        setEnvKeys.push(key);
+    }
+    // Return cleanup function
+    return ()=>{
+        // Restore or delete environment variables
+        for (const key of setEnvKeys){
+            if (originalEnvValues[key] === undefined) {
+                delete process.env[key];
+            } else {
+                process.env[key] = originalEnvValues[key];
+            }
+        }
+        // Clean up browser stubs
+        cleanupBrowserStubs();
+    };
+}
+
+//# sourceMappingURL=mockBrowserEnvironment.js.map

package/dist/util/environment/mockBrowserEnvironment.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/environment/mockBrowserEnvironment.ts"],"sourcesContent":["// TODO(SDK-983): Consider moving to @sanity/cli — only used there\nimport {getStudioEnvironmentVariables} from './getStudioEnvironmentVariables.js'\nimport {setupBrowserStubs} from './setupBrowserStubs.js'\n\n/**\n * Mocks a browser-like environment for processes in the main thread by:\n * - Injecting browser globals (window, document, ResizeObserver, etc.)\n * - Loading studio environment variables from the project's sanity installation into process.env\n *\n * This is useful for commands like `sanity exec` that have to run user scripts\n * in the main thread of the process (but in a child process).\n *\n * Be cautious when using this, since it will pollute the global namespace with browser globals.\n *\n * If your code can run in a worker thread, you should use the `studioWorkerTask` function instead.\n *\n * @param basePath - The root path of the Sanity Studio project\n * @returns A cleanup function that removes the injected globals and environment variables\n * @internal\n */\nexport async function mockBrowserEnvironment(basePath: string): Promise<() => void> {\n  // 1. Setup browser globals\n  const cleanupBrowserStubs = await setupBrowserStubs()\n\n  // 2. Load and set environment variables into process.env\n  const envVars = await getStudioEnvironmentVariables(basePath)\n  const setEnvKeys: string[] = []\n  const originalEnvValues: Record<string, string | undefined> = {}\n\n  for (const [key, value] of Object.entries(envVars)) {\n    // Store original value (if any) so we can restore it\n    originalEnvValues[key] = process.env[key]\n    process.env[key] = value\n    setEnvKeys.push(key)\n  }\n\n  // Return cleanup function\n  return () => {\n    // Restore or delete environment variables\n    for (const key of setEnvKeys) {\n      if (originalEnvValues[key] === undefined) {\n        delete process.env[key]\n      } else {\n        process.env[key] = originalEnvValues[key]\n      }\n    }\n\n    // Clean up browser stubs\n    cleanupBrowserStubs()\n  }\n}\n"],"names":["getStudioEnvironmentVariables","setupBrowserStubs","mockBrowserEnvironment","basePath","cleanupBrowserStubs","envVars","setEnvKeys","originalEnvValues","key","value","Object","entries","process","env","push","undefined"],"mappings":"AAAA,kEAAkE;AAClE,SAAQA,6BAA6B,QAAO,qCAAoC;AAChF,SAAQC,iBAAiB,QAAO,yBAAwB;AAExD;;;;;;;;;;;;;;;CAeC,GACD,OAAO,eAAeC,uBAAuBC,QAAgB;IAC3D,2BAA2B;IAC3B,MAAMC,sBAAsB,MAAMH;IAElC,yDAAyD;IACzD,MAAMI,UAAU,MAAML,8BAA8BG;IACpD,MAAMG,aAAuB,EAAE;IAC/B,MAAMC,oBAAwD,CAAC;IAE/D,KAAK,MAAM,CAACC,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACN,SAAU;QAClD,qDAAqD;QACrDE,iBAAiB,CAACC,IAAI,GAAGI,QAAQC,GAAG,CAACL,IAAI;QACzCI,QAAQC,GAAG,CAACL,IAAI,GAAGC;QACnBH,WAAWQ,IAAI,CAACN;IAClB;IAEA,0BAA0B;IAC1B,OAAO;QACL,0CAA0C;QAC1C,KAAK,MAAMA,OAAOF,WAAY;YAC5B,IAAIC,iBAAiB,CAACC,IAAI,KAAKO,WAAW;gBACxC,OAAOH,QAAQC,GAAG,CAACL,IAAI;YACzB,OAAO;gBACLI,QAAQC,GAAG,CAACL,IAAI,GAAGD,iBAAiB,CAACC,IAAI;YAC3C;QACF;QAEA,yBAAyB;QACzBJ;IACF;AACF"}

package/dist/util/environment/setupBrowserStubs.js

@@ -0,0 +1,42 @@
+import { getBrowserStubs } from './stubs.js';
+/**
+ * Sets up browser globals (window, document, etc.) in the global scope.
+ *
+ * This is used by both mockBrowserEnvironment (for child processes) and
+ * studioWorkerLoader (for worker threads) to provide a browser-like environment.
+ *
+ * @returns A cleanup function that removes the injected globals
+ * @internal
+ */ export async function setupBrowserStubs() {
+    // Guard against double-registering
+    if (globalThis.window && '__mockedBySanity' in globalThis.window) {
+        return ()=>{
+        /* intentional noop - already mocked */ };
+    }
+    // Inject browser stubs into global scope
+    const stubs = getBrowserStubs();
+    const mockedGlobalThis = globalThis;
+    const stubbedKeys = [];
+    for (const key of Object.keys(stubs)){
+        if (key in mockedGlobalThis) continue;
+        mockedGlobalThis[key] = stubs[key];
+        stubbedKeys.push(key);
+    }
+    // Add marker to window to detect double-mocking
+    if (globalThis.window) {
+        ;
+        globalThis.window.__mockedBySanity = true;
+    }
+    // Return cleanup function
+    return ()=>{
+        // Remove marker before deleting window
+        if (globalThis.window) {
+            delete globalThis.window.__mockedBySanity;
+        }
+        for (const key of stubbedKeys){
+            delete mockedGlobalThis[key];
+        }
+    };
+}
+
+//# sourceMappingURL=setupBrowserStubs.js.map

package/dist/util/environment/setupBrowserStubs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/environment/setupBrowserStubs.ts"],"sourcesContent":["import {getBrowserStubs} from './stubs.js'\n\n/**\n * Sets up browser globals (window, document, etc.) in the global scope.\n *\n * This is used by both mockBrowserEnvironment (for child processes) and\n * studioWorkerLoader (for worker threads) to provide a browser-like environment.\n *\n * @returns A cleanup function that removes the injected globals\n * @internal\n */\nexport async function setupBrowserStubs(): Promise<() => void> {\n  // Guard against double-registering\n  if (globalThis.window && '__mockedBySanity' in globalThis.window) {\n    return () => {\n      /* intentional noop - already mocked */\n    }\n  }\n\n  // Inject browser stubs into global scope\n  const stubs = getBrowserStubs()\n  const mockedGlobalThis: Record<string, unknown> = globalThis\n  const stubbedKeys: string[] = []\n\n  for (const key of Object.keys(stubs)) {\n    if (key in mockedGlobalThis) continue\n    mockedGlobalThis[key] = stubs[key]\n    stubbedKeys.push(key)\n  }\n\n  // Add marker to window to detect double-mocking\n  if (globalThis.window) {\n    ;(globalThis.window as unknown as Record<string, unknown>).__mockedBySanity = true\n  }\n\n  // Return cleanup function\n  return () => {\n    // Remove marker before deleting window\n    if (globalThis.window) {\n      delete (globalThis.window as unknown as Record<string, unknown>).__mockedBySanity\n    }\n\n    for (const key of stubbedKeys) {\n      delete mockedGlobalThis[key]\n    }\n  }\n}\n"],"names":["getBrowserStubs","setupBrowserStubs","globalThis","window","stubs","mockedGlobalThis","stubbedKeys","key","Object","keys","push","__mockedBySanity"],"mappings":"AAAA,SAAQA,eAAe,QAAO,aAAY;AAE1C;;;;;;;;CAQC,GACD,OAAO,eAAeC;IACpB,mCAAmC;IACnC,IAAIC,WAAWC,MAAM,IAAI,sBAAsBD,WAAWC,MAAM,EAAE;QAChE,OAAO;QACL,qCAAqC,GACvC;IACF;IAEA,yCAAyC;IACzC,MAAMC,QAAQJ;IACd,MAAMK,mBAA4CH;IAClD,MAAMI,cAAwB,EAAE;IAEhC,KAAK,MAAMC,OAAOC,OAAOC,IAAI,CAACL,OAAQ;QACpC,IAAIG,OAAOF,kBAAkB;QAC7BA,gBAAgB,CAACE,IAAI,GAAGH,KAAK,CAACG,IAAI;QAClCD,YAAYI,IAAI,CAACH;IACnB;IAEA,gDAAgD;IAChD,IAAIL,WAAWC,MAAM,EAAE;;QACnBD,WAAWC,MAAM,CAAwCQ,gBAAgB,GAAG;IAChF;IAEA,0BAA0B;IAC1B,OAAO;QACL,uCAAuC;QACvC,IAAIT,WAAWC,MAAM,EAAE;YACrB,OAAO,AAACD,WAAWC,MAAM,CAAwCQ,gBAAgB;QACnF;QAEA,KAAK,MAAMJ,OAAOD,YAAa;YAC7B,OAAOD,gBAAgB,CAACE,IAAI;QAC9B;IACF;AACF"}

package/dist/util/environment/stubs.js

@@ -0,0 +1,142 @@
+import { JSDOM } from 'jsdom';
+const html = `<!doctype html>
+<html>
+  <head><meta charset="utf-8"></head>
+  <body></body>
+</html>`;
+function isAbortSignalLike(value) {
+    return !!value && typeof value === 'object' && 'aborted' in value && typeof value.aborted === 'boolean' && 'addEventListener' in value && typeof value.addEventListener === 'function' && 'removeEventListener' in value && typeof value.removeEventListener === 'function';
+}
+/**
+ * Make JSDOM's `addEventListener({signal})` accept native Node.js AbortSignals.
+ *
+ * JSDOM validates `signal` using its own realm's `AbortSignal` constructor, which rejects
+ * Node's native signal. Instead of replacing the global Abort APIs, intercept those calls
+ * and emulate the abortable-listener behavior for cross-realm signals.
+ */ function patchEventTargetSignalSupport(dom) {
+    const eventTarget = dom.window.EventTarget;
+    const addEventListener = eventTarget.prototype.addEventListener;
+    eventTarget.prototype.addEventListener = function addEventListenerPatched(type, listener, options) {
+        if (typeof options === 'boolean' || !options?.signal) {
+            return addEventListener.call(this, type, listener, options);
+        }
+        const rawSignal = options.signal;
+        const isJSDOMSignal = rawSignal instanceof dom.window.AbortSignal;
+        if (!rawSignal || isJSDOMSignal || !isAbortSignalLike(rawSignal)) {
+            return addEventListener.call(this, type, listener, options);
+        }
+        const signal = rawSignal;
+        if (signal.aborted) {
+            return;
+        }
+        const { signal: _signal, ...optionsWithoutSignal } = options;
+        addEventListener.call(this, type, listener, optionsWithoutSignal);
+        const removeOnAbort = ()=>{
+            this.removeEventListener(type, listener, options);
+        };
+        signal.addEventListener('abort', removeOnAbort, {
+            once: true
+        });
+    };
+}
+/**
+ * Creates a JSDOM instance and applies polyfills for missing browser globals.
+ */ function createBrowserDom() {
+    const dom = new JSDOM(html, {
+        pretendToBeVisual: true,
+        url: 'http://localhost:3333/'
+    });
+    patchEventTargetSignalSupport(dom);
+    // Special handling of certain globals
+    if (typeof dom.window.document.execCommand !== 'function') {
+        // Crashes ace editor without this :/
+        dom.window.document.execCommand = function execCommand(// Provide the right arity for the function, even if unused
+        _commandName, _showDefaultUI, _valueArgument) {
+            // Return false to indicate "unsupported"
+            return false;
+        };
+    }
+    if (dom.window.requestIdleCallback === undefined) {
+        dom.window.requestIdleCallback = (cb)=>setTimeout(cb, 10);
+    }
+    if (dom.window.cancelIdleCallback === undefined) {
+        dom.window.cancelIdleCallback = (id)=>clearTimeout(id);
+    }
+    if (dom.window.ResizeObserver === undefined) {
+        dom.window.ResizeObserver = class ResizeObserver {
+            // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+            constructor(_callback){}
+            disconnect() {}
+            observe(_target, _options) {}
+            unobserve(_target) {}
+        };
+    }
+    if (dom.window.IntersectionObserver === undefined) {
+        dom.window.IntersectionObserver = class IntersectionObserver {
+            options;
+            constructor(_callback, options){
+                this.options = options || {};
+            }
+            get root() {
+                return this.options.root || null;
+            }
+            get rootMargin() {
+                return this.options.rootMargin || '';
+            }
+            get thresholds() {
+                return Array.isArray(this.options.threshold) ? this.options.threshold : [
+                    this.options.threshold || 0
+                ];
+            }
+            disconnect() {}
+            observe(_el) {}
+            takeRecords() {
+                return [];
+            }
+            unobserve(_el) {}
+        };
+    }
+    if (dom.window.matchMedia === undefined) {
+        dom.window.matchMedia = (_qs)=>({
+                matches: false,
+                media: '',
+                onchange: null
+            });
+    }
+    return dom;
+}
+/**
+ * Collects all browser globals from the JSDOM window that should be injected
+ * into the Node.js global scope to emulate a browser environment.
+ *
+ * This dynamically iterates over all own properties of the JSDOM window,
+ * skipping internal JSDOM properties (prefixed with `_`) and properties that
+ * already exist in Node.js globals to avoid conflicts.
+ *
+ * This approach ensures that any new properties added by JSDOM upgrades are
+ * automatically included, preventing "missing global" bugs (e.g. `Element`,
+ * `HTMLElement`, `SVGElement` needed by libraries like styled-components).
+ */ function collectBrowserStubs() {
+    const dom = createBrowserDom();
+    const stubs = Object.create(null);
+    const nodeGlobals = new Set(Object.getOwnPropertyNames(globalThis));
+    for (const key of Object.getOwnPropertyNames(dom.window)){
+        // Skip internal JSDOM properties
+        if (key.startsWith('_')) continue;
+        // Skip numeric indices (e.g. '0' for window[0])
+        if (/^\d+$/.test(key)) continue;
+        // Skip properties that Node.js already provides to avoid conflicts
+        if (nodeGlobals.has(key)) continue;
+        stubs[key] = dom.window[key];
+    }
+    return stubs;
+}
+let browserStubs;
+export function getBrowserStubs() {
+    if (!browserStubs) {
+        browserStubs = collectBrowserStubs();
+    }
+    return browserStubs;
+}
+
+//# sourceMappingURL=stubs.js.map

package/dist/util/environment/stubs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/environment/stubs.ts"],"sourcesContent":["import {JSDOM} from 'jsdom'\n\nconst html = `<!doctype html>\n<html>\n  <head><meta charset=\"utf-8\"></head>\n  <body></body>\n</html>`\n\ninterface AbortSignalLike {\n  aborted: boolean\n  addEventListener(type: 'abort', listener: () => void, options?: {once?: boolean}): void\n  removeEventListener(type: 'abort', listener: () => void): void\n}\n\ntype EventListenerOptionsWithSignal = AddEventListenerOptions & {signal?: unknown}\n\nfunction isAbortSignalLike(value: unknown): value is AbortSignalLike {\n  return (\n    !!value &&\n    typeof value === 'object' &&\n    'aborted' in value &&\n    typeof (value as AbortSignalLike).aborted === 'boolean' &&\n    'addEventListener' in value &&\n    typeof (value as AbortSignalLike).addEventListener === 'function' &&\n    'removeEventListener' in value &&\n    typeof (value as AbortSignalLike).removeEventListener === 'function'\n  )\n}\n\n/**\n * Make JSDOM's `addEventListener({signal})` accept native Node.js AbortSignals.\n *\n * JSDOM validates `signal` using its own realm's `AbortSignal` constructor, which rejects\n * Node's native signal. Instead of replacing the global Abort APIs, intercept those calls\n * and emulate the abortable-listener behavior for cross-realm signals.\n */\nfunction patchEventTargetSignalSupport(dom: JSDOM): void {\n  const eventTarget = dom.window.EventTarget\n  const addEventListener = eventTarget.prototype.addEventListener\n\n  eventTarget.prototype.addEventListener = function addEventListenerPatched(\n    type: string,\n    listener: EventListenerOrEventListenerObject | null,\n    options?: AddEventListenerOptions | boolean,\n  ) {\n    if (typeof options === 'boolean' || !options?.signal) {\n      return addEventListener.call(this, type, listener, options)\n    }\n\n    const rawSignal = (options as EventListenerOptionsWithSignal).signal\n    const isJSDOMSignal = rawSignal instanceof (dom.window.AbortSignal as typeof AbortSignal)\n    if (!rawSignal || isJSDOMSignal || !isAbortSignalLike(rawSignal)) {\n      return addEventListener.call(this, type, listener, options)\n    }\n\n    const signal: AbortSignalLike = rawSignal\n    if (signal.aborted) {\n      return\n    }\n\n    const {signal: _signal, ...optionsWithoutSignal} = options as EventListenerOptionsWithSignal\n    addEventListener.call(this, type, listener, optionsWithoutSignal)\n\n    const removeOnAbort = () => {\n      this.removeEventListener(type, listener, options)\n    }\n\n    signal.addEventListener('abort', removeOnAbort, {once: true})\n  }\n}\n\n/**\n * Creates a JSDOM instance and applies polyfills for missing browser globals.\n */\nfunction createBrowserDom(): JSDOM {\n  const dom = new JSDOM(html, {\n    pretendToBeVisual: true,\n    url: 'http://localhost:3333/',\n  })\n\n  patchEventTargetSignalSupport(dom)\n\n  // Special handling of certain globals\n  if (typeof dom.window.document.execCommand !== 'function') {\n    // Crashes ace editor without this :/\n    dom.window.document.execCommand = function execCommand(\n      // Provide the right arity for the function, even if unused\n      _commandName: string,\n      _showDefaultUI: boolean,\n      _valueArgument: unknown,\n    ) {\n      // Return false to indicate \"unsupported\"\n      return false\n    }\n  }\n\n  if (dom.window.requestIdleCallback === undefined) {\n    dom.window.requestIdleCallback = (cb: IdleRequestCallback) => setTimeout(cb, 10)\n  }\n\n  if (dom.window.cancelIdleCallback === undefined) {\n    dom.window.cancelIdleCallback = (id: number) => clearTimeout(id)\n  }\n\n  if (dom.window.ResizeObserver === undefined) {\n    dom.window.ResizeObserver = class ResizeObserver {\n      // eslint-disable-next-line @typescript-eslint/no-useless-constructor\n      constructor(_callback: unknown) {}\n      disconnect() {}\n      observe(_target: unknown, _options: unknown) {}\n      unobserve(_target: unknown) {}\n    }\n  }\n\n  if (dom.window.IntersectionObserver === undefined) {\n    dom.window.IntersectionObserver = class IntersectionObserver {\n      options: {root?: unknown; rootMargin?: string; threshold?: number}\n      constructor(\n        _callback: unknown,\n        options?: {root?: unknown; rootMargin?: string; threshold?: number},\n      ) {\n        this.options = options || {}\n      }\n      get root() {\n        return this.options.root || null\n      }\n      get rootMargin() {\n        return this.options.rootMargin || ''\n      }\n      get thresholds() {\n        return Array.isArray(this.options.threshold)\n          ? this.options.threshold\n          : [this.options.threshold || 0]\n      }\n\n      disconnect() {}\n      observe(_el: unknown) {}\n      takeRecords() {\n        return []\n      }\n      unobserve(_el: unknown) {}\n    }\n  }\n\n  if (dom.window.matchMedia === undefined) {\n    dom.window.matchMedia = (_qs: unknown) =>\n      ({\n        matches: false,\n        media: '',\n        onchange: null,\n      }) as MediaQueryList\n  }\n\n  return dom\n}\n\n/**\n * Collects all browser globals from the JSDOM window that should be injected\n * into the Node.js global scope to emulate a browser environment.\n *\n * This dynamically iterates over all own properties of the JSDOM window,\n * skipping internal JSDOM properties (prefixed with `_`) and properties that\n * already exist in Node.js globals to avoid conflicts.\n *\n * This approach ensures that any new properties added by JSDOM upgrades are\n * automatically included, preventing \"missing global\" bugs (e.g. `Element`,\n * `HTMLElement`, `SVGElement` needed by libraries like styled-components).\n */\nfunction collectBrowserStubs(): Record<string, unknown> {\n  const dom = createBrowserDom()\n  const stubs: Record<string, unknown> = Object.create(null)\n  const nodeGlobals = new Set(Object.getOwnPropertyNames(globalThis))\n\n  for (const key of Object.getOwnPropertyNames(dom.window)) {\n    // Skip internal JSDOM properties\n    if (key.startsWith('_')) continue\n\n    // Skip numeric indices (e.g. '0' for window[0])\n    if (/^\\d+$/.test(key)) continue\n\n    // Skip properties that Node.js already provides to avoid conflicts\n    if (nodeGlobals.has(key)) continue\n\n    stubs[key] = (dom.window as Record<string, unknown>)[key]\n  }\n\n  return stubs\n}\n\nlet browserStubs: Record<string, unknown> | undefined\n\nexport function getBrowserStubs(): Record<string, unknown> {\n  if (!browserStubs) {\n    browserStubs = collectBrowserStubs()\n  }\n  return browserStubs\n}\n"],"names":["JSDOM","html","isAbortSignalLike","value","aborted","addEventListener","removeEventListener","patchEventTargetSignalSupport","dom","eventTarget","window","EventTarget","prototype","addEventListenerPatched","type","listener","options","signal","call","rawSignal","isJSDOMSignal","AbortSignal","_signal","optionsWithoutSignal","removeOnAbort","once","createBrowserDom","pretendToBeVisual","url","document","execCommand","_commandName","_showDefaultUI","_valueArgument","requestIdleCallback","undefined","cb","setTimeout","cancelIdleCallback","id","clearTimeout","ResizeObserver","_callback","disconnect","observe","_target","_options","unobserve","IntersectionObserver","root","rootMargin","thresholds","Array","isArray","threshold","_el","takeRecords","matchMedia","_qs","matches","media","onchange","collectBrowserStubs","stubs","Object","create","nodeGlobals","Set","getOwnPropertyNames","globalThis","key","startsWith","test","has","browserStubs","getBrowserStubs"],"mappings":"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"}

package/dist/util/fileExists.js

@@ -0,0 +1,13 @@
+import { access } from 'node:fs/promises';
+/**
+ * Checks if a file exists and can be "accessed".
+ * Prone to race conditions, but good enough for our use cases.
+ *
+ * @param filePath - The path to the file to check
+ * @returns A promise that resolves to true if the file exists, false otherwise
+ * @internal
+ */ export function fileExists(filePath) {
+    return access(filePath).then(()=>true, ()=>false);
+}
+
+//# sourceMappingURL=fileExists.js.map

package/dist/util/fileExists.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/fileExists.ts"],"sourcesContent":["import {access} from 'node:fs/promises'\n\n/**\n * Checks if a file exists and can be \"accessed\".\n * Prone to race conditions, but good enough for our use cases.\n *\n * @param filePath - The path to the file to check\n * @returns A promise that resolves to true if the file exists, false otherwise\n * @internal\n */\nexport function fileExists(filePath: string): Promise<boolean> {\n  return access(filePath).then(\n    () => true,\n    () => false,\n  )\n}\n"],"names":["access","fileExists","filePath","then"],"mappings":"AAAA,SAAQA,MAAM,QAAO,mBAAkB;AAEvC;;;;;;;CAOC,GACD,OAAO,SAASC,WAAWC,QAAgB;IACzC,OAAOF,OAAOE,UAAUC,IAAI,CAC1B,IAAM,MACN,IAAM;AAEV"}

package/dist/util/generateHelpUrl.js

@@ -0,0 +1,11 @@
+/**
+ * Generate a help URL for the given slug
+ *
+ * @param slug - The slug to generate a help URL for
+ * @returns The generated help URL
+ * @internal
+ */ export function generateHelpUrl(slug) {
+    return `https://www.sanity.io/help/${slug}`;
+}
+
+//# sourceMappingURL=generateHelpUrl.js.map

package/dist/util/generateHelpUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/generateHelpUrl.ts"],"sourcesContent":["/**\n * Generate a help URL for the given slug\n *\n * @param slug - The slug to generate a help URL for\n * @returns The generated help URL\n * @internal\n */\nexport function generateHelpUrl(slug: string): string {\n  return `https://www.sanity.io/help/${slug}`\n}\n"],"names":["generateHelpUrl","slug"],"mappings":"AAAA;;;;;;CAMC,GACD,OAAO,SAASA,gBAAgBC,IAAY;IAC1C,OAAO,CAAC,2BAA2B,EAAEA,MAAM;AAC7C"}

package/dist/util/getEmptyAuth.js

@@ -0,0 +1,16 @@
+import { createClient } from '@sanity/client';
+export function getEmptyAuth() {
+    return {
+        authenticated: false,
+        client: createClient({
+            apiHost: 'http://localhost',
+            apiVersion: '2025-02-01',
+            projectId: 'unused',
+            requestTagPrefix: 'sanity.cli',
+            useCdn: false
+        }),
+        currentUser: null
+    };
+}
+
+//# sourceMappingURL=getEmptyAuth.js.map

package/dist/util/getEmptyAuth.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/getEmptyAuth.ts"],"sourcesContent":["import {createClient} from '@sanity/client'\n\nexport function getEmptyAuth() {\n  return {\n    authenticated: false,\n    client: createClient({\n      apiHost: 'http://localhost',\n      apiVersion: '2025-02-01',\n      projectId: 'unused',\n      requestTagPrefix: 'sanity.cli',\n      useCdn: false,\n    }),\n    currentUser: null,\n  }\n}\n"],"names":["createClient","getEmptyAuth","authenticated","client","apiHost","apiVersion","projectId","requestTagPrefix","useCdn","currentUser"],"mappings":"AAAA,SAAQA,YAAY,QAAO,iBAAgB;AAE3C,OAAO,SAASC;IACd,OAAO;QACLC,eAAe;QACfC,QAAQH,aAAa;YACnBI,SAAS;YACTC,YAAY;YACZC,WAAW;YACXC,kBAAkB;YAClBC,QAAQ;QACV;QACAC,aAAa;IACf;AACF"}

package/dist/util/getSanityEnvVar.js

@@ -0,0 +1,24 @@
+/**
+ * Gets an environment variable with the appropriate Sanity prefix based on whether it's an app or studio.
+ *
+ * @param suffix - The suffix for the environment variable (e.g., 'SERVER_HOSTNAME')
+ * @param isApp - Whether to use the app prefix (SANITY_APP_) or studio prefix (SANITY_STUDIO_)
+ * @returns The value of the environment variable, or undefined if not set
+ *
+ * @example
+ * ```ts
+ * // For studio: SANITY_STUDIO_SERVER_HOSTNAME
+ * const studioHostname = getSanityEnvVar('SERVER_HOSTNAME', false)
+ *
+ * // For app: SANITY_APP_SERVER_HOSTNAME
+ * const appHostname = getSanityEnvVar('SERVER_HOSTNAME', true)
+ * ```
+ *
+ * @internal
+ */ export function getSanityEnvVar(suffix, isApp) {
+    const prefix = isApp ? 'SANITY_APP_' : 'SANITY_STUDIO_';
+    const envVarName = `${prefix}${suffix}`;
+    return process.env[envVarName];
+}
+
+//# sourceMappingURL=getSanityEnvVar.js.map

package/dist/util/getSanityEnvVar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/getSanityEnvVar.ts"],"sourcesContent":["/**\n * Gets an environment variable with the appropriate Sanity prefix based on whether it's an app or studio.\n *\n * @param suffix - The suffix for the environment variable (e.g., 'SERVER_HOSTNAME')\n * @param isApp - Whether to use the app prefix (SANITY_APP_) or studio prefix (SANITY_STUDIO_)\n * @returns The value of the environment variable, or undefined if not set\n *\n * @example\n * ```ts\n * // For studio: SANITY_STUDIO_SERVER_HOSTNAME\n * const studioHostname = getSanityEnvVar('SERVER_HOSTNAME', false)\n *\n * // For app: SANITY_APP_SERVER_HOSTNAME\n * const appHostname = getSanityEnvVar('SERVER_HOSTNAME', true)\n * ```\n *\n * @internal\n */\nexport function getSanityEnvVar(suffix: string, isApp: boolean): string | undefined {\n  const prefix = isApp ? 'SANITY_APP_' : 'SANITY_STUDIO_'\n  const envVarName = `${prefix}${suffix}`\n  return process.env[envVarName]\n}\n"],"names":["getSanityEnvVar","suffix","isApp","prefix","envVarName","process","env"],"mappings":"AAAA;;;;;;;;;;;;;;;;;CAiBC,GACD,OAAO,SAASA,gBAAgBC,MAAc,EAAEC,KAAc;IAC5D,MAAMC,SAASD,QAAQ,gBAAgB;IACvC,MAAME,aAAa,GAAGD,SAASF,QAAQ;IACvC,OAAOI,QAAQC,GAAG,CAACF,WAAW;AAChC"}

package/dist/util/getSanityUrl.js

@@ -0,0 +1,9 @@
+/**
+ * @internal
+ * @returns The Sanity URL for the given path, using the correct domain based on the environment
+ */ export function getSanityUrl(path = '/') {
+    const domain = process.env.SANITY_INTERNAL_ENV === 'staging' ? 'https://www.sanity.work' : 'https://www.sanity.io';
+    return `${domain}${path.startsWith('/') ? path : `/${path}`}`;
+}
+
+//# sourceMappingURL=getSanityUrl.js.map

package/dist/util/getSanityUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/getSanityUrl.ts"],"sourcesContent":["/**\n * @internal\n * @returns The Sanity URL for the given path, using the correct domain based on the environment\n */\nexport function getSanityUrl(path = '/') {\n  const domain =\n    process.env.SANITY_INTERNAL_ENV === 'staging'\n      ? 'https://www.sanity.work'\n      : 'https://www.sanity.io'\n  return `${domain}${path.startsWith('/') ? path : `/${path}`}`\n}\n"],"names":["getSanityUrl","path","domain","process","env","SANITY_INTERNAL_ENV","startsWith"],"mappings":"AAAA;;;CAGC,GACD,OAAO,SAASA,aAAaC,OAAO,GAAG;IACrC,MAAMC,SACJC,QAAQC,GAAG,CAACC,mBAAmB,KAAK,YAChC,4BACA;IACN,OAAO,GAAGH,SAASD,KAAKK,UAAU,CAAC,OAAOL,OAAO,CAAC,CAAC,EAAEA,MAAM,EAAE;AAC/D"}

package/dist/util/importModule.js

@@ -0,0 +1,32 @@
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createJiti } from '@rexxars/jiti';
+import { subdebug } from '../debug.js';
+const debug = subdebug('importModule');
+/**
+ * Imports a module using jiti and returns its exports.
+ * This is a thin wrapper around tsx to allow swapping out the underlying implementation in the future if needed.
+ *
+ * @param filePath - Path to the module to import.
+ * @param options - Options for the importModule function.
+ * @returns The exported module.
+ *
+ * @internal
+ */ export async function importModule(filePath, options = {}) {
+    const { default: returnDefault = true, tsconfigPath } = options;
+    const jiti = createJiti(import.meta.url, {
+        debug: debug.enabled,
+        tsconfigPaths: typeof tsconfigPath === 'string' ? tsconfigPath : true
+    });
+    const fileURL = typeof filePath === 'string' ? pathToFileURL(filePath) : filePath;
+    debug(`Loading module: ${fileURLToPath(fileURL)}`, {
+        tsconfigPath
+    });
+    const jitiOptions = {};
+    // If the default option is true, add it to the jiti options
+    if (returnDefault) {
+        jitiOptions.default = true;
+    }
+    return jiti.import(fileURLToPath(fileURL), jitiOptions);
+}
+
+//# sourceMappingURL=importModule.js.map

package/dist/util/importModule.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/importModule.ts"],"sourcesContent":["import {fileURLToPath, pathToFileURL} from 'node:url'\n\nimport {createJiti, type JitiResolveOptions} from '@rexxars/jiti'\n\nimport {subdebug} from '../debug.js'\n\ninterface ImportModuleOptions {\n  /**\n   * Whether to return the default export of the module.\n   * Default: true\n   */\n  default?: boolean\n\n  /**\n   * Path to the tsconfig file to use for the import. If not provided, the tsconfig\n   * will be inferred from the nearest `tsconfig.json` file.\n   */\n  tsconfigPath?: string\n}\n\nconst debug = subdebug('importModule')\n\n/**\n * Imports a module using jiti and returns its exports.\n * This is a thin wrapper around tsx to allow swapping out the underlying implementation in the future if needed.\n *\n * @param filePath - Path to the module to import.\n * @param options - Options for the importModule function.\n * @returns The exported module.\n *\n * @internal\n */\nexport async function importModule<T = unknown>(\n  filePath: string | URL,\n  options: ImportModuleOptions = {},\n): Promise<T> {\n  const {default: returnDefault = true, tsconfigPath} = options\n\n  const jiti = createJiti(import.meta.url, {\n    debug: debug.enabled,\n    tsconfigPaths: typeof tsconfigPath === 'string' ? tsconfigPath : true,\n  })\n\n  const fileURL = typeof filePath === 'string' ? pathToFileURL(filePath) : filePath\n\n  debug(`Loading module: ${fileURLToPath(fileURL)}`, {tsconfigPath})\n\n  const jitiOptions: JitiResolveOptions & {default?: true} = {}\n\n  // If the default option is true, add it to the jiti options\n  if (returnDefault) {\n    jitiOptions.default = true\n  }\n\n  return jiti.import<T>(fileURLToPath(fileURL), jitiOptions)\n}\n"],"names":["fileURLToPath","pathToFileURL","createJiti","subdebug","debug","importModule","filePath","options","default","returnDefault","tsconfigPath","jiti","url","enabled","tsconfigPaths","fileURL","jitiOptions","import"],"mappings":"AAAA,SAAQA,aAAa,EAAEC,aAAa,QAAO,WAAU;AAErD,SAAQC,UAAU,QAAgC,gBAAe;AAEjE,SAAQC,QAAQ,QAAO,cAAa;AAgBpC,MAAMC,QAAQD,SAAS;AAEvB;;;;;;;;;CASC,GACD,OAAO,eAAeE,aACpBC,QAAsB,EACtBC,UAA+B,CAAC,CAAC;IAEjC,MAAM,EAACC,SAASC,gBAAgB,IAAI,EAAEC,YAAY,EAAC,GAAGH;IAEtD,MAAMI,OAAOT,WAAW,YAAYU,GAAG,EAAE;QACvCR,OAAOA,MAAMS,OAAO;QACpBC,eAAe,OAAOJ,iBAAiB,WAAWA,eAAe;IACnE;IAEA,MAAMK,UAAU,OAAOT,aAAa,WAAWL,cAAcK,YAAYA;IAEzEF,MAAM,CAAC,gBAAgB,EAAEJ,cAAce,UAAU,EAAE;QAACL;IAAY;IAEhE,MAAMM,cAAqD,CAAC;IAE5D,4DAA4D;IAC5D,IAAIP,eAAe;QACjBO,YAAYR,OAAO,GAAG;IACxB;IAEA,OAAOG,KAAKM,MAAM,CAAIjB,cAAce,UAAUC;AAChD"}

package/dist/util/isCi.js

@@ -0,0 +1,7 @@
+import { isTrueish } from './isTrueish.js';
+export const isCi = ()=>isTrueish(process.env.CI) || // Travis CI, CircleCI, Gitlab CI, Appveyor, CodeShip
+    isTrueish(process.env.CONTINUOUS_INTEGRATION) || // Travis CI
+    isTrueish(process.env.BUILD_NUMBER) // Jenkins, TeamCity
+;
+
+//# sourceMappingURL=isCi.js.map

package/dist/util/isCi.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/isCi.ts"],"sourcesContent":["import {isTrueish} from './isTrueish.js'\n\nexport const isCi = (): boolean =>\n  isTrueish(process.env.CI) || // Travis CI, CircleCI, Gitlab CI, Appveyor, CodeShip\n  isTrueish(process.env.CONTINUOUS_INTEGRATION) || // Travis CI\n  isTrueish(process.env.BUILD_NUMBER) // Jenkins, TeamCity\n"],"names":["isTrueish","isCi","process","env","CI","CONTINUOUS_INTEGRATION","BUILD_NUMBER"],"mappings":"AAAA,SAAQA,SAAS,QAAO,iBAAgB;AAExC,OAAO,MAAMC,OAAO,IAClBD,UAAUE,QAAQC,GAAG,CAACC,EAAE,KAAK,qDAAqD;IAClFJ,UAAUE,QAAQC,GAAG,CAACE,sBAAsB,KAAK,YAAY;IAC7DL,UAAUE,QAAQC,GAAG,CAACG,YAAY,EAAE,oBAAoB;CAArB"}

package/dist/util/isInteractive.js

@@ -0,0 +1,5 @@
+export function isInteractive() {
+    return Boolean(process.stdin.isTTY) && process.env.TERM !== 'dumb' && !('CI' in process.env);
+}
+
+//# sourceMappingURL=isInteractive.js.map

package/dist/util/isInteractive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/isInteractive.ts"],"sourcesContent":["export function isInteractive(): boolean {\n  return Boolean(process.stdin.isTTY) && process.env.TERM !== 'dumb' && !('CI' in process.env)\n}\n"],"names":["isInteractive","Boolean","process","stdin","isTTY","env","TERM"],"mappings":"AAAA,OAAO,SAASA;IACd,OAAOC,QAAQC,QAAQC,KAAK,CAACC,KAAK,KAAKF,QAAQG,GAAG,CAACC,IAAI,KAAK,UAAU,CAAE,CAAA,QAAQJ,QAAQG,GAAG,AAAD;AAC5F"}

package/dist/util/isRecord.js

@@ -0,0 +1,11 @@
+/**
+ * Checks if the given value is a record (javascript objectish)
+ *
+ * @param value - Value to check
+ * @returns True if the value is a record, false otherwise
+ * @internal
+ */ export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+//# sourceMappingURL=isRecord.js.map

package/dist/util/isRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/isRecord.ts"],"sourcesContent":["/**\n * Checks if the given value is a record (javascript objectish)\n *\n * @param value - Value to check\n * @returns True if the value is a record, false otherwise\n * @internal\n */\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n"],"names":["isRecord","value","Array","isArray"],"mappings":"AAAA;;;;;;CAMC,GACD,OAAO,SAASA,SAASC,KAAc;IACrC,OAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,CAACC,MAAMC,OAAO,CAACF;AACvE"}

package/dist/util/isStaging.js

@@ -0,0 +1,10 @@
+/**
+ * Checks if the environment is staging.
+ *
+ * @returns True if the environment is staging, false otherwise
+ * @internal
+ */ export function isStaging() {
+    return process.env.SANITY_INTERNAL_ENV === 'staging';
+}
+
+//# sourceMappingURL=isStaging.js.map

package/dist/util/isStaging.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/isStaging.ts"],"sourcesContent":["/**\n * Checks if the environment is staging.\n *\n * @returns True if the environment is staging, false otherwise\n * @internal\n */\nexport function isStaging(): boolean {\n  return process.env.SANITY_INTERNAL_ENV === 'staging'\n}\n"],"names":["isStaging","process","env","SANITY_INTERNAL_ENV"],"mappings":"AAAA;;;;;CAKC,GACD,OAAO,SAASA;IACd,OAAOC,QAAQC,GAAG,CAACC,mBAAmB,KAAK;AAC7C"}

package/dist/util/isTrueish.js

@@ -0,0 +1,10 @@
+export function isTrueish(value) {
+    if (value === undefined) return false;
+    if (value.toLowerCase() === 'true') return true;
+    if (value.toLowerCase() === 'false') return false;
+    const number = Number.parseInt(value, 10);
+    if (Number.isNaN(number)) return false;
+    return number > 0;
+}
+
+//# sourceMappingURL=isTrueish.js.map

package/dist/util/isTrueish.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/isTrueish.ts"],"sourcesContent":["export function isTrueish(value: string | undefined) {\n  if (value === undefined) return false\n  if (value.toLowerCase() === 'true') return true\n  if (value.toLowerCase() === 'false') return false\n  const number = Number.parseInt(value, 10)\n  if (Number.isNaN(number)) return false\n  return number > 0\n}\n"],"names":["isTrueish","value","undefined","toLowerCase","number","Number","parseInt","isNaN"],"mappings":"AAAA,OAAO,SAASA,UAAUC,KAAyB;IACjD,IAAIA,UAAUC,WAAW,OAAO;IAChC,IAAID,MAAME,WAAW,OAAO,QAAQ,OAAO;IAC3C,IAAIF,MAAME,WAAW,OAAO,SAAS,OAAO;IAC5C,MAAMC,SAASC,OAAOC,QAAQ,CAACL,OAAO;IACtC,IAAII,OAAOE,KAAK,CAACH,SAAS,OAAO;IACjC,OAAOA,SAAS;AAClB"}

package/dist/util/normalizePath.js

@@ -0,0 +1,12 @@
+/**
+ * Normalizes a path for cross-platform comparison by converting backslashes to forward slashes.
+ * Useful for converting windows paths to unix paths.
+ *
+ * @param path - Path to normalize
+ * @returns Normalized path with forward slashes
+ * @public
+ */ export function normalizePath(path) {
+    return path.replaceAll('\\', '/');
+}
+
+//# sourceMappingURL=normalizePath.js.map

package/dist/util/normalizePath.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/normalizePath.ts"],"sourcesContent":["/**\n * Normalizes a path for cross-platform comparison by converting backslashes to forward slashes.\n * Useful for converting windows paths to unix paths.\n *\n * @param path - Path to normalize\n * @returns Normalized path with forward slashes\n * @public\n */\nexport function normalizePath(path: string): string {\n  return path.replaceAll('\\\\', '/')\n}\n"],"names":["normalizePath","path","replaceAll"],"mappings":"AAAA;;;;;;;CAOC,GACD,OAAO,SAASA,cAAcC,IAAY;IACxC,OAAOA,KAAKC,UAAU,CAAC,MAAM;AAC/B"}

package/dist/util/packageManager.js

@@ -0,0 +1,55 @@
+/**
+ * Runtime-detectable package managers (excludes 'manual' which is a UI-only choice).
+ */ /**
+ * Convenience wrapper that reads `process.env.npm_config_user_agent` and returns
+ * the detected package manager.
+ */ export function getRunningPackageManager() {
+    return detectPackageManagerFromAgent();
+}
+/**
+ * Extract the yarn major version from a `npm_config_user_agent` string.
+ *
+ * @param ua - User-agent string. Defaults to `process.env.npm_config_user_agent`.
+ * @returns The major version number, or `undefined` if yarn isn't detected.
+ */ export function getYarnMajorVersion(ua = process.env.npm_config_user_agent ?? '') {
+    const match = ua.match(/yarn\/(\d+)/);
+    return match ? Number.parseInt(match[1], 10) : undefined;
+}
+/**
+ * Return the CLI invocation command for the detected (or provided) package manager.
+ *
+ * @param options - Optional `bin` (defaults to `'sanity'`) and `userAgent` override.
+ * @returns A string like `"npx sanity"`, `"pnpm exec sanity"`, etc.
+ */ export function getBinCommand(options) {
+    const bin = options?.bin ?? 'sanity';
+    const ua = options?.userAgent ?? process.env.npm_config_user_agent ?? '';
+    const pm = detectPackageManagerFromAgent(ua);
+    if (pm === 'npm') return `npx ${bin}`;
+    if (pm === 'pnpm') return `pnpm exec ${bin}`;
+    if (pm === 'bun') return `bunx ${bin}`;
+    if (pm === 'yarn') {
+        const major = getYarnMajorVersion(ua);
+        if (major !== undefined && major >= 2) return `yarn run ${bin}`;
+        return `yarn ${bin}`;
+    }
+    return bin;
+}
+/**
+ * Parse the `npm_config_user_agent` string and return the detected package manager.
+ *
+ * The check order matters: yarn and pnpm set a user-agent that *also* contains
+ * `npm/?`, so we must test for them before falling back to the anchored npm regex.
+ *
+ * @param ua - User-agent string. Defaults to `process.env.npm_config_user_agent`.
+ * @returns The detected package manager, or `undefined` when unrecognisable.
+ */ export function detectPackageManagerFromAgent(ua = process.env.npm_config_user_agent ?? '') {
+    if (ua.includes('pnpm')) return 'pnpm';
+    if (ua.includes('yarn')) return 'yarn';
+    if (ua.includes('bun')) return 'bun';
+    // Anchored regex: yarn/pnpm/bun agents also contain "npm/?" so we require
+    // `npm/` followed by a digit to avoid false positives.
+    if (/^npm\/\d/.test(ua)) return 'npm';
+    return undefined;
+}
+
+//# sourceMappingURL=packageManager.js.map

package/dist/util/packageManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/util/packageManager.ts"],"sourcesContent":["/**\n * Runtime-detectable package managers (excludes 'manual' which is a UI-only choice).\n */\nexport type DetectedPackageManager = 'bun' | 'npm' | 'pnpm' | 'yarn'\n\n/**\n * Convenience wrapper that reads `process.env.npm_config_user_agent` and returns\n * the detected package manager.\n */\nexport function getRunningPackageManager(): DetectedPackageManager | undefined {\n  return detectPackageManagerFromAgent()\n}\n\n/**\n * Extract the yarn major version from a `npm_config_user_agent` string.\n *\n * @param ua - User-agent string. Defaults to `process.env.npm_config_user_agent`.\n * @returns The major version number, or `undefined` if yarn isn't detected.\n */\nexport function getYarnMajorVersion(\n  ua: string = process.env.npm_config_user_agent ?? '',\n): number | undefined {\n  const match = ua.match(/yarn\\/(\\d+)/)\n  return match ? Number.parseInt(match[1], 10) : undefined\n}\n\n/**\n * Return the CLI invocation command for the detected (or provided) package manager.\n *\n * @param options - Optional `bin` (defaults to `'sanity'`) and `userAgent` override.\n * @returns A string like `\"npx sanity\"`, `\"pnpm exec sanity\"`, etc.\n */\nexport function getBinCommand(options?: {bin?: string; userAgent?: string}): string {\n  const bin = options?.bin ?? 'sanity'\n  const ua = options?.userAgent ?? process.env.npm_config_user_agent ?? ''\n  const pm = detectPackageManagerFromAgent(ua)\n\n  if (pm === 'npm') return `npx ${bin}`\n  if (pm === 'pnpm') return `pnpm exec ${bin}`\n  if (pm === 'bun') return `bunx ${bin}`\n  if (pm === 'yarn') {\n    const major = getYarnMajorVersion(ua)\n    if (major !== undefined && major >= 2) return `yarn run ${bin}`\n    return `yarn ${bin}`\n  }\n  return bin\n}\n\n/**\n * Parse the `npm_config_user_agent` string and return the detected package manager.\n *\n * The check order matters: yarn and pnpm set a user-agent that *also* contains\n * `npm/?`, so we must test for them before falling back to the anchored npm regex.\n *\n * @param ua - User-agent string. Defaults to `process.env.npm_config_user_agent`.\n * @returns The detected package manager, or `undefined` when unrecognisable.\n */\nexport function detectPackageManagerFromAgent(\n  ua: string = process.env.npm_config_user_agent ?? '',\n): DetectedPackageManager | undefined {\n  if (ua.includes('pnpm')) return 'pnpm'\n  if (ua.includes('yarn')) return 'yarn'\n  if (ua.includes('bun')) return 'bun'\n  // Anchored regex: yarn/pnpm/bun agents also contain \"npm/?\" so we require\n  // `npm/` followed by a digit to avoid false positives.\n  if (/^npm\\/\\d/.test(ua)) return 'npm'\n  return undefined\n}\n"],"names":["getRunningPackageManager","detectPackageManagerFromAgent","getYarnMajorVersion","ua","process","env","npm_config_user_agent","match","Number","parseInt","undefined","getBinCommand","options","bin","userAgent","pm","major","includes","test"],"mappings":"AAAA;;CAEC,GAGD;;;CAGC,GACD,OAAO,SAASA;IACd,OAAOC;AACT;AAEA;;;;;CAKC,GACD,OAAO,SAASC,oBACdC,KAAaC,QAAQC,GAAG,CAACC,qBAAqB,IAAI,EAAE;IAEpD,MAAMC,QAAQJ,GAAGI,KAAK,CAAC;IACvB,OAAOA,QAAQC,OAAOC,QAAQ,CAACF,KAAK,CAAC,EAAE,EAAE,MAAMG;AACjD;AAEA;;;;;CAKC,GACD,OAAO,SAASC,cAAcC,OAA4C;IACxE,MAAMC,MAAMD,SAASC,OAAO;IAC5B,MAAMV,KAAKS,SAASE,aAAaV,QAAQC,GAAG,CAACC,qBAAqB,IAAI;IACtE,MAAMS,KAAKd,8BAA8BE;IAEzC,IAAIY,OAAO,OAAO,OAAO,CAAC,IAAI,EAAEF,KAAK;IACrC,IAAIE,OAAO,QAAQ,OAAO,CAAC,UAAU,EAAEF,KAAK;IAC5C,IAAIE,OAAO,OAAO,OAAO,CAAC,KAAK,EAAEF,KAAK;IACtC,IAAIE,OAAO,QAAQ;QACjB,MAAMC,QAAQd,oBAAoBC;QAClC,IAAIa,UAAUN,aAAaM,SAAS,GAAG,OAAO,CAAC,SAAS,EAAEH,KAAK;QAC/D,OAAO,CAAC,KAAK,EAAEA,KAAK;IACtB;IACA,OAAOA;AACT;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASZ,8BACdE,KAAaC,QAAQC,GAAG,CAACC,qBAAqB,IAAI,EAAE;IAEpD,IAAIH,GAAGc,QAAQ,CAAC,SAAS,OAAO;IAChC,IAAId,GAAGc,QAAQ,CAAC,SAAS,OAAO;IAChC,IAAId,GAAGc,QAAQ,CAAC,QAAQ,OAAO;IAC/B,0EAA0E;IAC1E,uDAAuD;IACvD,IAAI,WAAWC,IAAI,CAACf,KAAK,OAAO;IAChC,OAAOO;AACT"}