@mintlify/previewing 4.0.1256 → 4.0.1257

package/dist/__tests__/docs-config-cache.test.js

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it } from 'vitest';
-import { clearDocsConfigCaches, getDocsConfigApiHash, getDocsConfigNavigationHash, getVariablesHash, hasDocsConfigApiChanged, hasDocsConfigNavigationChanged, hasNavigationApiReference, hasDocsConfigVariablesChanged, updateDocsConfigHashCache, } from '../local-preview/listener/docs-config-cache.js';
+import { clearDocsConfigCaches, getDocsConfigApiHash, getDocsConfigNavigationHash, getVariablesHash, hasDocsConfigApiChanged, hasDocsConfigNavigationChanged, hasNavigationApiReference, hadDocsConfigApiReference, hasDocsConfigVariablesChanged, updateDocsConfigHashCache, } from '../local-preview/listener/docs-config-cache.js';
 const createDocsConfig = (page) => ({
     $schema: 'https://mintlify.com/docs.json',
     name: 'Mintlify',
@@ -33,7 +33,7 @@ describe('docsConfigCache', () => {
         expect(hasDocsConfigNavigationChanged(getDocsConfigNavigationHash(createDocsConfig('new-page')))).toBe(true);
         expect(hasDocsConfigVariablesChanged(getVariablesHash({ product: 'Mint' }))).toBe(true);
     });
-    it('detects openapi and asyncapi references anywhere in navigation', () => {
+    it('detects API references anywhere in navigation', () => {
         expect(hasNavigationApiReference({
             groups: [
                 {
@@ -69,6 +69,14 @@ describe('docsConfigCache', () => {
                 },
             ],
         })).toBe(true);
+        expect(hasNavigationApiReference({
+            tabs: [
+                {
+                    tab: 'GraphQL',
+                    graphql: { source: 'schema.graphql', directory: 'reference' },
+                },
+            ],
+        })).toBe(true);
     });
     it('allows plain MDX navigation through the navigation fast path', () => {
         expect(hasNavigationApiReference({
@@ -80,4 +88,12 @@ describe('docsConfigCache', () => {
             ],
         })).toBe(false);
     });
+    it('remembers API references so removing the last generated source triggers cleanup', () => {
+        const docsConfig = {
+            ...createDocsConfig('raw-page'),
+            navigation: { tabs: [{ tab: 'GraphQL', graphql: 'schema.graphql' }] },
+        };
+        updateDocsConfigHashCache(docsConfig);
+        expect(hadDocsConfigApiReference()).toBe(true);
+    });
 });

package/dist/__tests__/get-docs-state.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/get-docs-state.test.js

@@ -0,0 +1,70 @@
+import { access, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { getDocsState } from '../local-preview/listener/getDocsState.js';
+describe('getDocsState', () => {
+    let contentDirectory;
+    let clientDirectory;
+    beforeEach(async () => {
+        contentDirectory = await mkdtemp(path.join(os.tmpdir(), 'preview-content-'));
+        clientDirectory = await mkdtemp(path.join(os.tmpdir(), 'preview-client-'));
+    });
+    afterEach(async () => {
+        await Promise.all([
+            rm(contentDirectory, { recursive: true, force: true }),
+            rm(clientDirectory, { recursive: true, force: true }),
+        ]);
+    });
+    it('rejects case-insensitive GraphQL and AsyncAPI collisions before overwriting either page', async () => {
+        await writeFile(path.join(contentDirectory, 'schema.graphql'), 'type Query { ping: String }');
+        await writeFile(path.join(contentDirectory, 'asyncapi.json'), JSON.stringify({
+            asyncapi: '3.0.0',
+            info: { title: 'Events', version: '1.0.0' },
+            channels: {
+                ping: {
+                    address: 'ping',
+                    tags: [{ name: 'Queries' }],
+                    messages: { ping: { payload: { type: 'string' } } },
+                },
+            },
+            operations: {
+                ping: {
+                    action: 'send',
+                    channel: { $ref: '#/channels/ping' },
+                    messages: [{ $ref: '#/channels/ping/messages/ping' }],
+                },
+            },
+        }));
+        await writeFile(path.join(contentDirectory, 'docs.json'), JSON.stringify({
+            theme: 'mint',
+            name: 'Preview collision',
+            colors: { primary: '#000000' },
+            navigation: {
+                tabs: [
+                    {
+                        tab: 'GraphQL',
+                        graphql: { source: 'schema.graphql', directory: 'API' },
+                    },
+                    {
+                        tab: 'AsyncAPI',
+                        asyncapi: { source: 'asyncapi.json', directory: 'api' },
+                    },
+                ],
+            },
+        }));
+        const graphqlPath = path.join(clientDirectory, 'src/_props/API/queries/ping.mdx');
+        const asyncApiPath = path.join(clientDirectory, 'src/_props/api/queries/ping.mdx');
+        await Promise.all([
+            mkdir(path.dirname(graphqlPath), { recursive: true }),
+            mkdir(path.dirname(asyncApiPath), { recursive: true }),
+        ]);
+        await Promise.all([
+            writeFile(graphqlPath, 'existing page'),
+            writeFile(asyncApiPath, 'existing page'),
+        ]);
+        await expect(getDocsState(undefined, { contentDirectory, clientDirectory })).rejects.toThrow('Generated GraphQL route');
+        await expect(readFile(graphqlPath, 'utf8')).resolves.toBe('existing page');
+        await expect(readFile(asyncApiPath, 'utf8')).resolves.toBe('existing page');
+        await expect(access(path.join(clientDirectory, 'src/_props/graphql-data.json'))).rejects.toMatchObject({ code: 'ENOENT' });
+    });
+});

package/dist/__tests__/referencedFiles.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/referencedFiles.test.js

@@ -0,0 +1,23 @@
+import path from 'path';
+import { getLocalGraphqlSources, shouldRegenerateGraphqlSource, } from '../local-preview/listener/referencedFiles.js';
+describe('getLocalGraphqlSources', () => {
+    it('tracks configured local schema paths regardless of extension', () => {
+        expect(getLocalGraphqlSources({
+            navigation: {
+                tabs: [
+                    {
+                        tab: 'API',
+                        graphql: { source: '/schemas/./nested/../schema.custom', directory: 'api' },
+                    },
+                    { tab: 'Remote', graphql: 'HTTPS://example.com/schema.graphql' },
+                ],
+            },
+        })).toEqual([path.normalize('schemas/schema.custom')]);
+    });
+    it('rebuilds only configured GraphQL sources', () => {
+        const configuredSources = new Set([path.normalize('schemas/schema.custom')]);
+        expect(shouldRegenerateGraphqlSource('/schemas/./schema.custom', configuredSources)).toBe(true);
+        expect(shouldRegenerateGraphqlSource('schema.graphql', configuredSources)).toBe(false);
+        expect(shouldRegenerateGraphqlSource('unrelated.txt', configuredSources)).toBe(false);
+    });
+});

package/dist/local-preview/listener/docs-config-cache.d.ts

@@ -3,6 +3,7 @@ export declare const getVariablesHash: (variables: Record<string, string> | unde
 export declare const getDocsConfigApiHash: (docsConfig: DocsConfig) => string;
 export declare const getDocsConfigNavigationHash: (docsConfig: DocsConfig) => string;
 export declare const updateDocsConfigHashCache: (docsConfig: DocsConfig) => void;
+export declare const hadDocsConfigApiReference: () => boolean;
 export declare const hasNavigationApiReference: (value: unknown) => boolean;
 export declare const hasDocsConfigApiChanged: (newApiHash: string) => boolean;
 export declare const hasDocsConfigNavigationChanged: (newNavigationHash: string) => boolean;

package/dist/local-preview/listener/docs-config-cache.js

@@ -1,6 +1,7 @@
 let docsConfigVariablesHash;
 let docsConfigApiHash;
 let docsConfigNavigationHash;
+let docsConfigHadApiReference = false;
 const getJsonHash = (value) => {
     return JSON.stringify(value ?? {});
 };
@@ -17,13 +18,17 @@ export const updateDocsConfigHashCache = (docsConfig) => {
     docsConfigVariablesHash = getVariablesHash(docsConfig.variables);
     docsConfigApiHash = getDocsConfigApiHash(docsConfig);
     docsConfigNavigationHash = getDocsConfigNavigationHash(docsConfig);
+    docsConfigHadApiReference =
+        docsConfig.api != null || hasNavigationApiReference(docsConfig.navigation);
 };
+export const hadDocsConfigApiReference = () => docsConfigHadApiReference;
 export const hasNavigationApiReference = (value) => {
     if (value == null || typeof value !== 'object') {
         return false;
     }
     if (Object.prototype.hasOwnProperty.call(value, 'openapi') ||
-        Object.prototype.hasOwnProperty.call(value, 'asyncapi')) {
+        Object.prototype.hasOwnProperty.call(value, 'asyncapi') ||
+        Object.prototype.hasOwnProperty.call(value, 'graphql')) {
         return true;
     }
     return Object.values(value).some(hasNavigationApiReference);
@@ -41,4 +46,5 @@ export const clearDocsConfigCaches = () => {
     docsConfigVariablesHash = undefined;
     docsConfigApiHash = undefined;
     docsConfigNavigationHash = undefined;
+    docsConfigHadApiReference = false;
 };

package/dist/local-preview/listener/getDocsState.d.ts

@@ -1,6 +1,9 @@
 import type { DecoratedNavigationPage, MintConfig, OpenApiFile } from '@mintlify/models';
 import { DocsConfig } from '@mintlify/validation';
-export declare const getDocsState: (onError?: (message: string) => void) => Promise<{
+export declare const getDocsState: (onError?: (message: string) => void, { contentDirectory, clientDirectory, }?: {
+    contentDirectory?: string;
+    clientDirectory?: string;
+}) => Promise<{
     mintConfig?: MintConfig;
     pagesAcc: Record<string, DecoratedNavigationPage>;
     openApiFiles: OpenApiFile[];

package/dist/local-preview/listener/getDocsState.js

@@ -1,31 +1,43 @@
-import { generateOpenApiAnchorsOrTabs, categorizeFilePaths, generateOpenApiDivisions, getMintIgnore, MintConfigUpdater, DocsConfigUpdater, warnInvalidSpecFiles, } from '@mintlify/prebuild';
+import { generateOpenApiAnchorsOrTabs, categorizeFilePaths, generateOpenApiDivisions, generateAsyncApiDivisions, generateGraphqlDivisionsFromDocsConfig, getMintIgnore, MintConfigUpdater, DocsConfigUpdater, warnInvalidSpecFiles, loadGraphqlSdlSource, writeGraphqlArtifacts, } from '@mintlify/prebuild';
 import { upgradeToDocsConfig } from '@mintlify/validation';
 import fse from 'fs-extra';
 import { join } from 'path';
 import { CMD_EXEC_PATH, CLIENT_PATH } from '../../constants.js';
-export const getDocsState = async (onError) => {
-    const mintIgnore = await getMintIgnore(CMD_EXEC_PATH);
-    const { openApiFiles, invalidSpecFiles } = await categorizeFilePaths(CMD_EXEC_PATH, mintIgnore);
+export const getDocsState = async (onError, { contentDirectory = CMD_EXEC_PATH, clientDirectory = CLIENT_PATH, } = {}) => {
+    const mintIgnore = await getMintIgnore(contentDirectory);
+    const { openApiFiles, asyncApiFiles, invalidSpecFiles } = await categorizeFilePaths(contentDirectory, mintIgnore);
+    let mintConfig;
+    let docsConfig;
+    let loadedMintConfig;
     try {
-        const mintConfig = await MintConfigUpdater.getConfig(join(CMD_EXEC_PATH, 'mint.json'), false, CMD_EXEC_PATH, onError);
-        const docsConfig = upgradeToDocsConfig(mintConfig);
-        const { mintConfig: newMintConfig } = await generateOpenApiAnchorsOrTabs(mintConfig, openApiFiles, CLIENT_PATH, undefined, invalidSpecFiles);
-        const { newDocsConfig, pagesAcc, openApiFiles: newOpenApiFiles, } = await generateOpenApiDivisions(docsConfig, openApiFiles, CLIENT_PATH, undefined, invalidSpecFiles);
-        warnInvalidSpecFiles(invalidSpecFiles);
-        return {
-            mintConfig: newMintConfig,
-            pagesAcc,
-            openApiFiles: newOpenApiFiles,
-            docsConfig: newDocsConfig,
-        };
+        loadedMintConfig = await MintConfigUpdater.getConfig(join(contentDirectory, 'mint.json'), false, contentDirectory, onError);
     }
     catch {
-        const docsJsonPath = join(CMD_EXEC_PATH, 'docs.json');
+        const docsJsonPath = join(contentDirectory, 'docs.json');
         if (!(await fse.pathExists(docsJsonPath)))
             throw new Error('No config found');
-        const docsConfig = await DocsConfigUpdater.getConfig(docsJsonPath, false, CMD_EXEC_PATH, onError, { allowSourceRefs: true });
-        const { newDocsConfig, pagesAcc, openApiFiles: newOpenApiFiles, } = await generateOpenApiDivisions(docsConfig, openApiFiles, CLIENT_PATH, undefined, invalidSpecFiles);
-        warnInvalidSpecFiles(invalidSpecFiles);
-        return { pagesAcc, openApiFiles: newOpenApiFiles, docsConfig: newDocsConfig };
+        docsConfig = await DocsConfigUpdater.getConfig(docsJsonPath, false, contentDirectory, onError, {
+            allowSourceRefs: true,
+        });
     }
+    if (loadedMintConfig) {
+        docsConfig = upgradeToDocsConfig(loadedMintConfig);
+        const result = await generateOpenApiAnchorsOrTabs(loadedMintConfig, openApiFiles, clientDirectory, undefined, invalidSpecFiles);
+        mintConfig = result.mintConfig;
+    }
+    if (!docsConfig)
+        throw new Error('No config found');
+    const graphqlResult = await generateGraphqlDivisionsFromDocsConfig(docsConfig, (source) => loadGraphqlSdlSource(source, contentDirectory));
+    const { newDocsConfig: docsConfigWithGraphqlPages, pagesAcc: pagesAccWithGraphqlPages } = graphqlResult;
+    const { newDocsConfig, pagesAcc: pagesAccWithOpenApiPages, openApiFiles: newOpenApiFiles, flushWrites: flushOpenApiWrites, } = await generateOpenApiDivisions(docsConfigWithGraphqlPages, openApiFiles, clientDirectory, undefined, invalidSpecFiles, pagesAccWithGraphqlPages, true);
+    const { flushWrites: flushAsyncApiWrites } = await generateAsyncApiDivisions(newDocsConfig, asyncApiFiles, clientDirectory, undefined, pagesAccWithGraphqlPages, false, true);
+    await Promise.all([flushOpenApiWrites(), flushAsyncApiWrites()]);
+    await writeGraphqlArtifacts(graphqlResult, clientDirectory);
+    warnInvalidSpecFiles(invalidSpecFiles);
+    return {
+        mintConfig,
+        pagesAcc: { ...pagesAccWithOpenApiPages, ...pagesAccWithGraphqlPages },
+        openApiFiles: newOpenApiFiles,
+        docsConfig: newDocsConfig,
+    };
 };

package/dist/local-preview/listener/index.d.ts

@@ -2,7 +2,9 @@ import { initializeImportCache } from './importCache.js';
 type LocalPreviewOptions = {
     localSchema?: boolean;
     groups?: string[];
+    disableOpenApi?: boolean;
     allowSourceRefs?: boolean;
+    lazyPages?: boolean;
 };
 declare const listener: (triggerRefresh: () => void, options?: LocalPreviewOptions, gate?: Promise<void>) => void;
 declare const initializeFrontmatterHashCache: () => Promise<void>;

package/dist/local-preview/listener/index.js

@@ -12,13 +12,13 @@ import { CMD_EXEC_PATH, NEXT_PROPS_PATH, NEXT_PUBLIC_PATH, CLIENT_PATH } from '.
 import { addChangeLog, addErrorLog, clearErrorLogs, getCurrentErrorLogs, } from '../../logging-state.js';
 import { AddedLog, DeletedLog, EditedLog, WarningLog, InfoLog, ErrorLog } from '../../logs.js';
 import { reportPageCompileError, reportPageCompileSuccess } from '../on-demand-page.js';
-import { clearDocsConfigCaches, getDocsConfigApiHash, getDocsConfigNavigationHash, getVariablesHash, hasDocsConfigApiChanged, hasDocsConfigNavigationChanged, hasNavigationApiReference, hasDocsConfigVariablesChanged, updateDocsConfigHashCache, } from './docs-config-cache.js';
+import { clearDocsConfigCaches, getDocsConfigApiHash, getDocsConfigNavigationHash, getVariablesHash, hasDocsConfigApiChanged, hasDocsConfigNavigationChanged, hasNavigationApiReference, hadDocsConfigApiReference, hasDocsConfigVariablesChanged, updateDocsConfigHashCache, } from './docs-config-cache.js';
 import { generateDependentSnippets } from './generateDependentSnippets.js';
 import { generatePagesWithImports } from './generatePagesWithImports.js';
 import { getDocsState } from './getDocsState.js';
 import { initializeImportCache, updateImportCacheForFile, removeFromImportCache, getImportedFilesFromCache, syncImportedFileLocations, } from './importCache.js';
 import { clearPageMetadataCache, removePageMetadataCacheEntryForFile, upsertPageMetadataCacheEntry, upsertPageMetadataCacheEntryForFile, } from './page-metadata-cache.js';
-import { hasTrackedReferencedFile, refreshTrackedReferencedFiles } from './referencedFiles.js';
+import { hasTrackedReferencedFile, refreshTrackedReferencedFiles, shouldRegenerateGraphqlSource, } from './referencedFiles.js';
 import { regenerateAllSnippets } from './regenerateAllSnippets.js';
 import { resolveImportsFromImportClosure } from './resolve-imports-from-import-closure.js';
 import { resolvePageImports } from './resolve-page-imports.js';
@@ -158,6 +158,11 @@ const onUnlinkEvent = async (filename, triggerRefresh, options) => {
         if (potentialCategory === 'page') {
             reportPageCompileSuccess(filename);
         }
+        if (shouldRegenerateGraphqlSource(filename)) {
+            await rebuildGraphqlSchema(triggerRefresh, options);
+            addChangeLog(_jsx(DeletedLog, { filename: filename }));
+            return;
+        }
         if (hasTrackedReferencedFile(filename)) {
             try {
                 const { mintConfig, openApiFiles, docsConfig } = await getDocsState(handleParseError);
@@ -308,6 +313,14 @@ const initializeDocsConfigHashCache = async () => {
     }
     catch { }
 };
+const rebuildGraphqlSchema = async (triggerRefresh, options) => {
+    const prebuildResult = await prebuild(CMD_EXEC_PATH, options);
+    await initializeImportCache(CMD_EXEC_PATH, prebuildResult?.fileImportsMap);
+    await initializeFrontmatterHashCache();
+    await initializeDocsConfigHashCache();
+    await refreshTrackedReferencedFiles();
+    triggerRefresh();
+};
 /**
  * This function is called when a file is added or changed
  * @param filename
@@ -316,6 +329,10 @@ const initializeDocsConfigHashCache = async () => {
 const onUpdateEvent = async (filename, triggerRefresh, options = {}) => {
     clearErrorLogs();
     const filePath = pathUtil.join(CMD_EXEC_PATH, filename);
+    if (shouldRegenerateGraphqlSource(filename)) {
+        await rebuildGraphqlSchema(triggerRefresh, options);
+        return null;
+    }
     const importChanges = await updateImportCacheForFile(CMD_EXEC_PATH, filename);
     await syncImportedFileLocations(importChanges);
     const importedFiles = getImportedFilesFromCache();
@@ -431,8 +448,13 @@ const onUpdateEvent = async (filename, triggerRefresh, options = {}) => {
                     const navigationChanged = hasDocsConfigNavigationChanged(newNavigationHash);
                     const newVariablesHash = getVariablesHash(docsConfig.variables);
                     const variablesChanged = hasDocsConfigVariablesChanged(newVariablesHash);
-                    const shouldUseNavigationFastPath = navigationChanged && !apiChanged && !hasDocsConfigApiRoutes(docsConfig);
-                    const shouldRegenerateGeneratedData = apiChanged || (navigationChanged && hasDocsConfigApiRoutes(docsConfig));
+                    const shouldUseNavigationFastPath = navigationChanged &&
+                        !apiChanged &&
+                        !hasDocsConfigApiRoutes(docsConfig) &&
+                        !hadDocsConfigApiReference();
+                    const shouldRegenerateGeneratedData = apiChanged ||
+                        (navigationChanged &&
+                            (hasDocsConfigApiRoutes(docsConfig) || hadDocsConfigApiReference()));
                     await refreshTrackedReferencedFiles();
                     if (shouldUseNavigationFastPath) {
                         // Plain MDX navigation changed without API changes: regenerate
@@ -484,8 +506,8 @@ const onUpdateEvent = async (filename, triggerRefresh, options = {}) => {
             // mint.json: preserve the original full-rebuild behavior.
             regenerateNav = true;
             try {
-                const { mintConfig, openApiFiles, docsConfig } = await getDocsState(handleParseError);
                 await refreshTrackedReferencedFiles();
+                const { mintConfig, openApiFiles, docsConfig } = await getDocsState(handleParseError);
                 if (mintConfig) {
                     await MintConfigUpdater.writeConfigFile(mintConfig, CLIENT_PATH);
                 }

package/dist/local-preview/listener/referencedFiles.d.ts

@@ -1,2 +1,4 @@
+export declare const getLocalGraphqlSources: (value: unknown) => string[];
 export declare const refreshTrackedReferencedFiles: () => Promise<void>;
 export declare const hasTrackedReferencedFile: (filePath: string) => boolean;
+export declare const shouldRegenerateGraphqlSource: (filePath: string, configuredSources?: ReadonlySet<string>) => boolean;

package/dist/local-preview/listener/referencedFiles.js

@@ -1,21 +1,50 @@
-import { getConfigPath, resolveFileRefs } from '@mintlify/prebuild';
+import { normalizeRelativePath } from '@mintlify/common';
+import { getConfigPath, isRemoteGraphqlSource, resolveFileRefs } from '@mintlify/prebuild';
 import { readFile } from 'fs/promises';
+import path from 'path';
 import { CMD_EXEC_PATH } from '../../constants.js';
 let trackedReferencedFiles = new Set();
+let trackedGraphqlSources = new Set();
+const normalizeTrackedPath = (filePath) => path.normalize(normalizeRelativePath(filePath));
+export const getLocalGraphqlSources = (value) => {
+    if (Array.isArray(value))
+        return value.flatMap(getLocalGraphqlSources);
+    if (value == null || typeof value !== 'object')
+        return [];
+    const node = value;
+    const graphql = node.graphql;
+    const source = typeof graphql === 'string'
+        ? graphql
+        : graphql != null && typeof graphql === 'object' && 'source' in graphql
+            ? graphql.source
+            : undefined;
+    const sources = typeof source === 'string' && !isRemoteGraphqlSource(source)
+        ? [normalizeTrackedPath(source)]
+        : [];
+    return [...sources, ...Object.values(node).flatMap(getLocalGraphqlSources)];
+};
 export const refreshTrackedReferencedFiles = async () => {
     try {
         const configPath = (await getConfigPath(CMD_EXEC_PATH, 'docs')) ?? (await getConfigPath(CMD_EXEC_PATH, 'mint'));
         if (!configPath) {
             trackedReferencedFiles = new Set();
+            trackedGraphqlSources = new Set();
             return;
         }
         const content = await readFile(configPath, 'utf-8');
         const parsed = JSON.parse(content);
-        const { referencedFiles } = await resolveFileRefs(parsed, CMD_EXEC_PATH);
-        trackedReferencedFiles = new Set(referencedFiles);
+        const { referencedFiles, resolved } = await resolveFileRefs(parsed, CMD_EXEC_PATH);
+        const graphqlSources = getLocalGraphqlSources(resolved);
+        trackedReferencedFiles = new Set([
+            ...referencedFiles.map(normalizeTrackedPath),
+            ...graphqlSources,
+        ]);
+        trackedGraphqlSources = new Set(graphqlSources);
     }
     catch {
         trackedReferencedFiles = new Set();
+        trackedGraphqlSources = new Set();
     }
 };
-export const hasTrackedReferencedFile = (filePath) => trackedReferencedFiles.has(filePath);
+export const hasTrackedReferencedFile = (filePath) => trackedReferencedFiles.has(normalizeTrackedPath(filePath));
+export const shouldRegenerateGraphqlSource = (filePath, configuredSources = trackedGraphqlSources) => configuredSources.has(normalizeTrackedPath(filePath));

package/dist/local-preview/run.js

@@ -173,7 +173,13 @@ export const run = async (argv) => {
         releaseWatcherGate = resolve;
     });
     addDevTimingLog('watching for file changes');
-    listener(onChange, {}, watcherGate);
+    listener(onChange, {
+        localSchema: argv['local-schema'],
+        groups: argv.groups,
+        disableOpenApi: argv.disableOpenapi,
+        allowSourceRefs: true,
+        lazyPages: true,
+    }, watcherGate);
     await timeDev('initialize import cache', () => initializeImportCache(CMD_EXEC_PATH, argv.fileImportsMap));
     markOnDemandPagesReady();
     await timeDev('initialize frontmatter cache', () => initializeFrontmatterHashCache());