@sanity/codegen 5.9.0-watch-mode.2 → 5.9.1

package/dist/actions/typegenGenerate.worker.js

@@ -1,1358 +1,28 @@
-// src/actions/typegenGenerate.worker.ts
-import { stat } from "node:fs/promises";
-import { isAbsolute, join as join2 } from "node:path";
-import { isMainThread, parentPort, workerData } from "node:worker_threads";
-import { WorkerChannelReporter } from "@sanity/worker-channels";
-// src/readSchema.ts
-import { readFile } from "node:fs/promises";
-async function readSchema(path3) {
-    const content = await readFile(path3, "utf8");
-    return JSON.parse(content);
-}
-// src/typescript/findQueriesInPath.ts
-import fs2 from "node:fs/promises";
-import createDebug3 from "debug";
-import glob from "globby";
-// src/getBabelConfig.ts
-import { existsSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-function findBabelConfig(path3) {
-    const configPath = join(path3, "babel.config.json");
-    if (existsSync(configPath)) {
-        return configPath;
-    }
-    const parent = resolve(join(path3, ".."));
-    if (parent && parent !== path3) {
-        return findBabelConfig(parent);
-    }
-    throw new Error("Could not find `babel.config.json` in @sanity/codegen");
-}
-function getBabelConfig(path3) {
-    const configPath = findBabelConfig(path3 || __dirname);
-    return {
-        extends: configPath
-    };
-}
-// src/typescript/findQueriesInSource.ts
-import { createRequire } from "node:module";
-import { traverse as traverse2 } from "@babel/core";
-import * as babelTypes2 from "@babel/types";
-// src/typescript/expressionResolvers.ts
-import fs from "node:fs";
-import path from "node:path";
-import { traverse } from "@babel/core";
-import { Scope } from "@babel/traverse";
-import * as babelTypes from "@babel/types";
-import createDebug from "debug";
-// src/utils/formatPath.ts
-function formatPath(path3) {
-    return path3.replaceAll("\\", "/");
-}
-// src/typescript/parseSource.ts
-import { parse } from "@babel/core";
-function parseSourceFile(_source, _filename, babelOptions) {
-    let source = _source;
-    let filename = _filename;
-    if (filename.endsWith(".astro")) {
-        filename += ".ts";
-        source = parseAstro(source);
-    } else if (filename.endsWith(".vue")) {
-        filename += ".ts";
-        source = parseVue(source);
-    } else if (filename.endsWith(".svelte")) {
-        filename += ".ts";
-        source = parseSvelte(source);
-    }
-    const result = parse(source, {
-        ...babelOptions,
-        filename
-    });
-    if (!result) {
-        throw new Error(`Failed to parse ${filename}`);
-    }
-    return result;
-}
-function parseAstro(source) {
-    const codeFences = source.match(/---\r?\n([\s\S]*?)\r?\n---/g);
-    if (!codeFences) {
-        return "";
-    }
-    return codeFences.map((codeFence)=>{
-        return codeFence.split(/\r?\n/).slice(1, -1).join("\n");
-    }).join("\n");
-}
-function parseVue(source) {
-    const scriptRegex = /<script(?:\s+generic=["'][^"']*["'])?[^>]*>([\s\S]*?)<\/script>/g;
-    const matches = matchAllPolyfill(source, scriptRegex);
-    if (matches.length === 0) {
-        return "";
-    }
-    return matches.map((match)=>match[1]).join("\n");
-}
-function parseSvelte(source) {
-    const scriptRegex = /<script[^>]*>([\s\S]*?)<\/script>/g;
-    const matches = matchAllPolyfill(source, scriptRegex);
-    if (matches.length === 0) {
-        return "";
-    }
-    return matches.map((match)=>match[1]).join("\n");
-}
-function matchAllPolyfill(str, regex) {
-    if (!regex.global) {
-        throw new Error("matchAll polyfill requires a global regex (with /g flag)");
-    }
-    const matches = [];
-    let match;
-    while((match = regex.exec(str)) !== null){
-        matches.push(match);
-    }
-    return matches;
-}
-// src/typescript/expressionResolvers.ts
-var debug = createDebug("sanity:codegen:findQueries:debug");
-var TAGGED_TEMPLATE_ALLOW_LIST = /* @__PURE__ */ new Set([
-    "groq"
-]);
-var FUNCTION_WRAPPER_ALLOW_LIST = /* @__PURE__ */ new Set([
-    "defineQuery"
-]);
-function resolveExpression({ babelConfig, file, filename, fnArguments = [], node, params = [], resolver, scope }) {
-    debug(`Resolving node ${node.type} in ${filename}:${node.loc?.start.line}:${node.loc?.start.column}`);
-    if (babelTypes.isTaggedTemplateExpression(node) && babelTypes.isIdentifier(node.tag) && TAGGED_TEMPLATE_ALLOW_LIST.has(node.tag.name)) {
-        return resolveExpression({
-            babelConfig,
-            file,
-            filename,
-            fnArguments,
-            node: node.quasi,
-            params,
-            resolver,
-            scope
-        });
-    }
-    if (babelTypes.isTemplateLiteral(node)) {
-        const resolvedExpressions = node.expressions.map((expression)=>resolveExpression({
-                babelConfig,
-                file,
-                filename,
-                fnArguments,
-                node: expression,
-                params,
-                resolver,
-                scope
-            }));
-        return node.quasis.map((quasi, idx)=>{
-            return (quasi.value.cooked || "") + (resolvedExpressions[idx] || "");
-        }).join("");
-    }
-    if (babelTypes.isLiteral(node)) {
-        if (node.type === "NullLiteral" || node.type === "RegExpLiteral") {
-            throw new Error(`Unsupported literal type: ${node.type}`);
-        }
-        return node.value.toString();
-    }
-    if (babelTypes.isIdentifier(node)) {
-        return resolveIdentifier({
-            babelConfig,
-            file,
-            filename,
-            fnArguments,
-            node,
-            params,
-            resolver,
-            scope
-        });
-    }
-    if (babelTypes.isVariableDeclarator(node)) {
-        const init = node.init ?? (babelTypes.isAssignmentPattern(node.id) && node.id.right);
-        if (!init) {
-            throw new Error(`Unsupported variable declarator`);
-        }
-        return resolveExpression({
-            babelConfig,
-            file,
-            filename,
-            fnArguments,
-            node: init,
-            resolver,
-            scope
-        });
-    }
-    if (babelTypes.isCallExpression(node) && babelTypes.isIdentifier(node.callee) && FUNCTION_WRAPPER_ALLOW_LIST.has(node.callee.name)) {
-        return resolveExpression({
-            babelConfig,
-            file,
-            filename,
-            node: node.arguments[0],
-            params,
-            resolver,
-            scope
-        });
-    }
-    if (babelTypes.isCallExpression(node)) {
-        return resolveCallExpression({
-            babelConfig,
-            file,
-            filename,
-            fnArguments,
-            node,
-            params,
-            resolver,
-            scope
-        });
-    }
-    if (babelTypes.isArrowFunctionExpression(node) || babelTypes.isFunctionDeclaration(node) || babelTypes.isFunctionExpression(node)) {
-        const newScope = new Scope(scope.path, scope);
-        for (const [i, param] of params.entries()){
-            newScope.push({
-                id: param,
-                init: fnArguments[i]
-            });
-        }
-        return resolveExpression({
-            babelConfig,
-            file,
-            filename,
-            fnArguments,
-            node: node.body,
-            params: node.params,
-            resolver,
-            scope: newScope
-        });
-    }
-    if (babelTypes.isNewExpression(node)) {
-        return resolveExpression({
-            babelConfig,
-            file,
-            filename,
-            node: node.callee,
-            resolver,
-            scope
-        });
-    }
-    if (babelTypes.isImportDefaultSpecifier(node) || babelTypes.isImportSpecifier(node)) {
-        return resolveImportSpecifier({
-            babelConfig,
-            file,
-            filename,
-            fnArguments,
-            node,
-            resolver,
-            scope
-        });
-    }
-    if (babelTypes.isAssignmentPattern(node)) {
-        return resolveExpression({
-            babelConfig,
-            file,
-            filename,
-            fnArguments,
-            node: node.right,
-            params,
-            resolver,
-            scope
-        });
-    }
-    if (babelTypes.isTSAsExpression(node)) {
-        return resolveExpression({
-            babelConfig,
-            file,
-            filename,
-            fnArguments,
-            node: node.expression,
-            params,
-            resolver,
-            scope
-        });
-    }
-    throw new Error(`Unsupported expression type: ${node.type} in ${filename}:${node.loc?.start.line}:${node.loc?.start.column}`);
-}
-function resolveIdentifier({ babelConfig, file, filename, fnArguments, node, params, resolver, scope }) {
-    const paramIndex = params.findIndex((param)=>babelTypes.isIdentifier(param) && node.name === param.name || babelTypes.isAssignmentPattern(param) && babelTypes.isIdentifier(param.left) && node.name === param.left.name);
-    let argument = fnArguments[paramIndex];
-    if (!argument && paramIndex !== -1 && babelTypes.isAssignmentPattern(params[paramIndex])) {
-        argument = params[paramIndex].right;
-    }
-    if (argument && babelTypes.isLiteral(argument)) {
-        return resolveExpression({
-            babelConfig,
-            file,
-            filename,
-            fnArguments,
-            node: argument,
-            params,
-            resolver,
-            scope
-        });
-    }
-    const binding = scope.getBinding(node.name);
-    if (binding) {
-        if (babelTypes.isIdentifier(binding.path.node)) {
-            const isSame = binding.path.node.name === node.name;
-            if (isSame) {
-                throw new Error(`Could not resolve same identifier "${node.name}" in "${filename}:${node.loc?.start.line}:${node.loc?.start.column}"`);
-            }
-        }
-        return resolveExpression({
-            babelConfig,
-            file,
-            filename,
-            fnArguments,
-            node: binding.path.node,
-            params,
-            resolver,
-            scope
-        });
-    }
-    throw new Error(`Could not find binding for node "${node.name}" in ${filename}:${node.loc?.start.line}:${node.loc?.start.column}`);
-}
-function resolveCallExpression({ babelConfig, file, filename, node, params, resolver, scope }) {
-    const { callee } = node;
-    return resolveExpression({
-        babelConfig,
-        file,
-        filename,
-        fnArguments: node.arguments,
-        node: callee,
-        params,
-        resolver,
-        scope
-    });
-}
-function resolveImportSpecifier({ babelConfig, file, filename, fnArguments, node, resolver }) {
-    let importDeclaration2;
-    traverse(file, {
-        ImportDeclaration (n) {
-            if (!babelTypes.isImportDeclaration(n.node)) {
-                return;
-            }
-            for (const specifier of n.node.specifiers){
-                if (babelTypes.isImportDefaultSpecifier(specifier) && specifier.local.loc?.identifierName === node.local.name) {
-                    importDeclaration2 = n.node;
-                    break;
-                }
-                if (specifier.local.name === node.local.name) {
-                    importDeclaration2 = n.node;
-                }
-            }
-        }
-    });
-    if (!importDeclaration2) {
-        throw new Error(`Could not find import declaration for ${node.local.name}`);
-    }
-    const importName = node.local.name;
-    const importFileName = importDeclaration2.source.value;
-    const importPath = importFileName.startsWith("./") || importFileName.startsWith("../") ? path.resolve(path.dirname(filename), importFileName) : importFileName;
-    const resolvedFile = resolver(formatPath(importPath));
-    const source = fs.readFileSync(resolvedFile);
-    const tree = parseSourceFile(source.toString(), resolvedFile, babelConfig);
-    let newScope;
-    traverse(tree, {
-        Program (p) {
-            newScope = p.scope;
-        }
-    });
-    if (!newScope) {
-        throw new Error(`Could not find scope for ${filename}`);
-    }
-    const binding = newScope.getBinding(importName);
-    if (binding) {
-        return resolveExpression({
-            babelConfig,
-            file: tree,
-            filename: resolvedFile,
-            fnArguments,
-            node: binding.path.node,
-            resolver,
-            scope: newScope
-        });
-    }
-    let namedExport;
-    let newImportName;
-    traverse(tree, {
-        ExportDeclaration (p) {
-            if (p.node.type === "ExportNamedDeclaration") {
-                for (const specifier of p.node.specifiers){
-                    if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier" && specifier.exported.name === importName) {
-                        namedExport = p.node;
-                        newImportName = specifier.exported.name;
-                    }
-                }
-            }
-        }
-    });
-    if (namedExport && newImportName) {
-        return resolveExportSpecifier({
-            babelConfig,
-            filename: resolvedFile,
-            fnArguments,
-            importName: newImportName,
-            node: namedExport,
-            resolver
-        });
-    }
-    let result;
-    traverse(tree, {
-        ExportDeclaration (p) {
-            if (p.node.type === "ExportAllDeclaration") {
-                try {
-                    result = resolveExportSpecifier({
-                        babelConfig,
-                        filename: resolvedFile,
-                        fnArguments,
-                        importName,
-                        node: p.node,
-                        resolver
-                    });
-                } catch (e) {
-                    if (e.cause !== `noBinding:${importName}`) throw e;
-                }
-            }
-        }
-    });
-    if (result) return result;
-    throw new Error(`Could not find binding for import "${importName}" in ${importFileName}`);
-}
-function resolveExportSpecifier({ babelConfig, filename, fnArguments, importName, node, resolver }) {
-    if (!node.source) {
-        throw new Error(`Could not find source for export "${importName}" in ${filename}`);
-    }
-    const importFileName = node.source.value;
-    const importPath = path.resolve(path.dirname(filename), importFileName);
-    const resolvedFile = resolver(formatPath(importPath));
-    const source = fs.readFileSync(resolvedFile);
-    const tree = parseSourceFile(source.toString(), resolvedFile, babelConfig);
-    let newScope;
-    traverse(tree, {
-        Program (p) {
-            newScope = p.scope;
-        }
-    });
-    if (!newScope) {
-        throw new Error(`Could not find scope for ${filename}`);
-    }
-    const binding = newScope.getBinding(importName);
-    if (binding) {
-        return resolveExpression({
-            babelConfig,
-            file: tree,
-            filename: resolvedFile,
-            fnArguments,
-            node: binding.path.node,
-            resolver,
-            scope: newScope
-        });
-    }
-    throw new Error(`Could not find binding for export "${importName}" in ${importFileName}`, {
-        cause: `noBinding:${importName}`
-    });
-}
-// src/typescript/types.ts
-var isRecord = (value)=>(typeof value === "object" || typeof value === "function") && !!value;
-var QueryExtractionError = class extends Error {
-    filename;
-    variable;
-    constructor({ cause, filename, variable }){
-        super(`Error while extracting query ${variable ? `from variable '${variable.id.name}' ` : ""}in ${filename}: ${isRecord(cause) && typeof cause.message === "string" ? cause.message : "Unknown error"}`);
-        this.name = "QueryExtractionError";
-        this.cause = cause;
-        this.variable = variable;
-        this.filename = filename;
-    }
-};
-var QueryEvaluationError = class extends Error {
-    filename;
-    variable;
-    constructor({ cause, filename, variable }){
-        super(`Error while evaluating query ${variable ? `from variable '${variable.id.name}' ` : ""}in ${filename}: ${isRecord(cause) && typeof cause.message === "string" ? cause.message : "Unknown error"}`);
-        this.name = "QueryEvaluationError";
-        this.cause = cause;
-        this.variable = variable;
-        this.filename = filename;
-    }
-};
-// src/typescript/findQueriesInSource.ts
-var require2 = createRequire(import.meta.url);
-var groqTagName = "groq";
-var defineQueryFunctionName = "defineQuery";
-var groqModuleName = "groq";
-var nextSanityModuleName = "next-sanity";
-var sveltekitModuleName = "@sanity/sveltekit";
-var ignoreValue = "@sanity-typegen-ignore";
-function findQueriesInSource(source, filename, babelConfig = getBabelConfig(), resolver = require2.resolve) {
-    const queries = [];
-    const errors = [];
-    const file = parseSourceFile(source, filename, babelConfig);
-    traverse2(file, {
-        // Look for variable declarations, e.g. `const myQuery = groq`... and extract the query.
-        // The variable name is used as the name of the query result type
-        VariableDeclarator (path3) {
-            const { node, scope } = path3;
-            const init = node.init;
-            const isGroqTemplateTag = babelTypes2.isTaggedTemplateExpression(init) && babelTypes2.isIdentifier(init.tag) && init.tag.name === groqTagName;
-            const isDefineQueryCall = babelTypes2.isCallExpression(init) && (isImportFrom(groqModuleName, defineQueryFunctionName, scope, init.callee) || isImportFrom(nextSanityModuleName, defineQueryFunctionName, scope, init.callee) || isImportFrom(sveltekitModuleName, defineQueryFunctionName, scope, init.callee));
-            if (babelTypes2.isIdentifier(node.id) && (isGroqTemplateTag || isDefineQueryCall)) {
-                if (declarationLeadingCommentContains(path3, ignoreValue)) {
-                    return;
-                }
-                const { end, id, start } = node;
-                const variable = {
-                    id,
-                    ...start && {
-                        start
-                    },
-                    ...end && {
-                        end
-                    }
-                };
-                try {
-                    const query = resolveExpression({
-                        babelConfig,
-                        file,
-                        filename,
-                        node: init,
-                        resolver,
-                        scope
-                    });
-                    queries.push({
-                        filename,
-                        query,
-                        variable
-                    });
-                } catch (cause) {
-                    errors.push(new QueryExtractionError({
-                        cause,
-                        filename,
-                        variable
-                    }));
-                }
-            }
-        }
-    });
-    return {
-        errors,
-        filename,
-        queries
-    };
-}
-function declarationLeadingCommentContains(path3, comment) {
-    const variableDeclaration2 = path3.find((node)=>node.isVariableDeclaration());
-    if (!variableDeclaration2) return false;
-    if (variableDeclaration2.node.leadingComments?.find((commentItem)=>commentItem.value.trim() === comment)) {
-        return true;
-    }
-    if (variableDeclaration2.parent.leadingComments?.find((commentItem)=>commentItem.value.trim() === comment)) {
-        return true;
-    }
-    return false;
-}
-function isImportFrom(moduleName, importName, scope, node) {
-    if (babelTypes2.isIdentifier(node)) {
-        const binding = scope.getBinding(node.name);
-        if (!binding) {
-            return false;
-        }
-        const { path: path3 } = binding;
-        if (babelTypes2.isImportSpecifier(path3.node)) {
-            return path3.node.importKind === "value" && path3.parentPath && babelTypes2.isImportDeclaration(path3.parentPath.node) && path3.parentPath.node.source.value === moduleName && babelTypes2.isIdentifier(path3.node.imported) && path3.node.imported.name === importName;
-        }
-        if (babelTypes2.isVariableDeclarator(path3.node)) {
-            const { init } = path3.node;
-            return babelTypes2.isCallExpression(init) && babelTypes2.isIdentifier(init.callee) && init.callee.name === "require" && babelTypes2.isStringLiteral(init.arguments[0]) && init.arguments[0].value === moduleName;
-        }
-    }
-    if (babelTypes2.isMemberExpression(node)) {
-        const { object, property } = node;
-        if (!babelTypes2.isIdentifier(object)) {
-            return false;
-        }
-        const binding = scope.getBinding(object.name);
-        if (!binding) {
-            return false;
-        }
-        const { path: path3 } = binding;
-        return babelTypes2.isIdentifier(object) && babelTypes2.isIdentifier(property) && property.name === importName && babelTypes2.isImportNamespaceSpecifier(path3.node) && path3.parentPath && babelTypes2.isImportDeclaration(path3.parentPath.node) && path3.parentPath.node.source.value === moduleName;
-    }
-    return false;
-}
-// src/typescript/helpers.ts
-import path2 from "node:path";
-import { CodeGenerator } from "@babel/generator";
-import * as t2 from "@babel/types";
-// src/typescript/constants.ts
-import * as t from "@babel/types";
-var INTERNAL_REFERENCE_SYMBOL = t.identifier("internalGroqTypeReferenceTo");
-var ALL_SANITY_SCHEMA_TYPES = t.identifier("AllSanitySchemaTypes");
-var SANITY_QUERIES = t.identifier("SanityQueries");
-var ARRAY_OF = t.identifier("ArrayOf");
-var RESERVED_IDENTIFIERS = /* @__PURE__ */ new Set();
-RESERVED_IDENTIFIERS.add(SANITY_QUERIES.name);
-RESERVED_IDENTIFIERS.add(ALL_SANITY_SCHEMA_TYPES.name);
-RESERVED_IDENTIFIERS.add(INTERNAL_REFERENCE_SYMBOL.name);
-RESERVED_IDENTIFIERS.add(ARRAY_OF.name);
-// src/typescript/helpers.ts
-function normalizePrintablePath(root, filename) {
-    const resolved = path2.resolve(root, filename);
-    return formatPath(path2.relative(root, resolved));
-}
-function normalizeGlobPattern(pattern) {
-    if (Array.isArray(pattern)) {
-        return pattern.map((p)=>formatPath(p));
-    }
-    return formatPath(pattern);
-}
-function sanitizeIdentifier(input) {
-    return `${input.replace(/^\d/, "_").replaceAll(/[^$\w]+(.)/g, (_, char)=>char.toUpperCase())}`;
-}
-function isIdentifierName(input) {
-    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(input);
-}
-function normalizeIdentifier(input) {
-    const sanitized = sanitizeIdentifier(input);
-    return `${sanitized.charAt(0).toUpperCase()}${sanitized.slice(1)}`;
-}
-function getUniqueIdentifierForName(name, currentIdentifiers) {
-    const desiredName = normalizeIdentifier(name);
-    let resultingName = desiredName;
-    let index = 2;
-    while(currentIdentifiers.has(resultingName) || RESERVED_IDENTIFIERS.has(resultingName)){
-        resultingName = `${desiredName}_${index}`;
-        index++;
-    }
-    return t2.identifier(resultingName);
-}
-function computeOnce(fn) {
-    const ref = {
-        computed: false,
-        current: void 0
-    };
-    return function() {
-        if (ref.computed) return ref.current;
-        ref.current = fn();
-        ref.computed = true;
-        return ref.current;
-    };
-}
-function weakMapMemo(fn) {
-    const cache = /* @__PURE__ */ new WeakMap();
-    const wrapped = function(arg) {
-        if (cache.has(arg)) return cache.get(arg);
-        const result = fn(arg);
-        cache.set(arg, result);
-        return result;
-    };
-    return wrapped;
-}
-function generateCode(node) {
-    return `${new CodeGenerator(node).generate().code.trim()}
-
-`;
-}
-function getFilterArrayUnionType(typeNode, predicate) {
-    if (typeNode.of.type !== "union") {
-        return typeNode;
-    }
-    return {
-        ...typeNode,
-        of: {
-            ...typeNode.of,
-            of: typeNode.of.of.filter((unionTypeNode)=>predicate(unionTypeNode))
-        }
-    };
-}
-// src/typescript/moduleResolver.ts
-import { createRequire as createRequire2 } from "node:module";
-import createDebug2 from "debug";
-import { createMatchPath, loadConfig as loadTSConfig } from "tsconfig-paths";
-var require3 = createRequire2(import.meta.url);
-var debug2 = createDebug2("sanity:codegen:moduleResolver");
-function getResolver(cwd) {
-    const tsConfig = loadTSConfig(cwd);
-    if (tsConfig.resultType === "failed") {
-        debug2("Could not load tsconfig, using default resolver: %s", tsConfig.message);
-        return require3.resolve;
-    }
-    const matchPath = createMatchPath(tsConfig.absoluteBaseUrl, tsConfig.paths, tsConfig.mainFields, tsConfig.addMatchAll);
-    const resolve2 = function(request, options) {
-        const found = matchPath(request);
-        if (found !== void 0) {
-            return require3.resolve(found, options);
-        }
-        return require3.resolve(request, options);
-    };
-    resolve2.paths = (request)=>{
-        return require3.resolve.paths(request);
-    };
-    return resolve2;
-}
-// src/typescript/findQueriesInPath.ts
-var debug3 = createDebug3("sanity:codegen:findQueries:debug");
-function findQueriesInPath({ babelOptions = getBabelConfig(), path: path3, resolver = getResolver() }) {
-    const queryNames = /* @__PURE__ */ new Set();
-    debug3(`Globing ${path3}`);
-    const normalizedPath = normalizeGlobPattern(path3);
-    const files = glob.sync(normalizedPath, {
-        absolute: false,
-        ignore: [
-            "**/node_modules/**"
-        ],
-        // we never want to look in node_modules
-        onlyFiles: true
-    }).toSorted();
-    async function* getQueries() {
-        for (const filename of files){
-            if (typeof filename !== "string") {
-                continue;
-            }
-            debug3(`Found file "${filename}"`);
-            try {
-                const source = await fs2.readFile(filename, "utf8");
-                const pluckedModuleResult = findQueriesInSource(source, filename, babelOptions, resolver);
-                for (const { variable } of pluckedModuleResult.queries){
-                    if (queryNames.has(variable.id.name)) {
-                        throw new Error(`Duplicate query name found: "${variable.id.name}". Query names must be unique across all files.`);
-                    }
-                    queryNames.add(variable.id.name);
-                }
-                yield pluckedModuleResult;
-            } catch (cause) {
-                debug3(`Error in file "${filename}"`, cause);
-                yield {
-                    errors: [
-                        new QueryExtractionError({
-                            cause,
-                            filename
-                        })
-                    ],
-                    filename,
-                    queries: []
-                };
-            }
-        }
-    }
-    return {
-        files,
-        queries: getQueries()
-    };
-}
-// src/typescript/registerBabel.ts
-import register from "@babel/register";
-function registerBabel(babelOptions) {
-    const options = babelOptions || getBabelConfig();
-    register({
-        ...options,
-        extensions: [
-            ".ts",
-            ".tsx",
-            ".js",
-            ".jsx",
-            ".mjs",
-            ".cjs"
-        ]
-    });
-}
-// src/typescript/typeGenerator.ts
-import process from "node:process";
-import * as t4 from "@babel/types";
-import { createSelector } from "reselect";
-// src/casing.ts
-function resultSuffix(variableName) {
-    if (!variableName) return "result";
-    const isUpperSnake = /^[A-Z0-9_]+$/.test(variableName);
-    const isSnake = /^[a-z0-9_]+$/.test(variableName) && variableName.includes("_");
-    const isCamel = /^[a-z][A-Za-z0-9]*$/.test(variableName);
-    if (isCamel) {
-        return `${variableName}Result`;
-    }
-    if (isUpperSnake) {
-        return `${variableName}_RESULT`;
-    }
-    if (isSnake) {
-        return `${variableName}_result`;
-    }
-    const cleaned = variableName.replaceAll(/[^A-Za-z0-9]/g, "");
-    return `${cleaned}Result`;
-}
-// src/typescript/schemaTypeGenerator.ts
-import * as t3 from "@babel/types";
-import { typeEvaluate } from "groq-js";
-// src/safeParseQuery.ts
-import { parse as parse2 } from "groq-js";
-function safeParseQuery(query) {
-    const params = {};
-    for (const param of extractSliceParams(query)){
-        params[param] = 0;
-    }
-    return parse2(query, {
-        params
-    });
-}
-function* extractSliceParams(query) {
-    const sliceRegex = /\[(\$(\w+)|\d)\.\.\.?(\$(\w+)|\d)\]/g;
-    const matches = query.matchAll(sliceRegex);
-    if (!matches) {
-        return;
-    }
-    for (const match of matches){
-        const start = match[1] === `$${match[2]}` ? match[2] : null;
-        if (start !== null) {
-            yield start;
-        }
-        const end = match[3] === `$${match[4]}` ? match[4] : null;
-        if (end !== null) {
-            yield end;
-        }
-    }
-}
-// src/typescript/schemaTypeGenerator.ts
-var SchemaTypeGenerator = class {
-    schema;
-    evaluateQuery = weakMapMemo(// eslint-disable-next-line unicorn/consistent-function-scoping
-    ({ query })=>{
-        const ast = safeParseQuery(query);
-        const typeNode = typeEvaluate(ast, this.schema);
-        const tsType = this.generateTsType(typeNode);
-        const stats = walkAndCountQueryTypeNodeStats(typeNode);
-        return {
-            stats,
-            tsType
-        };
-    });
-    identifiers = /* @__PURE__ */ new Map();
-    tsTypes = /* @__PURE__ */ new Map();
-    constructor(schema){
-        this.schema = schema;
-        const uniqueTypeNames = /* @__PURE__ */ new Set();
-        for (const type of schema){
-            if (uniqueTypeNames.has(type.name)) {
-                throw new Error(`Duplicate type name "${type.name}" in schema. Type names must be unique within the same schema.`);
-            }
-            uniqueTypeNames.add(type.name);
-        }
-        for (const type of schema){
-            const currentIdentifierNames = new Set([
-                ...this.identifiers.values()
-            ].map((id)=>id.name));
-            const uniqueIdentifier = getUniqueIdentifierForName(type.name, currentIdentifierNames);
-            this.identifiers.set(type.name, uniqueIdentifier);
-        }
-        for (const type of schema){
-            this.tsTypes.set(type.name, this.generateTsType(type));
-        }
-    }
-    getType(typeName) {
-        const tsType = this.tsTypes.get(typeName);
-        const id = this.identifiers.get(typeName);
-        if (tsType && id) return {
-            id,
-            tsType
-        };
-        return void 0;
-    }
-    hasType(typeName) {
-        return this.tsTypes.has(typeName);
-    }
-    *[Symbol.iterator]() {
-        for (const { name } of this.schema){
-            yield {
-                name,
-                ...this.getType(name)
-            };
-        }
-    }
-    typeNames() {
-        return this.schema.map((schemaType)=>schemaType.name);
-    }
-    /**
-   * Helper function used to generate TS types for arrays of inline types, or arrays of inline types
-   * wrapped in the ArrayOf wrapper that adds _key prop
-   */ generateArrayOfTsType(typeNode) {
-        const typeNodes = this.generateTsType(typeNode.of);
-        return t3.tsTypeReference(ARRAY_OF, t3.tsTypeParameterInstantiation([
-            typeNodes
-        ]));
-    }
-    // Helper function used to generate TS types for array type nodes.
-    generateArrayTsType(typeNode) {
-        if (typeNode.of.type === "inline") {
-            return this.generateArrayOfTsType(typeNode);
-        }
-        if (typeNode.of.type !== "union") {
-            const typeNodes = this.generateTsType(typeNode.of);
-            return t3.tsTypeReference(t3.identifier("Array"), t3.tsTypeParameterInstantiation([
-                typeNodes
-            ]));
-        }
-        if (typeNode.of.of.every((unionTypeNode)=>unionTypeNode.type !== "inline")) {
-            const typeNodes = this.generateTsType(typeNode.of);
-            return t3.tsTypeReference(t3.identifier("Array"), t3.tsTypeParameterInstantiation([
-                typeNodes
-            ]));
-        }
-        if (typeNode.of.of.every((unionMember)=>unionMember.type === "inline")) {
-            return this.generateArrayOfTsType(typeNode);
-        }
-        const arrayOfNonInline = getFilterArrayUnionType(typeNode, (member)=>member.type !== "inline");
-        const arrayOfInline = getFilterArrayUnionType(typeNode, (member)=>member.type === "inline");
-        return t3.tsUnionType([
-            this.generateArrayTsType(arrayOfNonInline),
-            this.generateArrayTsType(arrayOfInline)
-        ]);
-    }
-    // Helper function used to generate TS types for document type nodes.
-    generateDocumentTsType(document) {
-        const props = Object.entries(document.attributes).map(([key, node])=>this.generateTsObjectProperty(key, node));
-        return t3.tsTypeLiteral(props);
-    }
-    generateInlineTsType(typeNode) {
-        const id = this.identifiers.get(typeNode.name);
-        if (!id) {
-            return t3.addComment(t3.tsUnknownKeyword(), "trailing", ` Unable to locate the referenced type "${typeNode.name}" in schema`, true);
-        }
-        return t3.tsTypeReference(id);
-    }
-    // Helper function used to generate TS types for object type nodes.
-    generateObjectTsType(typeNode) {
-        const props = [];
-        for (const [key, attribute] of Object.entries(typeNode.attributes)){
-            props.push(this.generateTsObjectProperty(key, attribute));
-        }
-        const rest = typeNode.rest;
-        if (rest) {
-            switch(rest.type){
-                case "inline":
-                    {
-                        const resolved = this.generateInlineTsType(rest);
-                        if (t3.isTSUnknownKeyword(resolved)) return resolved;
-                        return t3.tsIntersectionType([
-                            t3.tsTypeLiteral(props),
-                            resolved
-                        ]);
-                    }
-                case "object":
-                    {
-                        for (const [key, attribute] of Object.entries(rest.attributes)){
-                            props.push(this.generateTsObjectProperty(key, attribute));
-                        }
-                        break;
-                    }
-                case "unknown":
-                    {
-                        return t3.tsUnknownKeyword();
-                    }
-                default:
-                    {
-                        throw new Error(`Type "${rest.type}" not found in schema`);
-                    }
-            }
-        }
-        if (typeNode.dereferencesTo) {
-            const derefType = Object.assign(t3.tsPropertySignature(INTERNAL_REFERENCE_SYMBOL, t3.tsTypeAnnotation(t3.tsLiteralType(t3.stringLiteral(typeNode.dereferencesTo)))), {
-                computed: true,
-                optional: true
-            });
-            props.push(derefType);
-        }
-        return t3.tsTypeLiteral(props);
-    }
-    // Helper function used to generate TS types for object properties.
-    generateTsObjectProperty(key, attribute) {
-        const type = this.generateTsType(attribute.value);
-        const keyNode = isIdentifierName(key) ? t3.identifier(key) : t3.stringLiteral(key);
-        const propertySignature = t3.tsPropertySignature(keyNode, t3.tsTypeAnnotation(type));
-        propertySignature.optional = attribute.optional;
-        return propertySignature;
-    }
-    generateTsType(typeNode) {
-        switch(typeNode.type){
-            case "array":
-                {
-                    return this.generateArrayTsType(typeNode);
-                }
-            case "boolean":
-                {
-                    if (typeNode.value !== void 0) {
-                        return t3.tsLiteralType(t3.booleanLiteral(typeNode.value));
-                    }
-                    return t3.tsBooleanKeyword();
-                }
-            case "document":
-                {
-                    return this.generateDocumentTsType(typeNode);
-                }
-            case "inline":
-                {
-                    return this.generateInlineTsType(typeNode);
-                }
-            case "null":
-                {
-                    return t3.tsNullKeyword();
-                }
-            case "number":
-                {
-                    if (typeNode.value !== void 0) {
-                        return t3.tsLiteralType(t3.numericLiteral(typeNode.value));
-                    }
-                    return t3.tsNumberKeyword();
-                }
-            case "object":
-                {
-                    return this.generateObjectTsType(typeNode);
-                }
-            case "string":
-                {
-                    if (typeNode.value !== void 0) {
-                        return t3.tsLiteralType(t3.stringLiteral(typeNode.value));
-                    }
-                    return t3.tsStringKeyword();
-                }
-            case "type":
-                {
-                    return this.generateTsType(typeNode.value);
-                }
-            case "union":
-                {
-                    return this.generateUnionTsType(typeNode);
-                }
-            case "unknown":
-                {
-                    return t3.tsUnknownKeyword();
-                }
-            default:
-                {
-                    throw new Error(`Encountered unsupported node type "${typeNode.type}" while generating schema types`);
-                }
-        }
-    }
-    // Helper function used to generate TS types for union type nodes.
-    generateUnionTsType(typeNode) {
-        if (typeNode.of.length === 0) return t3.tsNeverKeyword();
-        if (typeNode.of.length === 1) return this.generateTsType(typeNode.of[0]);
-        return t3.tsUnionType(typeNode.of.map((node)=>this.generateTsType(node)));
-    }
-};
-function walkAndCountQueryTypeNodeStats(typeNode) {
-    switch(typeNode.type){
-        case "array":
-            {
-                const acc = walkAndCountQueryTypeNodeStats(typeNode.of);
-                acc.allTypes += 1;
-                return acc;
-            }
-        case "object":
-            {
-                if (typeNode.rest && typeNode.rest.type === "unknown") {
-                    return {
-                        allTypes: 2,
-                        emptyUnions: 0,
-                        unknownTypes: 1
-                    };
-                }
-                const restStats = typeNode.rest ? walkAndCountQueryTypeNodeStats(typeNode.rest) : {
-                    allTypes: 0,
-                    emptyUnions: 0,
-                    unknownTypes: 0
-                };
-                restStats.allTypes += 1;
-                const attrs = Object.values(typeNode.attributes);
-                let acc = restStats;
-                for (const attribute of attrs){
-                    const { allTypes, emptyUnions, unknownTypes } = walkAndCountQueryTypeNodeStats(attribute.value);
-                    acc = {
-                        allTypes: acc.allTypes + allTypes,
-                        emptyUnions: acc.emptyUnions + emptyUnions,
-                        unknownTypes: acc.unknownTypes + unknownTypes
-                    };
-                }
-                return acc;
-            }
-        case "union":
-            {
-                if (typeNode.of.length === 0) {
-                    return {
-                        allTypes: 1,
-                        emptyUnions: 1,
-                        unknownTypes: 0
-                    };
-                }
-                let acc = {
-                    allTypes: 1,
-                    emptyUnions: 0,
-                    unknownTypes: 0
-                };
-                for (const type of typeNode.of){
-                    const { allTypes, emptyUnions, unknownTypes } = walkAndCountQueryTypeNodeStats(type);
-                    acc = {
-                        allTypes: acc.allTypes + allTypes,
-                        emptyUnions: acc.emptyUnions + emptyUnions,
-                        unknownTypes: acc.unknownTypes + unknownTypes
-                    };
-                }
-                return acc;
-            }
-        case "unknown":
-            {
-                return {
-                    allTypes: 1,
-                    emptyUnions: 0,
-                    unknownTypes: 1
-                };
-            }
-        default:
-            {
-                return {
-                    allTypes: 1,
-                    emptyUnions: 0,
-                    unknownTypes: 0
-                };
-            }
-    }
-}
-// src/typescript/typeGenerator.ts
-var TypeGenerator = class _TypeGenerator {
-    getSchemaTypeGenerator = createSelector([
-        (options)=>options.schema
-    ], (schema)=>new SchemaTypeGenerator(schema));
-    getSchemaTypeDeclarations = createSelector([
-        (options)=>options.root,
-        (options)=>options.schemaPath,
-        this.getSchemaTypeGenerator
-    ], (root = process.cwd(), schemaPath, schema)=>[
-            ...schema
-        ].map(({ id, name, tsType }, index)=>{
-            const typeAlias = t4.tsTypeAliasDeclaration(id, null, tsType);
-            let ast = t4.exportNamedDeclaration(typeAlias);
-            if (index === 0 && schemaPath) {
-                ast = t4.addComments(ast, "leading", [
-                    {
-                        type: "CommentLine",
-                        value: ` Source: ${normalizePrintablePath(root, schemaPath)}`
-                    }
-                ]);
-            }
-            const code = generateCode(ast);
-            return {
-                ast,
-                code,
-                id,
-                name,
-                tsType
-            };
-        }));
-    getAllSanitySchemaTypesDeclaration = createSelector([
-        this.getSchemaTypeDeclarations
-    ], (schemaTypes)=>{
-        const ast = t4.exportNamedDeclaration(t4.tsTypeAliasDeclaration(ALL_SANITY_SCHEMA_TYPES, null, schemaTypes.length > 0 ? t4.tsUnionType(schemaTypes.map(({ id })=>t4.tsTypeReference(id))) : t4.tsNeverKeyword()));
-        const code = generateCode(ast);
-        return {
-            ast,
-            code,
-            id: ALL_SANITY_SCHEMA_TYPES
-        };
-    });
-    getArrayOfDeclaration = computeOnce(()=>{
-        const typeParam = t4.tsTypeParameter(null, null, "T");
-        const intersectionType = t4.tsIntersectionType([
-            t4.tsTypeReference(t4.identifier("T")),
-            t4.tsTypeLiteral([
-                t4.tsPropertySignature(t4.identifier("_key"), t4.tsTypeAnnotation(t4.tsStringKeyword()))
-            ])
-        ]);
-        const arrayType = t4.tsTypeReference(t4.identifier("Array"), t4.tsTypeParameterInstantiation([
-            intersectionType
-        ]));
-        const ast = t4.tsTypeAliasDeclaration(ARRAY_OF, t4.tsTypeParameterDeclaration([
-            typeParam
-        ]), arrayType);
-        const code = generateCode(ast);
-        return {
-            ast,
-            code,
-            id: ARRAY_OF
-        };
-    });
-    getInternalReferenceSymbolDeclaration = computeOnce(()=>{
-        const typeOperator = t4.tsTypeOperator(t4.tsSymbolKeyword(), "unique");
-        const id = INTERNAL_REFERENCE_SYMBOL;
-        id.typeAnnotation = t4.tsTypeAnnotation(typeOperator);
-        const declaration = t4.variableDeclaration("const", [
-            t4.variableDeclarator(id)
-        ]);
-        declaration.declare = true;
-        const ast = t4.exportNamedDeclaration(declaration);
-        const code = generateCode(ast);
-        return {
-            ast,
-            code,
-            id
-        };
-    });
-    static async getEvaluatedModules({ queries: extractedModules, reporter: report, root = process.cwd(), schemaTypeDeclarations, schemaTypeGenerator }) {
-        if (!extractedModules) {
-            report?.stream.evaluatedModules.end();
-            return [];
-        }
-        const currentIdentifiers = new Set(schemaTypeDeclarations.map(({ id })=>id.name));
-        const evaluatedModuleResults = [];
-        for await (const { filename, ...extractedModule } of extractedModules){
-            const queries = [];
-            const errors = [
-                ...extractedModule.errors
-            ];
-            for (const extractedQuery of extractedModule.queries){
-                const { variable } = extractedQuery;
-                try {
-                    const { stats, tsType } = schemaTypeGenerator.evaluateQuery(extractedQuery);
-                    const id = getUniqueIdentifierForName(resultSuffix(variable.id.name), currentIdentifiers);
-                    const typeAlias = t4.tsTypeAliasDeclaration(id, null, tsType);
-                    const trimmedQuery = extractedQuery.query.replaceAll(/(\r\n|\n|\r)/gm, "").trim();
-                    const ast = t4.addComments(t4.exportNamedDeclaration(typeAlias), "leading", [
-                        {
-                            type: "CommentLine",
-                            value: ` Source: ${normalizePrintablePath(root, filename)}`
-                        },
-                        {
-                            type: "CommentLine",
-                            value: ` Variable: ${variable.id.name}`
-                        },
-                        {
-                            type: "CommentLine",
-                            value: ` Query: ${trimmedQuery}`
-                        }
-                    ]);
-                    const evaluatedQueryResult = {
-                        ast,
-                        code: generateCode(ast),
-                        id,
-                        stats,
-                        tsType,
-                        ...extractedQuery
-                    };
-                    currentIdentifiers.add(id.name);
-                    queries.push(evaluatedQueryResult);
-                } catch (cause) {
-                    errors.push(new QueryEvaluationError({
-                        cause,
-                        filename,
-                        variable
-                    }));
-                }
-            }
-            const evaluatedModule = {
-                errors,
-                filename,
-                queries
-            };
-            report?.stream.evaluatedModules.emit(evaluatedModule);
-            evaluatedModuleResults.push(evaluatedModule);
-        }
-        report?.stream.evaluatedModules.end();
-        return evaluatedModuleResults;
-    }
-    static async getQueryMapDeclaration({ evaluatedModules, overloadClientMethods = true }) {
-        if (!overloadClientMethods) return {
-            ast: t4.program([]),
-            code: ""
-        };
-        const queries = evaluatedModules.flatMap((module)=>module.queries);
-        if (queries.length === 0) return {
-            ast: t4.program([]),
-            code: ""
-        };
-        const typesByQuerystring = {};
-        for (const { id, query } of queries){
-            typesByQuerystring[query] ??= [];
-            typesByQuerystring[query].push(id.name);
-        }
-        const queryReturnInterface = t4.tsInterfaceDeclaration(SANITY_QUERIES, null, [], t4.tsInterfaceBody(Object.entries(typesByQuerystring).map(([query, types])=>{
-            return t4.tsPropertySignature(t4.stringLiteral(query), t4.tsTypeAnnotation(types.length > 0 ? t4.tsUnionType(types.map((type)=>t4.tsTypeReference(t4.identifier(type)))) : t4.tsNeverKeyword()));
-        })));
-        const declareModule2 = t4.declareModule(t4.stringLiteral("@sanity/client"), t4.blockStatement([
-            queryReturnInterface
-        ]));
-        const clientImport = t4.addComments(t4.importDeclaration([], t4.stringLiteral("@sanity/client")), "leading", [
-            {
-                type: "CommentLine",
-                value: " Query TypeMap"
-            }
-        ]);
-        const ast = t4.program([
-            clientImport,
-            declareModule2
-        ]);
-        const code = generateCode(ast);
-        return {
-            ast,
-            code
-        };
-    }
-    async generateTypes(options) {
-        const { reporter: report } = options;
-        const internalReferenceSymbol = this.getInternalReferenceSymbolDeclaration();
-        const arrayOfDeclaration = this.getArrayOfDeclaration();
-        const schemaTypeDeclarations = this.getSchemaTypeDeclarations(options);
-        const allSanitySchemaTypesDeclaration = this.getAllSanitySchemaTypesDeclaration(options);
-        report?.event.generatedSchemaTypes({
-            allSanitySchemaTypesDeclaration,
-            internalReferenceSymbol,
-            schemaTypeDeclarations
-        });
-        const program2 = t4.program([]);
-        let code = "";
-        for (const declaration of schemaTypeDeclarations){
-            program2.body.push(declaration.ast);
-            code += declaration.code;
-        }
-        program2.body.push(allSanitySchemaTypesDeclaration.ast);
-        code += allSanitySchemaTypesDeclaration.code;
-        program2.body.push(internalReferenceSymbol.ast);
-        code += internalReferenceSymbol.code;
-        program2.body.push(arrayOfDeclaration.ast);
-        code += arrayOfDeclaration.code;
-        const evaluatedModules = await _TypeGenerator.getEvaluatedModules({
-            ...options,
-            schemaTypeDeclarations,
-            schemaTypeGenerator: this.getSchemaTypeGenerator(options)
-        });
-        for (const { queries } of evaluatedModules){
-            for (const query of queries){
-                program2.body.push(query.ast);
-                code += query.code;
-            }
-        }
-        const queryMapDeclaration = await _TypeGenerator.getQueryMapDeclaration({
-            ...options,
-            evaluatedModules
-        });
-        program2.body.push(...queryMapDeclaration.ast.body);
-        code += queryMapDeclaration.code;
-        report?.event.generatedQueryTypes({
-            queryMapDeclaration
-        });
-        return {
-            ast: program2,
-            code
-        };
-    }
-};
-// src/actions/typegenGenerate.worker.ts
+import { stat } from 'node:fs/promises';
+import { isAbsolute, join } from 'node:path';
+import { isMainThread, parentPort, workerData } from 'node:worker_threads';
+import { WorkerChannelReporter } from '@sanity/worker-channels';
+import { readSchema } from '../readSchema.js';
+import { findQueriesInPath } from '../typescript/findQueriesInPath.js';
+import { getResolver } from '../typescript/moduleResolver.js';
+import { registerBabel } from '../typescript/registerBabel.js';
+import { TypeGenerator } from '../typescript/typeGenerator.js';
 if (isMainThread || !parentPort) {
-    throw new Error("This module must be run as a worker thread");
+    throw new Error('This module must be run as a worker thread');
 }
 registerBabel();
 async function main({ overloadClientMethods, schemaPath, searchPath, workDir }) {
     const report = WorkerChannelReporter.from(parentPort);
-    const fullPath = isAbsolute(schemaPath) ? schemaPath : join2(workDir, schemaPath);
+    const fullPath = isAbsolute(schemaPath) ? schemaPath : join(workDir, schemaPath);
     try {
         const schemaStats = await stat(fullPath);
         if (!schemaStats.isFile()) {
             throw new Error(`Schema path is not a file: ${schemaPath}`);
         }
     } catch (err) {
-        if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-            const hint = schemaPath === "./schema.json" ? ` - did you run "sanity schema extract"?` : "";
+        if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+            // If the user has not provided a specific schema path (eg we're using the default), give some help
+            const hint = schemaPath === './schema.json' ? ` - did you run "sanity schema extract"?` : '';
             throw new Error(`Schema file not found: ${fullPath}${hint}`, {
                 cause: err
             });