@sanity/cli-core 0.0.0-20260410130107

package/dist/config/util/recursivelyResolveProjectRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/config/util/recursivelyResolveProjectRoot.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path'\n\n/**\n * Result of finding a project configuration\n *\n * @public\n */\nexport interface ProjectRootResult {\n  directory: string\n  /**\n   * Path to the project configuration file, if found.\n   */\n  path: string\n  /**\n   * Type of project root.\n   */\n  type: 'app' | 'studio'\n}\n\n/**\n * Generic recursive search function for project configuration files.\n *\n * @param basePath - The base path to start searching from\n * @param findConfigFn - Function that looks for config files in a given directory\n * @param projectType - The type of project ('app' | 'studio')\n * @param iterations - Current iteration count, passed internally to prevent infinite recursion\n * @returns A promise that resolves to an object if config is found, false otherwise\n * @internal\n */\nexport async function recursivelyResolveProjectRoot(\n  basePath: string,\n  findConfigFn: (path: string) => Promise<string | undefined>,\n  projectType: 'app' | 'studio',\n  iterations = 0,\n): Promise<false | ProjectRootResult> {\n  const configPath = await findConfigFn(basePath)\n\n  if (configPath) {\n    return {\n      directory: dirname(configPath),\n      path: configPath,\n      type: projectType,\n    }\n  }\n\n  const parentDir = resolve(basePath, '..')\n  if (parentDir === basePath || iterations > 50) {\n    // Reached root (or max depth), give up\n    return false\n  }\n\n  return recursivelyResolveProjectRoot(parentDir, findConfigFn, projectType, iterations + 1)\n}\n"],"names":["dirname","resolve","recursivelyResolveProjectRoot","basePath","findConfigFn","projectType","iterations","configPath","directory","path","type","parentDir"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAW;AAmB1C;;;;;;;;;CASC,GACD,OAAO,eAAeC,8BACpBC,QAAgB,EAChBC,YAA2D,EAC3DC,WAA6B,EAC7BC,aAAa,CAAC;IAEd,MAAMC,aAAa,MAAMH,aAAaD;IAEtC,IAAII,YAAY;QACd,OAAO;YACLC,WAAWR,QAAQO;YACnBE,MAAMF;YACNG,MAAML;QACR;IACF;IAEA,MAAMM,YAAYV,QAAQE,UAAU;IACpC,IAAIQ,cAAcR,YAAYG,aAAa,IAAI;QAC7C,uCAAuC;QACvC,OAAO;IACT;IAEA,OAAOJ,8BAA8BS,WAAWP,cAAcC,aAAaC,aAAa;AAC1F"}

package/dist/debug.js

@@ -0,0 +1,15 @@
+import debugIt from 'debug';
+/**
+ * `debug` instance for the CLI
+ *
+ * @internal
+ */ export const debug = debugIt('sanity:cli');
+/**
+ * Get a `debug` instance which extends the CLI debug instance with the given namespace,
+ * eg namespace would be `sanity:cli:<providedNamespace>`
+ *
+ * @param namespace - The namespace to extend the CLI debug instance with
+ * @returns The extended `debug` instance
+ */ export const subdebug = (namespace)=>debug.extend(namespace);
+
+//# sourceMappingURL=debug.js.map

package/dist/debug.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/debug.ts"],"sourcesContent":["import debugIt from 'debug'\n\n/**\n * `debug` instance for the CLI\n *\n * @internal\n */\nexport const debug = debugIt('sanity:cli')\n\n/**\n * Get a `debug` instance which extends the CLI debug instance with the given namespace,\n * eg namespace would be `sanity:cli:<providedNamespace>`\n *\n * @param namespace - The namespace to extend the CLI debug instance with\n * @returns The extended `debug` instance\n */\nexport const subdebug = (namespace: string) => debug.extend(namespace)\n"],"names":["debugIt","debug","subdebug","namespace","extend"],"mappings":"AAAA,OAAOA,aAAa,QAAO;AAE3B;;;;CAIC,GACD,OAAO,MAAMC,QAAQD,QAAQ,cAAa;AAE1C;;;;;;CAMC,GACD,OAAO,MAAME,WAAW,CAACC,YAAsBF,MAAMG,MAAM,CAACD,WAAU"}

package/dist/errors/NonInteractiveError.js

@@ -0,0 +1,18 @@
+import { CLIError } from '@oclif/core/errors';
+/**
+ * Error thrown when a prompt is attempted in a non-interactive environment
+ * (e.g., CI, non-TTY, piped stdin). Callers can catch this specific error
+ * to provide appropriate fallback behavior.
+ *
+ * Extends `CLIError` to suppress stack traces in user-facing output.
+ */ export class NonInteractiveError extends CLIError {
+    constructor(promptName){
+        super(`Cannot run "${promptName}" prompt in a non-interactive environment. ` + 'Provide the required value via flags or environment variables, or run in an interactive terminal.', {
+            code: 'NON_INTERACTIVE',
+            exit: 1
+        });
+        this.name = 'NonInteractiveError';
+    }
+}
+
+//# sourceMappingURL=NonInteractiveError.js.map

package/dist/errors/NonInteractiveError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/errors/NonInteractiveError.ts"],"sourcesContent":["import {CLIError} from '@oclif/core/errors'\n\n/**\n * Error thrown when a prompt is attempted in a non-interactive environment\n * (e.g., CI, non-TTY, piped stdin). Callers can catch this specific error\n * to provide appropriate fallback behavior.\n *\n * Extends `CLIError` to suppress stack traces in user-facing output.\n */\nexport class NonInteractiveError extends CLIError {\n  constructor(promptName: string) {\n    super(\n      `Cannot run \"${promptName}\" prompt in a non-interactive environment. ` +\n        'Provide the required value via flags or environment variables, or run in an interactive terminal.',\n      {code: 'NON_INTERACTIVE', exit: 1},\n    )\n    this.name = 'NonInteractiveError'\n  }\n}\n"],"names":["CLIError","NonInteractiveError","promptName","code","exit","name"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,qBAAoB;AAE3C;;;;;;CAMC,GACD,OAAO,MAAMC,4BAA4BD;IACvC,YAAYE,UAAkB,CAAE;QAC9B,KAAK,CACH,CAAC,YAAY,EAAEA,WAAW,2CAA2C,CAAC,GACpE,qGACF;YAACC,MAAM;YAAmBC,MAAM;QAAC;QAEnC,IAAI,CAACC,IAAI,GAAG;IACd;AACF"}

package/dist/errors/NotFoundError.js

@@ -0,0 +1,27 @@
+import { isRecord } from '../util/isRecord.js';
+/**
+ * Error thrown when a file or directory is not found
+ *
+ * `code` is always `ENOENT` to mirror Node.js behavior when a file is not found
+ *
+ * @internal
+ */ export class NotFoundError extends Error {
+    code = 'ENOENT';
+    path;
+    constructor(message, path){
+        super(message);
+        this.path = path;
+        this.name = 'NotFoundError';
+    }
+}
+/**
+ * Returns whether or not the given error is a `NotFoundError`
+ *
+ * @param err - The error to check
+ * @returns `true` if the error is a `NotFoundError`, `false` otherwise
+ * @internal
+ */ export function isNotFoundError(err) {
+    return isRecord(err) && 'name' in err && err.name === 'NotFoundError' && 'code' in err && err.code === 'ENOENT' && 'message' in err && typeof err.message === 'string';
+}
+
+//# sourceMappingURL=NotFoundError.js.map

package/dist/errors/NotFoundError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/errors/NotFoundError.ts"],"sourcesContent":["import {isRecord} from '../util/isRecord.js'\n\n/**\n * Error thrown when a file or directory is not found\n *\n * `code` is always `ENOENT` to mirror Node.js behavior when a file is not found\n *\n * @internal\n */\nexport class NotFoundError extends Error {\n  code = 'ENOENT'\n  path?: string\n\n  constructor(message: string, path?: string) {\n    super(message)\n    this.path = path\n    this.name = 'NotFoundError'\n  }\n}\n\n/**\n * Returns whether or not the given error is a `NotFoundError`\n *\n * @param err - The error to check\n * @returns `true` if the error is a `NotFoundError`, `false` otherwise\n * @internal\n */\nexport function isNotFoundError(err: unknown): err is NotFoundError {\n  return (\n    isRecord(err) &&\n    'name' in err &&\n    err.name === 'NotFoundError' &&\n    'code' in err &&\n    err.code === 'ENOENT' &&\n    'message' in err &&\n    typeof err.message === 'string'\n  )\n}\n"],"names":["isRecord","NotFoundError","Error","code","path","message","name","isNotFoundError","err"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,sBAAqB;AAE5C;;;;;;CAMC,GACD,OAAO,MAAMC,sBAAsBC;IACjCC,OAAO,SAAQ;IACfC,KAAa;IAEb,YAAYC,OAAe,EAAED,IAAa,CAAE;QAC1C,KAAK,CAACC;QACN,IAAI,CAACD,IAAI,GAAGA;QACZ,IAAI,CAACE,IAAI,GAAG;IACd;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,gBAAgBC,GAAY;IAC1C,OACER,SAASQ,QACT,UAAUA,OACVA,IAAIF,IAAI,KAAK,mBACb,UAAUE,OACVA,IAAIL,IAAI,KAAK,YACb,aAAaK,OACb,OAAOA,IAAIH,OAAO,KAAK;AAE3B"}

package/dist/errors/ProjectRootNotFoundError.js

@@ -0,0 +1,35 @@
+import { CLIError } from '@oclif/core/errors';
+import { isRecord } from '../util/isRecord.js';
+/**
+ * Error thrown when a project root directory cannot be found.
+ *
+ * This occurs when the CLI is run outside a Sanity project directory
+ * (one containing `sanity.config.(ts|js)` or `sanity.cli.(ts|js)`).
+ *
+ * Extends `CLIError` to suppress stack traces in user-facing output.
+ *
+ * @internal
+ */ export class ProjectRootNotFoundError extends CLIError {
+    constructor(message, options){
+        super(message, {
+            code: 'PROJECT_ROOT_NOT_FOUND',
+            exit: 1,
+            suggestions: options?.suggestions
+        });
+        this.name = 'ProjectRootNotFoundError';
+        if (options?.cause) {
+            this.cause = options.cause;
+        }
+    }
+}
+/**
+ * Returns whether or not the given error is a `ProjectRootNotFoundError`
+ *
+ * @param err - The error to check
+ * @returns `true` if the error is a `ProjectRootNotFoundError`, `false` otherwise
+ * @internal
+ */ export function isProjectRootNotFoundError(err) {
+    return isRecord(err) && 'name' in err && err.name === 'ProjectRootNotFoundError' && 'code' in err && err.code === 'PROJECT_ROOT_NOT_FOUND' && 'message' in err && typeof err.message === 'string';
+}
+
+//# sourceMappingURL=ProjectRootNotFoundError.js.map

package/dist/errors/ProjectRootNotFoundError.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/errors/ProjectRootNotFoundError.ts"],"sourcesContent":["import {CLIError} from '@oclif/core/errors'\n\nimport {isRecord} from '../util/isRecord.js'\n\n/**\n * Error thrown when a project root directory cannot be found.\n *\n * This occurs when the CLI is run outside a Sanity project directory\n * (one containing `sanity.config.(ts|js)` or `sanity.cli.(ts|js)`).\n *\n * Extends `CLIError` to suppress stack traces in user-facing output.\n *\n * @internal\n */\nexport class ProjectRootNotFoundError extends CLIError {\n  constructor(message: string, options?: {cause?: Error; suggestions?: string[]}) {\n    super(message, {code: 'PROJECT_ROOT_NOT_FOUND', exit: 1, suggestions: options?.suggestions})\n    this.name = 'ProjectRootNotFoundError'\n    if (options?.cause) {\n      this.cause = options.cause\n    }\n  }\n}\n\n/**\n * Returns whether or not the given error is a `ProjectRootNotFoundError`\n *\n * @param err - The error to check\n * @returns `true` if the error is a `ProjectRootNotFoundError`, `false` otherwise\n * @internal\n */\nexport function isProjectRootNotFoundError(err: unknown): err is ProjectRootNotFoundError {\n  return (\n    isRecord(err) &&\n    'name' in err &&\n    err.name === 'ProjectRootNotFoundError' &&\n    'code' in err &&\n    err.code === 'PROJECT_ROOT_NOT_FOUND' &&\n    'message' in err &&\n    typeof err.message === 'string'\n  )\n}\n"],"names":["CLIError","isRecord","ProjectRootNotFoundError","message","options","code","exit","suggestions","name","cause","isProjectRootNotFoundError","err"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,qBAAoB;AAE3C,SAAQC,QAAQ,QAAO,sBAAqB;AAE5C;;;;;;;;;CASC,GACD,OAAO,MAAMC,iCAAiCF;IAC5C,YAAYG,OAAe,EAAEC,OAAiD,CAAE;QAC9E,KAAK,CAACD,SAAS;YAACE,MAAM;YAA0BC,MAAM;YAAGC,aAAaH,SAASG;QAAW;QAC1F,IAAI,CAACC,IAAI,GAAG;QACZ,IAAIJ,SAASK,OAAO;YAClB,IAAI,CAACA,KAAK,GAAGL,QAAQK,KAAK;QAC5B;IACF;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASC,2BAA2BC,GAAY;IACrD,OACEV,SAASU,QACT,UAAUA,OACVA,IAAIH,IAAI,KAAK,8BACb,UAAUG,OACVA,IAAIN,IAAI,KAAK,4BACb,aAAaM,OACb,OAAOA,IAAIR,OAAO,KAAK;AAE3B"}

package/dist/exitCodes.js

@@ -0,0 +1,17 @@
+/**
+ * Standard exit codes for CLI commands.
+ *
+ * - 0, 1, 2 align with oclif defaults and Unix convention.
+ * - 3 is application-defined (oclif does not use it).
+ * - 130 follows the Unix convention of 128 + signal number (SIGINT = 2).
+ *
+ * @see CLAUDE.md "Exit Code Convention" for usage guidance and examples.
+ */ export const exitCodes = {
+    /** Something went wrong that is not the user's fault (API errors, network, missing config, etc.). */ RUNTIME_ERROR: 1,
+    /** The user interrupted via Ctrl+C (128 + SIGINT). Handled by SanityCommand.catch(). */ SIGINT: 130,
+    /** Command completed normally. */ SUCCESS: 0,
+    /** The user provided invalid input (bad args, unknown flags, validation failures). */ USAGE_ERROR: 2,
+    /** The user declined a confirmation or chose not to proceed. */ USER_ABORT: 3
+};
+
+//# sourceMappingURL=exitCodes.js.map

package/dist/exitCodes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/exitCodes.ts"],"sourcesContent":["/**\n * Standard exit codes for CLI commands.\n *\n * - 0, 1, 2 align with oclif defaults and Unix convention.\n * - 3 is application-defined (oclif does not use it).\n * - 130 follows the Unix convention of 128 + signal number (SIGINT = 2).\n *\n * @see CLAUDE.md \"Exit Code Convention\" for usage guidance and examples.\n */\nexport const exitCodes = {\n  /** Something went wrong that is not the user's fault (API errors, network, missing config, etc.). */\n  RUNTIME_ERROR: 1,\n  /** The user interrupted via Ctrl+C (128 + SIGINT). Handled by SanityCommand.catch(). */\n  SIGINT: 130,\n  /** Command completed normally. */\n  SUCCESS: 0,\n  /** The user provided invalid input (bad args, unknown flags, validation failures). */\n  USAGE_ERROR: 2,\n  /** The user declined a confirmation or chose not to proceed. */\n  USER_ABORT: 3,\n} as const\n"],"names":["exitCodes","RUNTIME_ERROR","SIGINT","SUCCESS","USAGE_ERROR","USER_ABORT"],"mappings":"AAAA;;;;;;;;CAQC,GACD,OAAO,MAAMA,YAAY;IACvB,mGAAmG,GACnGC,eAAe;IACf,sFAAsF,GACtFC,QAAQ;IACR,gCAAgC,GAChCC,SAAS;IACT,oFAAoF,GACpFC,aAAa;IACb,8DAA8D,GAC9DC,YAAY;AACd,EAAU"}

package/dist/loaders/studio/studioWorkerLoader.worker.js

@@ -0,0 +1,205 @@
+import { dirname, resolve as resolvePath } from 'node:path';
+import { isMainThread } from 'node:worker_threads';
+import { getTsconfig } from 'get-tsconfig';
+import { createServer, loadEnv, mergeConfig } from 'vite';
+import { ViteNodeRunner } from 'vite-node/client';
+import { ViteNodeServer } from 'vite-node/server';
+import { installSourcemapsSupport } from 'vite-node/source-map';
+import { getCliConfig } from '../../config/cli/getCliConfig.js';
+import { subdebug } from '../../debug.js';
+import { isNotFoundError } from '../../errors/NotFoundError.js';
+import { getStudioEnvironmentVariables } from '../../util/environment/getStudioEnvironmentVariables.js';
+import { setupBrowserStubs } from '../../util/environment/setupBrowserStubs.js';
+import { isRecord } from '../../util/isRecord.js';
+if (isMainThread) {
+    throw new Error('Should be child of thread, not the main thread');
+}
+const rootPath = process.env.STUDIO_WORKER_STUDIO_ROOT_PATH;
+if (!rootPath) {
+    throw new Error('Missing `STUDIO_WORKER_STUDIO_ROOT_PATH` environment variable');
+}
+const debug = subdebug('studio:worker');
+const workerScriptPath = process.env.STUDIO_WORKER_TASK_FILE;
+if (!workerScriptPath) {
+    throw new Error('Missing `STUDIO_WORKER_TASK_FILE` environment variable');
+}
+await setupBrowserStubs();
+const studioEnvVars = await getStudioEnvironmentVariables(rootPath);
+// Allow the CLI config (`sanity.cli.(js|ts)`) to define a `vite` property which can
+// extend/modify the default vite configuration for the studio.
+let cliConfig;
+try {
+    cliConfig = await getCliConfig(rootPath);
+} catch (err) {
+    debug('Failed to load CLI config: %o', err);
+    if (!isNotFoundError(err)) {
+        // eslint-disable-next-line no-console
+        console.warn('[warn] Failed to load CLI config:', err);
+    }
+}
+/**
+ * Reads tsconfig.json `paths` and converts them to Vite `resolve.alias` entries.
+ * This allows studio projects using path aliases (e.g. `"@/*": ["./src/*"]`) to work
+ * with CLI worker commands without requiring the user to manually add `vite-tsconfig-paths`.
+ */ function getTsconfigPathAliases(studioRootPath) {
+    const tsconfig = getTsconfig(studioRootPath);
+    if (!tsconfig) return {};
+    const { baseUrl, paths } = tsconfig.config.compilerOptions ?? {};
+    if (!paths) return {};
+    const tsconfigDir = dirname(tsconfig.path);
+    const base = baseUrl ? resolvePath(tsconfigDir, baseUrl) : tsconfigDir;
+    const aliases = {};
+    for (const [pattern, targets] of Object.entries(paths)){
+        if (!targets || targets.length === 0) continue;
+        // Only the first target is used — multiple fallback targets are not supported
+        const target = targets[0];
+        if (pattern.endsWith('/*') && target.endsWith('/*')) {
+            // Wildcard: "@/*" => "./src/*" becomes "@" => "/abs/path/src"
+            aliases[pattern.slice(0, -2)] = resolvePath(base, target.slice(0, -2));
+        } else {
+            // Exact: "@utils" => "./src/utils/index"
+            aliases[pattern] = resolvePath(base, target);
+        }
+    }
+    // Sort by key length descending so more-specific aliases take precedence
+    // (e.g. "@lib" is matched before "@" when both exist)
+    return Object.fromEntries(Object.entries(aliases).toSorted(([a], [b])=>b.length - a.length));
+}
+/**
+ * Fetches and caches modules from HTTP/HTTPS URLs.
+ * Vite's SSR transform treats `https://` imports as external and bypasses the plugin
+ * resolve pipeline entirely, so we intercept them at the ViteNodeRunner level instead.
+ */ const httpModuleCache = new Map();
+async function fetchHttpModule(url) {
+    const cached = httpModuleCache.get(url);
+    if (cached) return {
+        code: cached
+    };
+    debug('Fetching HTTP import: %s', url);
+    const response = await fetch(url, {
+        signal: AbortSignal.timeout(30_000)
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch module from ${url}: ${response.status} ${response.statusText}`);
+    }
+    const code = await response.text();
+    httpModuleCache.set(url, code);
+    return {
+        code
+    };
+}
+function isHttpsUrl(id) {
+    return id.startsWith('https://');
+}
+let tsconfigAliases = {};
+try {
+    tsconfigAliases = getTsconfigPathAliases(rootPath);
+} catch (err) {
+    debug('Failed to read tsconfig paths: %o', err);
+}
+const defaultViteConfig = {
+    build: {
+        target: 'node'
+    },
+    configFile: false,
+    // Inject environment variables as compile-time constants for Vite
+    define: Object.fromEntries(Object.entries(studioEnvVars).map(([key, value])=>[
+            `process.env.${key}`,
+            JSON.stringify(value)
+        ])),
+    envPrefix: cliConfig && 'app' in cliConfig ? 'SANITY_APP_' : 'SANITY_STUDIO_',
+    esbuild: {
+        jsx: 'automatic'
+    },
+    logLevel: 'error',
+    optimizeDeps: {
+        include: undefined,
+        noDiscovery: true
+    },
+    resolve: {
+        alias: tsconfigAliases
+    },
+    root: rootPath,
+    server: {
+        hmr: false,
+        watch: null
+    },
+    ssr: {
+        /**
+     * We don't want to externalize any dependencies, we want everything to run thru vite.
+     * Especially for CJS compatibility, etc.
+     */ noExternal: true
+    }
+};
+// Merge the CLI config's Vite config with the default Vite config
+let viteConfig = defaultViteConfig;
+if (typeof cliConfig?.vite === 'function') {
+    viteConfig = await cliConfig.vite(viteConfig, {
+        command: 'build',
+        isSsrBuild: true,
+        mode: 'production'
+    });
+} else if (isRecord(cliConfig?.vite)) {
+    viteConfig = mergeConfig(viteConfig, cliConfig.vite);
+}
+debug('Creating Vite server with config: %o', viteConfig);
+// Vite will build the files we give it - targetting Node.js instead of the browser.
+// We include the inject plugin in order to provide the stubs for the undefined global APIs.
+const server = await createServer(viteConfig);
+// Bit of a hack, but seems necessary based on the `node-vite` binary implementation
+await server.pluginContainer.buildStart({});
+// Load environment variables from `.env` files in the same way as Vite does.
+// Note that Sanity also provides environment variables through `process.env.*` for compat reasons,
+// and so we need to do the same here.
+// Load ALL env vars from .env files (not just studio-prefixed ones) so non-Sanity-prefixed
+// vars (e.g. NEXT_PUBLIC_*, VITE_*) are available via process.env at runtime.
+// The ??= on the next line prevents overwriting existing process.env values.
+const env = loadEnv(server.config.mode, server.config.envDir, '');
+for(const key in env){
+    process.env[key] ??= env[key];
+}
+// Now we're providing the glue that ensures node-specific loading and execution works.
+const node = new ViteNodeServer(server);
+// Should make it easier to debug any crashes in the imported code…
+installSourcemapsSupport({
+    getSourceMap: (source)=>node.getSourceMap(source)
+});
+const runner = new ViteNodeRunner({
+    base: server.config.base,
+    async fetchModule (id) {
+        // Vite's SSR transform externalizes https:// imports, so Node's ESM loader
+        // would reject them. We fetch the module over HTTP and run it through Vite's
+        // SSR transform to rewrite ESM export/import syntax to the __vite_ssr_*
+        // format that ViteNodeRunner expects.
+        if (isHttpsUrl(id)) {
+            const { code: rawCode } = await fetchHttpModule(id);
+            const result = await server.ssrTransform(rawCode, null, id);
+            return {
+                code: result?.code || rawCode
+            };
+        }
+        return node.fetchModule(id);
+    },
+    resolveId (id, importer) {
+        // Prevent vite-node from trying to resolve HTTP URLs through Node's resolver
+        if (isHttpsUrl(id)) return {
+            id
+        };
+        // Resolve any import from an HTTP-fetched module against the remote origin
+        // (e.g. esm.sh returns `export * from '/pkg@1.0/es2022/pkg.mjs'`)
+        if (importer && isHttpsUrl(importer)) {
+            return {
+                id: new URL(id, importer).href
+            };
+        }
+        return node.resolveId(id, importer);
+    },
+    root: server.config.root
+});
+// Copied from `vite-node` - it appears that this applies the `define` config from
+// vite, but it also takes a surprisingly long time to execute. Not clear at this
+// point why this is, so we should investigate whether it's necessary or not.
+await runner.executeId('/@vite/env');
+await runner.executeId(workerScriptPath);
+
+//# sourceMappingURL=studioWorkerLoader.worker.js.map

package/dist/loaders/studio/studioWorkerLoader.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/loaders/studio/studioWorkerLoader.worker.ts"],"sourcesContent":["import {dirname, resolve as resolvePath} from 'node:path'\nimport {isMainThread} from 'node:worker_threads'\n\nimport {getTsconfig} from 'get-tsconfig'\nimport {createServer, type InlineConfig, loadEnv, mergeConfig} from 'vite'\nimport {ViteNodeRunner} from 'vite-node/client'\nimport {ViteNodeServer} from 'vite-node/server'\nimport {installSourcemapsSupport} from 'vite-node/source-map'\n\nimport {getCliConfig} from '../../config/cli/getCliConfig.js'\nimport {type CliConfig} from '../../config/cli/types/cliConfig.js'\nimport {subdebug} from '../../debug.js'\nimport {isNotFoundError} from '../../errors/NotFoundError.js'\nimport {getStudioEnvironmentVariables} from '../../util/environment/getStudioEnvironmentVariables.js'\nimport {setupBrowserStubs} from '../../util/environment/setupBrowserStubs.js'\nimport {isRecord} from '../../util/isRecord.js'\n\nif (isMainThread) {\n  throw new Error('Should be child of thread, not the main thread')\n}\n\nconst rootPath = process.env.STUDIO_WORKER_STUDIO_ROOT_PATH\nif (!rootPath) {\n  throw new Error('Missing `STUDIO_WORKER_STUDIO_ROOT_PATH` environment variable')\n}\n\nconst debug = subdebug('studio:worker')\n\nconst workerScriptPath = process.env.STUDIO_WORKER_TASK_FILE\nif (!workerScriptPath) {\n  throw new Error('Missing `STUDIO_WORKER_TASK_FILE` environment variable')\n}\n\nawait setupBrowserStubs()\n\nconst studioEnvVars = await getStudioEnvironmentVariables(rootPath)\n\n// Allow the CLI config (`sanity.cli.(js|ts)`) to define a `vite` property which can\n// extend/modify the default vite configuration for the studio.\nlet cliConfig: CliConfig | undefined\ntry {\n  cliConfig = await getCliConfig(rootPath)\n} catch (err) {\n  debug('Failed to load CLI config: %o', err)\n  if (!isNotFoundError(err)) {\n    // eslint-disable-next-line no-console\n    console.warn('[warn] Failed to load CLI config:', err)\n  }\n}\n\n/**\n * Reads tsconfig.json `paths` and converts them to Vite `resolve.alias` entries.\n * This allows studio projects using path aliases (e.g. `\"@/*\": [\"./src/*\"]`) to work\n * with CLI worker commands without requiring the user to manually add `vite-tsconfig-paths`.\n */\nfunction getTsconfigPathAliases(studioRootPath: string): Record<string, string> {\n  const tsconfig = getTsconfig(studioRootPath)\n  if (!tsconfig) return {}\n\n  const {baseUrl, paths} = tsconfig.config.compilerOptions ?? {}\n  if (!paths) return {}\n\n  const tsconfigDir = dirname(tsconfig.path)\n  const base = baseUrl ? resolvePath(tsconfigDir, baseUrl) : tsconfigDir\n\n  const aliases: Record<string, string> = {}\n  for (const [pattern, targets] of Object.entries(paths)) {\n    if (!targets || targets.length === 0) continue\n    // Only the first target is used — multiple fallback targets are not supported\n    const target = targets[0]\n\n    if (pattern.endsWith('/*') && target.endsWith('/*')) {\n      // Wildcard: \"@/*\" => \"./src/*\" becomes \"@\" => \"/abs/path/src\"\n      aliases[pattern.slice(0, -2)] = resolvePath(base, target.slice(0, -2))\n    } else {\n      // Exact: \"@utils\" => \"./src/utils/index\"\n      aliases[pattern] = resolvePath(base, target)\n    }\n  }\n  // Sort by key length descending so more-specific aliases take precedence\n  // (e.g. \"@lib\" is matched before \"@\" when both exist)\n  return Object.fromEntries(Object.entries(aliases).toSorted(([a], [b]) => b.length - a.length))\n}\n\n/**\n * Fetches and caches modules from HTTP/HTTPS URLs.\n * Vite's SSR transform treats `https://` imports as external and bypasses the plugin\n * resolve pipeline entirely, so we intercept them at the ViteNodeRunner level instead.\n */\nconst httpModuleCache = new Map<string, string>()\nasync function fetchHttpModule(url: string): Promise<{code: string}> {\n  const cached = httpModuleCache.get(url)\n  if (cached) return {code: cached}\n\n  debug('Fetching HTTP import: %s', url)\n  const response = await fetch(url, {signal: AbortSignal.timeout(30_000)})\n  if (!response.ok) {\n    throw new Error(`Failed to fetch module from ${url}: ${response.status} ${response.statusText}`)\n  }\n\n  const code = await response.text()\n  httpModuleCache.set(url, code)\n  return {code}\n}\n\nfunction isHttpsUrl(id: string): boolean {\n  return id.startsWith('https://')\n}\n\nlet tsconfigAliases: Record<string, string> = {}\ntry {\n  tsconfigAliases = getTsconfigPathAliases(rootPath)\n} catch (err) {\n  debug('Failed to read tsconfig paths: %o', err)\n}\n\nconst defaultViteConfig: InlineConfig = {\n  build: {target: 'node'},\n  configFile: false,\n  // Inject environment variables as compile-time constants for Vite\n  define: Object.fromEntries(\n    Object.entries(studioEnvVars).map(([key, value]) => [\n      `process.env.${key}`,\n      JSON.stringify(value),\n    ]),\n  ),\n  envPrefix: cliConfig && 'app' in cliConfig ? 'SANITY_APP_' : 'SANITY_STUDIO_',\n  esbuild: {\n    jsx: 'automatic',\n  },\n  logLevel: 'error',\n  optimizeDeps: {\n    include: undefined,\n    noDiscovery: true,\n  },\n  resolve: {\n    alias: tsconfigAliases,\n  },\n  root: rootPath,\n  server: {\n    hmr: false,\n    watch: null,\n  },\n  ssr: {\n    /**\n     * We don't want to externalize any dependencies, we want everything to run thru vite.\n     * Especially for CJS compatibility, etc.\n     */\n    noExternal: true,\n  },\n}\n\n// Merge the CLI config's Vite config with the default Vite config\nlet viteConfig = defaultViteConfig\nif (typeof cliConfig?.vite === 'function') {\n  viteConfig = (await cliConfig.vite(viteConfig, {\n    command: 'build',\n    isSsrBuild: true,\n    mode: 'production',\n  })) as InlineConfig\n} else if (isRecord(cliConfig?.vite)) {\n  viteConfig = mergeConfig(viteConfig, cliConfig.vite)\n}\n\ndebug('Creating Vite server with config: %o', viteConfig)\n// Vite will build the files we give it - targetting Node.js instead of the browser.\n// We include the inject plugin in order to provide the stubs for the undefined global APIs.\nconst server = await createServer(viteConfig)\n\n// Bit of a hack, but seems necessary based on the `node-vite` binary implementation\nawait server.pluginContainer.buildStart({})\n\n// Load environment variables from `.env` files in the same way as Vite does.\n// Note that Sanity also provides environment variables through `process.env.*` for compat reasons,\n// and so we need to do the same here.\n// Load ALL env vars from .env files (not just studio-prefixed ones) so non-Sanity-prefixed\n// vars (e.g. NEXT_PUBLIC_*, VITE_*) are available via process.env at runtime.\n// The ??= on the next line prevents overwriting existing process.env values.\nconst env = loadEnv(server.config.mode, server.config.envDir, '')\nfor (const key in env) {\n  process.env[key] ??= env[key]\n}\n\n// Now we're providing the glue that ensures node-specific loading and execution works.\nconst node = new ViteNodeServer(server)\n\n// Should make it easier to debug any crashes in the imported code…\ninstallSourcemapsSupport({\n  getSourceMap: (source) => node.getSourceMap(source),\n})\n\nconst runner = new ViteNodeRunner({\n  base: server.config.base,\n  async fetchModule(id) {\n    // Vite's SSR transform externalizes https:// imports, so Node's ESM loader\n    // would reject them. We fetch the module over HTTP and run it through Vite's\n    // SSR transform to rewrite ESM export/import syntax to the __vite_ssr_*\n    // format that ViteNodeRunner expects.\n    if (isHttpsUrl(id)) {\n      const {code: rawCode} = await fetchHttpModule(id)\n      const result = await server.ssrTransform(rawCode, null, id)\n      return {code: result?.code || rawCode}\n    }\n    return node.fetchModule(id)\n  },\n  resolveId(id, importer) {\n    // Prevent vite-node from trying to resolve HTTP URLs through Node's resolver\n    if (isHttpsUrl(id)) return {id}\n    // Resolve any import from an HTTP-fetched module against the remote origin\n    // (e.g. esm.sh returns `export * from '/pkg@1.0/es2022/pkg.mjs'`)\n    if (importer && isHttpsUrl(importer)) {\n      return {id: new URL(id, importer).href}\n    }\n    return node.resolveId(id, importer)\n  },\n  root: server.config.root,\n})\n\n// Copied from `vite-node` - it appears that this applies the `define` config from\n// vite, but it also takes a surprisingly long time to execute. Not clear at this\n// point why this is, so we should investigate whether it's necessary or not.\nawait runner.executeId('/@vite/env')\n\nawait runner.executeId(workerScriptPath)\n"],"names":["dirname","resolve","resolvePath","isMainThread","getTsconfig","createServer","loadEnv","mergeConfig","ViteNodeRunner","ViteNodeServer","installSourcemapsSupport","getCliConfig","subdebug","isNotFoundError","getStudioEnvironmentVariables","setupBrowserStubs","isRecord","Error","rootPath","process","env","STUDIO_WORKER_STUDIO_ROOT_PATH","debug","workerScriptPath","STUDIO_WORKER_TASK_FILE","studioEnvVars","cliConfig","err","console","warn","getTsconfigPathAliases","studioRootPath","tsconfig","baseUrl","paths","config","compilerOptions","tsconfigDir","path","base","aliases","pattern","targets","Object","entries","length","target","endsWith","slice","fromEntries","toSorted","a","b","httpModuleCache","Map","fetchHttpModule","url","cached","get","code","response","fetch","signal","AbortSignal","timeout","ok","status","statusText","text","set","isHttpsUrl","id","startsWith","tsconfigAliases","defaultViteConfig","build","configFile","define","map","key","value","JSON","stringify","envPrefix","esbuild","jsx","logLevel","optimizeDeps","include","undefined","noDiscovery","alias","root","server","hmr","watch","ssr","noExternal","viteConfig","vite","command","isSsrBuild","mode","pluginContainer","buildStart","envDir","node","getSourceMap","source","runner","fetchModule","rawCode","result","ssrTransform","resolveId","importer","URL","href","executeId"],"mappings":"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"}

package/dist/loaders/studio/studioWorkerTask.js

@@ -0,0 +1,90 @@
+import { fileURLToPath } from 'node:url';
+import { Worker } from 'node:worker_threads';
+import { isRecord } from '../../util/isRecord.js';
+import { promisifyWorker } from '../../util/promisifyWorker.js';
+/**
+ * Executes a worker file in a Sanity Studio browser context.
+ *
+ * This uses a combination of vite for "bundling" + jsdom for emulating a browser
+ * environment under the hood, which means that the same thing that will work in vite
+ * _should_ work in the worker - to a degree. If the user has defined any typescript
+ * path aliases, these will have to be added as aliases to the vite config - the same
+ * behavior as you would see with regular vite. Other things that are accounted for:
+ *
+ * - TypeScript support (+JSX, enums and other "compilation needed" features)
+ * - CSS, font and other file imports will resolve to a file path
+ * - CSS module imports will resolve to a javascript object of class names
+ * - Environment variables are available both as `import.meta.env` and `process.env`,
+ *   and `.env` files are loaded in the same way that they would in a Sanity studio.
+ * - Browser globals not available in a Node.js environment but _are_ provided by JSDOM
+ *   are defined directly to the Node environment as globals. While this polutes the
+ *   global namespace, it is done only in the worker thread.
+ * - Certain browser globals that are _not_ available in JSDOM are also provided to the
+ *   global namespace - things like `requestIdleCallback`, `IntersectionObserver` etc.
+ *   These are provided with a minimal stub implementation to make them not crash.
+ *
+ * @param filePath - Path to the worker file (`.ts` works and is encouraged)
+ * @param options - Options to pass to the worker
+ * @returns A promise that resolves with the message from the worker
+ * @throws If the file does not exist
+ * @throws If the worker exits with a non-zero code
+ * @internal
+ */ export function studioWorkerTask(filePath, options) {
+    const normalizedFilePath = fileURLToPath(filePath);
+    if (!/\.worker\.(js|ts)$/.test(normalizedFilePath)) {
+        throw new Error('Studio worker tasks must include `.worker.(js|ts)` in path');
+    }
+    const { studioRootPath, timeout, ...workerOptions } = options;
+    return promisifyWorker(new URL('studioWorkerLoader.worker.js', import.meta.url), {
+        ...workerOptions,
+        env: {
+            ...isRecord(workerOptions.env) ? workerOptions.env : process.env,
+            STUDIO_WORKER_STUDIO_ROOT_PATH: studioRootPath,
+            STUDIO_WORKER_TASK_FILE: normalizedFilePath
+        },
+        timeout
+    });
+}
+/**
+ * Creates a new worker for a studio worker task.
+ *
+ * This uses a combination of vite for "bundling" + jsdom for emulating a browser
+ * environment under the hood, which means that the same thing that will work in vite
+ * _should_ work in the worker - to a degree. If the user has defined any typescript
+ * path aliases, these will have to be added as aliases to the vite config - the same
+ * behavior as you would see with regular vite. Other things that are accounted for:
+ *
+ * - TypeScript support (+JSX, enums and other "compilation needed" features)
+ * - CSS, font and other file imports will resolve to a file path
+ * - CSS module imports will resolve to a javascript object of class names
+ * - Environment variables are available both as `import.meta.env` and `process.env`,
+ *   and `.env` files are loaded in the same way that they would in a Sanity studio.
+ * - Browser globals not available in a Node.js environment but _are_ provided by JSDOM
+ *   are defined directly to the Node environment as globals. While this polutes the
+ *   global namespace, it is done only in the worker thread.
+ * - Certain browser globals that are _not_ available in JSDOM are also provided to the
+ *   global namespace - things like `requestIdleCallback`, `IntersectionObserver` etc.
+ *   These are provided with a minimal stub implementation to make them not crash.
+ *
+ * @param filePath - Path to the worker file (`.ts` works and is encouraged)
+ * @param options - Options to pass to the worker
+ * @returns A promise that resolves with the message from the worker
+ * @throws If the file does not exist
+ * @throws If the worker exits with a non-zero code
+ * @internal
+ */ export function createStudioWorker(filePath, options) {
+    const normalizedFilePath = fileURLToPath(filePath);
+    if (!/\.worker\.(js|ts)$/.test(normalizedFilePath)) {
+        throw new Error('Studio worker tasks must include `.worker.(js|ts)` in path');
+    }
+    return new Worker(new URL('studioWorkerLoader.worker.js', import.meta.url), {
+        ...options,
+        env: {
+            ...isRecord(options.env) ? options.env : process.env,
+            STUDIO_WORKER_STUDIO_ROOT_PATH: options.studioRootPath,
+            STUDIO_WORKER_TASK_FILE: normalizedFilePath
+        }
+    });
+}
+
+//# sourceMappingURL=studioWorkerTask.js.map

package/dist/loaders/studio/studioWorkerTask.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/loaders/studio/studioWorkerTask.ts"],"sourcesContent":["import {fileURLToPath} from 'node:url'\nimport {Worker, type WorkerOptions} from 'node:worker_threads'\n\nimport {type RequireProps} from '../../types.js'\nimport {isRecord} from '../../util/isRecord.js'\nimport {promisifyWorker} from '../../util/promisifyWorker.js'\n\n/**\n * Options for the studio worker task\n *\n * @internal\n */\ninterface StudioWorkerTaskOptions extends RequireProps<WorkerOptions, 'name'> {\n  studioRootPath: string\n\n  /** Optional timeout in milliseconds. If the worker does not respond within this time, it will be terminated and the promise rejected. */\n  timeout?: number\n}\n\n/**\n * Executes a worker file in a Sanity Studio browser context.\n *\n * This uses a combination of vite for \"bundling\" + jsdom for emulating a browser\n * environment under the hood, which means that the same thing that will work in vite\n * _should_ work in the worker - to a degree. If the user has defined any typescript\n * path aliases, these will have to be added as aliases to the vite config - the same\n * behavior as you would see with regular vite. Other things that are accounted for:\n *\n * - TypeScript support (+JSX, enums and other \"compilation needed\" features)\n * - CSS, font and other file imports will resolve to a file path\n * - CSS module imports will resolve to a javascript object of class names\n * - Environment variables are available both as `import.meta.env` and `process.env`,\n *   and `.env` files are loaded in the same way that they would in a Sanity studio.\n * - Browser globals not available in a Node.js environment but _are_ provided by JSDOM\n *   are defined directly to the Node environment as globals. While this polutes the\n *   global namespace, it is done only in the worker thread.\n * - Certain browser globals that are _not_ available in JSDOM are also provided to the\n *   global namespace - things like `requestIdleCallback`, `IntersectionObserver` etc.\n *   These are provided with a minimal stub implementation to make them not crash.\n *\n * @param filePath - Path to the worker file (`.ts` works and is encouraged)\n * @param options - Options to pass to the worker\n * @returns A promise that resolves with the message from the worker\n * @throws If the file does not exist\n * @throws If the worker exits with a non-zero code\n * @internal\n */\nexport function studioWorkerTask<T = unknown>(\n  filePath: URL,\n  options: StudioWorkerTaskOptions,\n): Promise<T> {\n  const normalizedFilePath = fileURLToPath(filePath)\n\n  if (!/\\.worker\\.(js|ts)$/.test(normalizedFilePath)) {\n    throw new Error('Studio worker tasks must include `.worker.(js|ts)` in path')\n  }\n\n  const {studioRootPath, timeout, ...workerOptions} = options\n  return promisifyWorker<T>(new URL('studioWorkerLoader.worker.js', import.meta.url), {\n    ...workerOptions,\n    env: {\n      ...(isRecord(workerOptions.env) ? workerOptions.env : process.env),\n      STUDIO_WORKER_STUDIO_ROOT_PATH: studioRootPath,\n      STUDIO_WORKER_TASK_FILE: normalizedFilePath,\n    },\n    timeout,\n  })\n}\n\n/**\n * Creates a new worker for a studio worker task.\n *\n * This uses a combination of vite for \"bundling\" + jsdom for emulating a browser\n * environment under the hood, which means that the same thing that will work in vite\n * _should_ work in the worker - to a degree. If the user has defined any typescript\n * path aliases, these will have to be added as aliases to the vite config - the same\n * behavior as you would see with regular vite. Other things that are accounted for:\n *\n * - TypeScript support (+JSX, enums and other \"compilation needed\" features)\n * - CSS, font and other file imports will resolve to a file path\n * - CSS module imports will resolve to a javascript object of class names\n * - Environment variables are available both as `import.meta.env` and `process.env`,\n *   and `.env` files are loaded in the same way that they would in a Sanity studio.\n * - Browser globals not available in a Node.js environment but _are_ provided by JSDOM\n *   are defined directly to the Node environment as globals. While this polutes the\n *   global namespace, it is done only in the worker thread.\n * - Certain browser globals that are _not_ available in JSDOM are also provided to the\n *   global namespace - things like `requestIdleCallback`, `IntersectionObserver` etc.\n *   These are provided with a minimal stub implementation to make them not crash.\n *\n * @param filePath - Path to the worker file (`.ts` works and is encouraged)\n * @param options - Options to pass to the worker\n * @returns A promise that resolves with the message from the worker\n * @throws If the file does not exist\n * @throws If the worker exits with a non-zero code\n * @internal\n */\nexport function createStudioWorker(filePath: URL, options: StudioWorkerTaskOptions) {\n  const normalizedFilePath = fileURLToPath(filePath)\n\n  if (!/\\.worker\\.(js|ts)$/.test(normalizedFilePath)) {\n    throw new Error('Studio worker tasks must include `.worker.(js|ts)` in path')\n  }\n\n  return new Worker(new URL('studioWorkerLoader.worker.js', import.meta.url), {\n    ...options,\n    env: {\n      ...(isRecord(options.env) ? options.env : process.env),\n      STUDIO_WORKER_STUDIO_ROOT_PATH: options.studioRootPath,\n      STUDIO_WORKER_TASK_FILE: normalizedFilePath,\n    },\n  })\n}\n"],"names":["fileURLToPath","Worker","isRecord","promisifyWorker","studioWorkerTask","filePath","options","normalizedFilePath","test","Error","studioRootPath","timeout","workerOptions","URL","url","env","process","STUDIO_WORKER_STUDIO_ROOT_PATH","STUDIO_WORKER_TASK_FILE","createStudioWorker"],"mappings":"AAAA,SAAQA,aAAa,QAAO,WAAU;AACtC,SAAQC,MAAM,QAA2B,sBAAqB;AAG9D,SAAQC,QAAQ,QAAO,yBAAwB;AAC/C,SAAQC,eAAe,QAAO,gCAA+B;AAc7D;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BC,GACD,OAAO,SAASC,iBACdC,QAAa,EACbC,OAAgC;IAEhC,MAAMC,qBAAqBP,cAAcK;IAEzC,IAAI,CAAC,qBAAqBG,IAAI,CAACD,qBAAqB;QAClD,MAAM,IAAIE,MAAM;IAClB;IAEA,MAAM,EAACC,cAAc,EAAEC,OAAO,EAAE,GAAGC,eAAc,GAAGN;IACpD,OAAOH,gBAAmB,IAAIU,IAAI,gCAAgC,YAAYC,GAAG,GAAG;QAClF,GAAGF,aAAa;QAChBG,KAAK;YACH,GAAIb,SAASU,cAAcG,GAAG,IAAIH,cAAcG,GAAG,GAAGC,QAAQD,GAAG;YACjEE,gCAAgCP;YAChCQ,yBAAyBX;QAC3B;QACAI;IACF;AACF;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BC,GACD,OAAO,SAASQ,mBAAmBd,QAAa,EAAEC,OAAgC;IAChF,MAAMC,qBAAqBP,cAAcK;IAEzC,IAAI,CAAC,qBAAqBG,IAAI,CAACD,qBAAqB;QAClD,MAAM,IAAIE,MAAM;IAClB;IAEA,OAAO,IAAIR,OAAO,IAAIY,IAAI,gCAAgC,YAAYC,GAAG,GAAG;QAC1E,GAAGR,OAAO;QACVS,KAAK;YACH,GAAIb,SAASI,QAAQS,GAAG,IAAIT,QAAQS,GAAG,GAAGC,QAAQD,GAAG;YACrDE,gCAAgCX,QAAQI,cAAc;YACtDQ,yBAAyBX;QAC3B;IACF;AACF"}

package/dist/loaders/tsx/tsxWorkerLoader.worker.js

@@ -0,0 +1,11 @@
+import { importModule } from '../../util/importModule.js';
+const workerScript = process.env.TSX_WORKER_TASK_SCRIPT;
+if (workerScript) {
+    await importModule(workerScript, {
+        tsconfigPath: process.env.TSX_TSCONFIG_PATH
+    });
+} else {
+    throw new Error('`TX_WORKER_TASK_SCRIPT` not defined');
+}
+
+//# sourceMappingURL=tsxWorkerLoader.worker.js.map

package/dist/loaders/tsx/tsxWorkerLoader.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/loaders/tsx/tsxWorkerLoader.worker.ts"],"sourcesContent":["import {importModule} from '../../util/importModule.js'\n\nconst workerScript = process.env.TSX_WORKER_TASK_SCRIPT\n\nif (workerScript) {\n  await importModule(workerScript, {\n    tsconfigPath: process.env.TSX_TSCONFIG_PATH,\n  })\n} else {\n  throw new Error('`TX_WORKER_TASK_SCRIPT` not defined')\n}\n"],"names":["importModule","workerScript","process","env","TSX_WORKER_TASK_SCRIPT","tsconfigPath","TSX_TSCONFIG_PATH","Error"],"mappings":"AAAA,SAAQA,YAAY,QAAO,6BAA4B;AAEvD,MAAMC,eAAeC,QAAQC,GAAG,CAACC,sBAAsB;AAEvD,IAAIH,cAAc;IAChB,MAAMD,aAAaC,cAAc;QAC/BI,cAAcH,QAAQC,GAAG,CAACG,iBAAiB;IAC7C;AACF,OAAO;IACL,MAAM,IAAIC,MAAM;AAClB"}

package/dist/loaders/tsx/tsxWorkerTask.js

@@ -0,0 +1,34 @@
+import { fileURLToPath, URL } from 'node:url';
+import { getTsconfig } from 'get-tsconfig';
+import { isRecord } from '../../util/isRecord.js';
+import { promisifyWorker } from '../../util/promisifyWorker.js';
+/**
+ * Executes a worker file with tsx registered. This means you can import other
+ * typescript with fairly rich syntax, and still have that only apply to the worker
+ * thread instead of the full parent process. The worker should emit a message when
+ * complete using `parentPort`. Once it has received a single message will resolve the
+ * returned promise with that message. If you are expecting multiple messages, you will
+ * have to implement another method ;)
+ *
+ * @param filePath - Path to the worker file
+ * @param options - Options to pass to the worker
+ * @returns A promise that resolves with the message from the worker
+ * @throws If the file does not exist
+ * @throws If the worker exits with a non-zero code
+ * @internal
+ */ export function tsxWorkerTask(filePath, options) {
+    const tsconfig = getTsconfig(options.rootPath);
+    const env = {
+        ...isRecord(options.env) ? options.env : process.env,
+        ...tsconfig?.path ? {
+            TSX_TSCONFIG_PATH: tsconfig.path
+        } : {},
+        TSX_WORKER_TASK_SCRIPT: fileURLToPath(filePath)
+    };
+    return promisifyWorker(new URL('tsxWorkerLoader.worker.js', import.meta.url), {
+        ...options,
+        env
+    });
+}
+
+//# sourceMappingURL=tsxWorkerTask.js.map

package/dist/loaders/tsx/tsxWorkerTask.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/loaders/tsx/tsxWorkerTask.ts"],"sourcesContent":["import {fileURLToPath, URL} from 'node:url'\nimport {type WorkerOptions} from 'node:worker_threads'\n\nimport {getTsconfig} from 'get-tsconfig'\n\nimport {type RequireProps} from '../../types.js'\nimport {isRecord} from '../../util/isRecord.js'\nimport {promisifyWorker} from '../../util/promisifyWorker.js'\n\n/**\n * Options for the tsx worker task\n *\n * @internal\n */\ninterface TsxWorkerTaskOptions extends RequireProps<WorkerOptions, 'name'> {\n  rootPath: string\n}\n\n/**\n * Executes a worker file with tsx registered. This means you can import other\n * typescript with fairly rich syntax, and still have that only apply to the worker\n * thread instead of the full parent process. The worker should emit a message when\n * complete using `parentPort`. Once it has received a single message will resolve the\n * returned promise with that message. If you are expecting multiple messages, you will\n * have to implement another method ;)\n *\n * @param filePath - Path to the worker file\n * @param options - Options to pass to the worker\n * @returns A promise that resolves with the message from the worker\n * @throws If the file does not exist\n * @throws If the worker exits with a non-zero code\n * @internal\n */\nexport function tsxWorkerTask<T = unknown>(\n  filePath: URL,\n  options: TsxWorkerTaskOptions,\n): Promise<T> {\n  const tsconfig = getTsconfig(options.rootPath)\n\n  const env = {\n    ...(isRecord(options.env) ? options.env : process.env),\n    ...(tsconfig?.path ? {TSX_TSCONFIG_PATH: tsconfig.path} : {}),\n    TSX_WORKER_TASK_SCRIPT: fileURLToPath(filePath),\n  }\n\n  return promisifyWorker<T>(new URL('tsxWorkerLoader.worker.js', import.meta.url), {\n    ...options,\n    env,\n  })\n}\n"],"names":["fileURLToPath","URL","getTsconfig","isRecord","promisifyWorker","tsxWorkerTask","filePath","options","tsconfig","rootPath","env","process","path","TSX_TSCONFIG_PATH","TSX_WORKER_TASK_SCRIPT","url"],"mappings":"AAAA,SAAQA,aAAa,EAAEC,GAAG,QAAO,WAAU;AAG3C,SAAQC,WAAW,QAAO,eAAc;AAGxC,SAAQC,QAAQ,QAAO,yBAAwB;AAC/C,SAAQC,eAAe,QAAO,gCAA+B;AAW7D;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASC,cACdC,QAAa,EACbC,OAA6B;IAE7B,MAAMC,WAAWN,YAAYK,QAAQE,QAAQ;IAE7C,MAAMC,MAAM;QACV,GAAIP,SAASI,QAAQG,GAAG,IAAIH,QAAQG,GAAG,GAAGC,QAAQD,GAAG;QACrD,GAAIF,UAAUI,OAAO;YAACC,mBAAmBL,SAASI,IAAI;QAAA,IAAI,CAAC,CAAC;QAC5DE,wBAAwBd,cAAcM;IACxC;IAEA,OAAOF,gBAAmB,IAAIH,IAAI,6BAA6B,YAAYc,GAAG,GAAG;QAC/E,GAAGR,OAAO;QACVG;IACF;AACF"}