@mintlify/previewing 4.0.1462 → 4.0.1464

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

@@ -1,9 +1,11 @@
 import { resolveAllImports as baseResolveAllImports } from '@mintlify/common';
+import { packageImportArgs } from '../packages/state.js';
 import { getProcessedSnippets } from './getSnippets.js';
 export const resolveAllImports = async (fileWithImports) => {
     const snippets = await getProcessedSnippets();
     return await baseResolveAllImports({
         snippets,
         fileWithImports,
+        ...packageImportArgs(),
     });
 };

package/dist/local-preview/packages/dev.d.ts

@@ -0,0 +1,88 @@
+import type { BuildResult } from '@mintlify/package-builder';
+import { type PackageRouteState } from './serve.js';
+export declare const PACKAGE_BUILD_PROPS_FILE = "package-build.json";
+export type PackagesDevStatus = {
+    state: 'disabled';
+} | {
+    state: 'building';
+} | {
+    state: 'ready';
+} | {
+    state: 'missing-node-modules';
+} | {
+    state: 'failed';
+    message: string;
+};
+export type PackagesDevReporter = {
+    building(): void;
+    built(result: {
+        buildId: string;
+        islands: number;
+        ms: number;
+        warnings: string[];
+    }): void;
+    failed(errors: string[], warnings: string[]): void;
+    missingNodeModules(docsRoot: string): void;
+    islandErrors(errors: string[]): void;
+    configError(message: string): void;
+};
+export type PackagesDevOptions = {
+    docsRoot: string;
+    buildsDir: string;
+    propsPath: string;
+    onRebuilt: () => void;
+    regenerateSnippets?: () => Promise<unknown>;
+    reporter: PackagesDevReporter;
+    debounceMs?: number;
+    pollMs?: number;
+    build?: (input: Parameters<typeof import('@mintlify/package-builder').build>[0]) => Promise<BuildResult>;
+};
+export declare class PackagesDev {
+    private readonly options;
+    private setup;
+    private collected;
+    private collector;
+    private adopted;
+    private status;
+    private builtInputKey;
+    private buildingInputKey;
+    private builder;
+    private buildFiles;
+    private buildFilesKnown;
+    private changedWhileBuilding;
+    private debounceTimer;
+    private pollTimer;
+    private running;
+    private rerun;
+    private collectPending;
+    private buildCount;
+    private closed;
+    private propsWrite;
+    private listedIds;
+    constructor(options: PackagesDevOptions);
+    get enabled(): boolean;
+    getStatus(): PackagesDevStatus;
+    routeState: () => PackageRouteState;
+    init(): Promise<void>;
+    onFileChange(filename: string, category: string | null | undefined): Promise<void>;
+    private buildReads;
+    private finishTracking;
+    writeProps(): Promise<void>;
+    private writePropsNow;
+    close(): Promise<void>;
+    private reload;
+    private reportConfigError;
+    private importOptionsChanged;
+    private recollect;
+    private reportIslandProblems;
+    private inputKey;
+    private schedule;
+    private flush;
+    private runBuild;
+    private fail;
+    private pruneBuilds;
+    private nodeModulesStamp;
+    private watchForNodeModules;
+    private stopPolling;
+    private invalidateCompiledPages;
+}

package/dist/local-preview/packages/dev.js

@@ -0,0 +1,478 @@
+import { islandPrefixFor, isPackageManifestPath } from '@mintlify/common';
+import { getFileListSync } from '@mintlify/prebuild';
+import { existsSync, statSync } from 'fs';
+import fse from 'fs-extra';
+import path from 'path';
+import { formatDiagnostic, loadPackageBuilder } from '../../packages/builder.js';
+import { formatProblem, PackageIslandCollector, } from '../../packages/collect.js';
+import { errnoCode } from '../../packages/errno.js';
+import { DocsJsonError, InvalidPackagesError, readPackagesSetup, } from '../../packages/setup.js';
+import { PACKAGE_ROUTE_PREFIX } from './serve.js';
+import { setPackageImportOptions } from './state.js';
+export const PACKAGE_BUILD_PROPS_FILE = 'package-build.json';
+const PENDING_BUILD_ID = 'pending';
+const NODE_MODULES_MARKERS = [
+    '.package-lock.json',
+    '.modules.yaml',
+    '.yarn-integrity',
+    '.yarn-state.yml',
+];
+const MARKED_LOCKFILES = [
+    'package-lock.json',
+    'npm-shrinkwrap.json',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+];
+const PAGE_EXTENSIONS = new Set(['.mdx', '.md']);
+const sameSet = (a, b) => a.size === b.size && [...a].every((value) => b.has(value));
+const sameVariables = (a = {}, b = {}) => Object.keys(a).length === Object.keys(b).length &&
+    Object.entries(a).every(([key, value]) => b[key] === value);
+const mtimeOf = (file) => {
+    try {
+        return statSync(file).mtimeMs;
+    }
+    catch {
+        return undefined;
+    }
+};
+const RENAME_RETRY_CODES = new Set(['EPERM', 'EBUSY', 'EACCES']);
+async function replaceFile(from, to, attempts = 20) {
+    for (let attempt = 1;; attempt++) {
+        try {
+            await fse.rename(from, to);
+            return;
+        }
+        catch (error) {
+            const code = errnoCode(error);
+            if (attempt >= attempts || !code || !RENAME_RETRY_CODES.has(code))
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, 10 * attempt));
+        }
+    }
+}
+export class PackagesDev {
+    constructor(options) {
+        this.options = options;
+        this.status = { state: 'disabled' };
+        this.buildFiles = new Set();
+        this.buildFilesKnown = false;
+        this.rerun = false;
+        this.collectPending = false;
+        this.buildCount = 0;
+        this.closed = false;
+        this.propsWrite = Promise.resolve();
+        this.listedIds = new Set();
+        this.routeState = () => ({
+            enabled: this.enabled,
+            buildsDir: this.options.buildsDir,
+        });
+    }
+    get enabled() {
+        return this.setup !== undefined;
+    }
+    getStatus() {
+        return this.status;
+    }
+    async init() {
+        await this.reload(true);
+        if (!this.enabled) {
+            await fse.remove(this.options.buildsDir);
+            return;
+        }
+        await fse.emptyDir(this.options.buildsDir);
+        await this.flush();
+    }
+    async onFileChange(filename, category) {
+        if (this.closed)
+            return;
+        const normalized = filename.split(path.sep).join('/');
+        const extension = path.extname(normalized).toLowerCase();
+        const manifest = isPackageManifestPath(normalized);
+        if (category === 'docsConfig' || manifest) {
+            if (await this.reload())
+                this.schedule(manifest);
+            else
+                this.reportIslandProblems();
+            return;
+        }
+        if (!this.enabled)
+            return;
+        if (category === 'mintIgnore') {
+            await this.writeProps();
+            this.collectPending = true;
+            this.schedule(true);
+            return;
+        }
+        if (category === 'page') {
+            await this.recollect((collector) => collector.updatePage(normalized));
+            this.schedule(false);
+            return;
+        }
+        if (category === 'snippet-v2' ||
+            (category === 'snippet' && PAGE_EXTENSIONS.has(extension)) ||
+            Object.prototype.hasOwnProperty.call(this.collected?.snippetFiles ?? {}, `/${normalized}`)) {
+            try {
+                await this.recollect();
+            }
+            finally {
+                this.schedule(true);
+            }
+            return;
+        }
+        this.reportIslandProblems();
+        const file = `/${normalized.toLowerCase()}`;
+        if (this.buildReads(file))
+            this.schedule(true);
+        else
+            this.changedWhileBuilding?.add(file);
+    }
+    buildReads(file) {
+        if (this.buildFiles.has(file))
+            return true;
+        if (this.buildFilesKnown || this.changedWhileBuilding)
+            return false;
+        return this.builder?.isLocalInputPath(file) ?? false;
+    }
+    finishTracking(changed, files) {
+        this.changedWhileBuilding = undefined;
+        if (files)
+            this.buildFiles = new Set(files.map((file) => file.toLowerCase()));
+        this.buildFilesKnown = files !== undefined;
+        if ([...changed].some((file) => this.buildReads(file)))
+            this.rerun = true;
+    }
+    writeProps() {
+        const write = this.propsWrite.then(() => this.writePropsNow());
+        this.propsWrite = write.catch(() => { });
+        return write;
+    }
+    async writePropsNow() {
+        const target = path.join(this.options.propsPath, PACKAGE_BUILD_PROPS_FILE);
+        if (!this.setup || !this.collected) {
+            await fse.remove(target);
+            return;
+        }
+        const buildId = this.adopted?.buildId ?? PENDING_BUILD_ID;
+        const baseUrl = `${PACKAGE_ROUTE_PREFIX}/${buildId}`;
+        const built = this.adopted?.manifest.islands ?? {};
+        const collectedIds = this.collected.islands.map((island) => island.id);
+        const islands = {};
+        for (const id of [...collectedIds, ...this.listedIds, ...Object.keys(built)]) {
+            if (Object.prototype.hasOwnProperty.call(islands, id))
+                continue;
+            const html = Object.prototype.hasOwnProperty.call(built, id) ? built[id]?.html : undefined;
+            const css = Object.prototype.hasOwnProperty.call(built, id) ? built[id]?.css : undefined;
+            islands[id] = {
+                prefix: islandPrefixFor(id),
+                ...(html !== undefined && { html }),
+                ...(css !== undefined && { css }),
+            };
+        }
+        for (const id of collectedIds)
+            this.listedIds.add(id);
+        const tmp = `${target}.${process.pid}.tmp`;
+        const props = {
+            baseUrl,
+            islands,
+            packageNames: [...this.setup.packageNames].sort(),
+            packageSnippets: [...this.collected.packageSnippets].sort(),
+            css: this.adopted?.manifest.css ?? [],
+        };
+        await fse.outputFile(tmp, JSON.stringify(props));
+        await replaceFile(tmp, target);
+    }
+    close() {
+        this.closed = true;
+        clearTimeout(this.debounceTimer);
+        this.stopPolling();
+        return this.running ?? Promise.resolve();
+    }
+    async reload(initial = false) {
+        const previous = this.setup;
+        const previousSnippets = this.collected?.packageSnippets;
+        let setup;
+        try {
+            setup = await readPackagesSetup(this.options.docsRoot);
+        }
+        catch (error) {
+            if (!(error instanceof DocsJsonError))
+                throw error;
+            if (previous) {
+                this.reportConfigError(error.problems, 'Keeping the last package setup until docs.json is fixed.');
+                if (!(error instanceof InvalidPackagesError))
+                    return false;
+                if (sameVariables(previous.variables, error.variables))
+                    return false;
+                setup = { ...previous, variables: error.variables };
+            }
+            else if (error instanceof InvalidPackagesError) {
+                this.reportConfigError(error.problems, 'Packages stay off until docs.json is fixed.');
+            }
+        }
+        if (previous && setup?.packageJsonError) {
+            this.reportConfigError([setup.packageJsonError], 'Keeping the last package setup until package.json is fixed.');
+            if (sameVariables(previous.variables, setup.variables))
+                return false;
+            setup = { ...previous, variables: setup.variables };
+        }
+        this.setup = setup;
+        if (!setup) {
+            this.collected = undefined;
+            this.collector = undefined;
+            this.status = { state: 'disabled' };
+            this.builtInputKey = undefined;
+            this.buildingInputKey = undefined;
+            this.stopPolling();
+            setPackageImportOptions(undefined);
+            await this.writeProps();
+            if (previous)
+                await this.importOptionsChanged();
+            return true;
+        }
+        const previousCollector = this.collector;
+        this.collector = new PackageIslandCollector({
+            docsRoot: this.options.docsRoot,
+            packageNames: setup.packageNames,
+            variables: setup.variables,
+            provider: setup.packages.provider,
+        });
+        if (previousCollector)
+            this.collector.inheritSnippetTrees(previousCollector);
+        await this.recollect();
+        const namesChanged = !previous || !sameSet(previous.packageNames, setup.packageNames);
+        const snippetsChanged = !previousSnippets || !sameSet(previousSnippets, this.collected?.packageSnippets ?? new Set());
+        if (!initial && (namesChanged || snippetsChanged))
+            await this.importOptionsChanged();
+        return true;
+    }
+    reportConfigError(problems, note) {
+        problems.forEach((problem, index) => this.options.reporter.configError(index === problems.length - 1 ? `${problem}. ${note}` : problem));
+    }
+    async importOptionsChanged() {
+        await this.options.regenerateSnippets?.();
+        await this.invalidateCompiledPages();
+    }
+    async recollect(collect = (collector) => collector.collectAll()) {
+        const { setup, collector } = this;
+        if (!setup || !collector)
+            return;
+        const collected = await collect(collector);
+        if (collector !== this.collector)
+            return;
+        const previousSnippets = this.collected?.packageSnippets;
+        this.collected = collected;
+        setPackageImportOptions({
+            packageNames: setup.packageNames,
+            packageSnippets: collected.packageSnippets,
+        });
+        if (previousSnippets && !sameSet(previousSnippets, collected.packageSnippets)) {
+            await this.invalidateCompiledPages();
+        }
+        this.reportIslandProblems();
+        await this.writeProps();
+    }
+    reportIslandProblems() {
+        this.options.reporter.islandErrors([
+            ...(this.setup?.errors ?? []),
+            ...(this.collected?.errors ?? []).map(formatProblem),
+        ]);
+    }
+    inputKey() {
+        return JSON.stringify({
+            packages: this.setup?.packages,
+            names: [...(this.setup?.packageNames ?? [])].sort(),
+            islands: (this.collected?.islands ?? []).map((island) => island.id).sort(),
+            snippets: this.collected?.snippetFiles,
+        });
+    }
+    schedule(force) {
+        if (!this.enabled || this.closed)
+            return;
+        if (!force && this.inputKey() === (this.buildingInputKey ?? this.builtInputKey))
+            return;
+        if (force)
+            this.builtInputKey = undefined;
+        if (this.status.state === 'ready')
+            this.status = { state: 'building' };
+        clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => void this.flush(), this.options.debounceMs ?? 300);
+    }
+    async flush() {
+        if (this.running) {
+            this.rerun = true;
+            return this.running;
+        }
+        this.running = (async () => {
+            do {
+                this.rerun = false;
+                try {
+                    await this.runBuild();
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.status = { state: 'failed', message };
+                    this.options.reporter.failed([message], []);
+                }
+                finally {
+                    this.buildingInputKey = undefined;
+                }
+            } while (this.rerun && !this.closed);
+        })().finally(() => {
+            this.running = undefined;
+        });
+        return this.running;
+    }
+    async runBuild() {
+        if (this.collectPending) {
+            this.collectPending = false;
+            await this.recollect();
+        }
+        const setup = this.setup;
+        const collected = this.collected;
+        if (!setup || !collected || this.closed)
+            return;
+        const inputKey = this.inputKey();
+        this.builtInputKey = undefined;
+        this.buildingInputKey = inputKey;
+        const started = Date.now();
+        const stamp = this.nodeModulesStamp();
+        this.status = { state: 'building' };
+        this.options.reporter.building();
+        const tmpDir = path.join(this.options.buildsDir, `.tmp-${process.pid}-${++this.buildCount}`);
+        this.builder ??= await loadPackageBuilder();
+        const build = this.options.build ?? this.builder.build;
+        const changed = new Set();
+        this.changedWhileBuilding = changed;
+        let result;
+        try {
+            result = await build({
+                docsRoot: this.options.docsRoot,
+                packages: setup.packages,
+                islands: collected.islands,
+                snippetFiles: collected.snippetFiles,
+                outDir: tmpDir,
+                installer: 'local',
+            });
+        }
+        catch (error) {
+            this.finishTracking(changed);
+            if (this.buildingInputKey !== inputKey) {
+                await fse.remove(tmpDir);
+                return;
+            }
+            return this.fail(error, tmpDir, stamp);
+        }
+        this.finishTracking(changed, [...result.localFiles, ...result.missingLocalFiles]);
+        if (this.buildingInputKey !== inputKey) {
+            await fse.remove(tmpDir);
+            return;
+        }
+        const diagnostics = result.manifest.diagnostics;
+        const errors = diagnostics.filter((d) => d.level === 'error');
+        const warnings = diagnostics.filter((d) => d.level === 'warning').map(formatDiagnostic);
+        const servable = Object.entries(result.manifest.islands).filter(([, island]) => existsSync(path.join(tmpDir, island.entry)));
+        const previous = this.adopted;
+        const servedId = `${result.manifest.buildId}-${this.buildCount}`;
+        const dir = path.join(this.options.buildsDir, servedId);
+        try {
+            if (servable.length > 0 || (result.ok && collected.islands.length === 0)) {
+                await fse.move(tmpDir, dir);
+                await this.pruneBuilds([servedId, previous?.buildId]);
+                this.adopted = { buildId: servedId, manifest: result.manifest, dir };
+            }
+            else {
+                await fse.remove(tmpDir);
+            }
+            this.listedIds.clear();
+            await this.writeProps();
+        }
+        catch (error) {
+            this.adopted = previous;
+            await fse.remove(dir);
+            return this.fail(error, tmpDir, stamp);
+        }
+        const dependencyDrift = diagnostics.some((d) => d.code === 'local-node-modules-drift');
+        if (!result.ok || dependencyDrift)
+            this.watchForNodeModules(stamp);
+        else
+            this.stopPolling();
+        if (errors.some((d) => d.code === 'install-missing-node-modules')) {
+            this.status = { state: 'missing-node-modules' };
+            this.options.reporter.missingNodeModules(this.options.docsRoot);
+        }
+        else if (!result.ok) {
+            const messages = errors.map(formatDiagnostic);
+            this.status = { state: 'failed', message: messages[0] ?? 'unknown error' };
+            this.options.reporter.failed(messages, warnings);
+        }
+        else {
+            this.status = { state: 'ready' };
+            this.options.reporter.built({
+                buildId: result.manifest.buildId,
+                islands: Object.keys(result.manifest.islands).length,
+                ms: Date.now() - started,
+                warnings,
+            });
+        }
+        if (result.ok && inputKey === this.inputKey())
+            this.builtInputKey = inputKey;
+        this.options.onRebuilt();
+    }
+    async fail(error, tmpDir, stamp) {
+        this.listedIds.clear();
+        this.watchForNodeModules(stamp);
+        await fse.remove(tmpDir);
+        const message = error instanceof Error ? error.message : String(error);
+        this.status = { state: 'failed', message };
+        this.options.reporter.failed([message], []);
+        await this.writeProps();
+        this.options.onRebuilt();
+    }
+    async pruneBuilds(keep) {
+        const entries = await fse.readdir(this.options.buildsDir).catch(() => []);
+        await Promise.all(entries
+            .filter((entry) => !keep.includes(entry) && !entry.startsWith('.tmp-'))
+            .map((entry) => fse.remove(path.join(this.options.buildsDir, entry))));
+    }
+    nodeModulesStamp() {
+        const { docsRoot } = this.options;
+        const dir = path.join(docsRoot, 'node_modules');
+        const markers = NODE_MODULES_MARKERS.map((marker) => mtimeOf(path.join(dir, marker)));
+        const stamp = MARKED_LOCKFILES.some((file) => existsSync(path.join(docsRoot, file)))
+            ? markers
+            : [mtimeOf(dir), ...markers];
+        return stamp.every((mtime) => mtime === undefined) ? undefined : stamp.join(',');
+    }
+    watchForNodeModules(initial) {
+        if (this.pollTimer || this.closed)
+            return;
+        let seen = initial;
+        let settling = false;
+        this.pollTimer = setInterval(() => {
+            const stamp = this.nodeModulesStamp();
+            if (stamp !== seen) {
+                seen = stamp;
+                settling = true;
+            }
+            else if (settling) {
+                settling = false;
+                this.schedule(true);
+            }
+        }, this.options.pollMs ?? 2000);
+        this.pollTimer.unref?.();
+    }
+    stopPolling() {
+        clearInterval(this.pollTimer);
+        this.pollTimer = undefined;
+    }
+    async invalidateCompiledPages() {
+        const { propsPath, docsRoot } = this.options;
+        for (const relative of getFileListSync(propsPath)) {
+            if (!PAGE_EXTENSIONS.has(path.extname(relative).toLowerCase()))
+                continue;
+            if (await fse.pathExists(path.join(docsRoot, relative))) {
+                await fse.utimes(path.join(propsPath, relative), 0, 0);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+export declare const setPackagesRebuiltListener: (listener: () => void) => void;
+export declare const startPackagesDev: () => Promise<void>;
+export declare const notifyPackageInputChange: (filename: string, category: string | null | undefined) => Promise<void>;
+export declare const writePackageBuildProps: () => Promise<void>;
+export declare const packageRoute: {
+    prefix: string;
+    handler: (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => Promise<void>;
+};

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

@@ -0,0 +1,89 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import path from 'path';
+import { CMD_EXEC_PATH, NEXT_PROPS_PATH, PREVIEW_PATH } from '../../constants.js';
+import { addChangeLog, addErrorLog, getCurrentErrorLogs, removeErrorLogs, } from '../../logging-state.js';
+import { ErrorLog, InfoLog, SuccessLog, WarningLog } from '../../logs.js';
+import { regenerateAllSnippets } from '../listener/regenerateAllSnippets.js';
+import { PackagesDev } from './dev.js';
+import { createPackageRoute, PACKAGE_ROUTE_PREFIX } from './serve.js';
+const MAX_LOGGED = 5;
+let instance;
+let shownIslandErrors = { key: '', logs: [] };
+const reporter = {
+    building: () => {
+        addChangeLog(_jsx(InfoLog, { message: "building npm packages\u2026" }));
+    },
+    built: ({ buildId, islands, ms, warnings }) => {
+        addChangeLog(_jsx(SuccessLog, { message: `built npm packages (${islands} component${islands === 1 ? '' : 's'}, build ${buildId.slice(0, 12)}) in ${(ms / 1000).toFixed(1)}s` }));
+        for (const warning of warnings.slice(0, MAX_LOGGED)) {
+            addChangeLog(_jsx(WarningLog, { message: `npm packages: ${warning}` }));
+        }
+    },
+    failed: (errors, warnings) => {
+        for (const error of errors.slice(0, MAX_LOGGED)) {
+            addErrorLog(_jsx(ErrorLog, { message: `npm packages: ${error}` }));
+        }
+        for (const warning of warnings.slice(0, MAX_LOGGED)) {
+            addChangeLog(_jsx(WarningLog, { message: `npm packages: ${warning}` }));
+        }
+    },
+    missingNodeModules: (docsRoot) => {
+        addErrorLog(_jsx(ErrorLog, { message: `docs.json uses npm packages but ${path.join(docsRoot, 'node_modules')} is missing. Run npm install in ${docsRoot}; package components stay empty until then.` }));
+    },
+    configError: (message) => {
+        addErrorLog(_jsx(ErrorLog, { message: `npm packages: ${message}` }));
+    },
+    islandErrors: (errors) => {
+        const key = errors.join('\n');
+        const current = getCurrentErrorLogs();
+        const visible = shownIslandErrors.logs.every((log) => current.includes(log));
+        if (key === shownIslandErrors.key && visible)
+            return;
+        removeErrorLogs(shownIslandErrors.logs);
+        const logs = errors
+            .slice(0, MAX_LOGGED)
+            .map((error) => _jsx(ErrorLog, { message: `npm packages: ${error}` }));
+        logs.forEach(addErrorLog);
+        shownIslandErrors = { key, logs };
+    },
+};
+const onRebuiltRef = { current: () => { } };
+export const setPackagesRebuiltListener = (listener) => {
+    onRebuiltRef.current = listener;
+};
+const reportError = (error) => addErrorLog(_jsx(ErrorLog, { message: `npm packages: ${error instanceof Error ? error.message : String(error)}` }));
+export const startPackagesDev = async () => {
+    await instance?.close();
+    instance = new PackagesDev({
+        docsRoot: CMD_EXEC_PATH,
+        buildsDir: path.join(PREVIEW_PATH, 'packages'),
+        propsPath: NEXT_PROPS_PATH,
+        onRebuilt: () => onRebuiltRef.current(),
+        regenerateSnippets: regenerateAllSnippets,
+        reporter,
+    });
+    try {
+        await instance.init();
+    }
+    catch (error) {
+        reportError(error);
+    }
+};
+export const notifyPackageInputChange = async (filename, category) => {
+    try {
+        await instance?.onFileChange(filename, category);
+    }
+    catch (error) {
+        reportError(error);
+    }
+};
+export const writePackageBuildProps = async () => {
+    await instance?.writeProps();
+};
+export const packageRoute = {
+    prefix: PACKAGE_ROUTE_PREFIX,
+    handler: createPackageRoute(() => instance?.routeState() ?? {
+        enabled: false,
+        buildsDir: '',
+    }),
+};

package/dist/local-preview/packages/serve.d.ts

@@ -0,0 +1,8 @@
+import type { NextFunction, Request, Response } from 'express';
+export declare const PACKAGE_ROUTE_PREFIX = "/_mintlify/pkg";
+export type PackageRouteState = {
+    enabled: boolean;
+    buildsDir: string;
+};
+export declare const EMPTY_ISLAND_MODULE = "export function hydrate() {\n  return { unmount() {} };\n}\n";
+export declare const createPackageRoute: (getState: () => PackageRouteState) => (req: Request, res: Response, next: NextFunction) => Promise<void>;