@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/plugin.js

@@ -1,666 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, resolve, sep } from "node:path";
-import { createModuleLoader, honeyConfigOf } from "./codegen-load.js";
-import { generateManifest, generateOpenApi, generateRouteTree, generateRouteTreeFromApp, generateRouteTreeFromRouteTree, generateTypes, prepareCodegen, sanitizeOpenApiSpec, } from "./codegen.js";
-import { detectFeaturesInSource, featurePrelude, importsFeatureEntry } from "./feature-detect.js";
-import { runCli } from "./gen-process.js";
-import { writeGenFile, writeGenJsonFile, writeGenYamlFile, writeOutputDir } from "./gen-write.js";
-import { WATCH_IGNORE_RE, compileGlobs } from "./glob.js";
-import { overlaySchemas } from "./tree.js";
-import { openApiOutputPaths, toYaml } from "./yaml.js";
-export async function generateFromApp(app, options) {
-    const host = app;
-    const artifacts = {
-        routeTree: generateRouteTreeFromApp(host),
-    };
-    if (options?.manifest) {
-        const manifest = generateManifest(host);
-        artifacts.manifest = JSON.stringify(manifest, null, 2);
-    }
-    if (options?.openApi) {
-        const spec = await generateOpenApi(host, { info: options.openApi.info });
-        artifacts.openApi = JSON.stringify(spec, null, 2);
-        artifacts.openApiYaml = toYaml(spec);
-    }
-    return artifacts;
-}
-export function resolveHoneyConfig(raw) {
-    const c = raw.codegen;
-    const resolvePathFlag = (val, defaultPath, defaultEnabled) => {
-        if (val === false)
-            return false;
-        if (val === true || (val === undefined && defaultEnabled))
-            return defaultPath;
-        if (typeof val === "string")
-            return val;
-        return false;
-    };
-    let types = false;
-    if (c?.types !== undefined && c.types !== false) {
-        if (typeof c.types === "string") {
-            types = { baseCtxName: undefined, path: c.types };
-        }
-        else if (c.types === true) {
-            types = { baseCtxName: undefined, path: "src/_gen/types.gen.d.ts" };
-        }
-        else {
-            types = {
-                baseCtxName: c.types.baseCtxName,
-                path: c.types.path ?? "src/_gen/types.gen.d.ts",
-            };
-        }
-    }
-    let sdk = false;
-    if (c?.sdk !== undefined && c.sdk !== false) {
-        if (typeof c.sdk === "string") {
-            throw new Error("codegen.sdk string form removed — pass object { name?, specs?, ports }");
-        }
-        if (c.sdk === true) {
-            sdk = { name: "SDK", ports: { typescript: { outDir: "src/_gen" } } };
-        }
-        else {
-            const rawPorts = c.sdk.ports ?? { typescript: true };
-            const ports = {};
-            if (rawPorts.typescript !== undefined && rawPorts.typescript !== false) {
-                if (rawPorts.typescript === true) {
-                    ports.typescript = { outDir: "src/_gen" };
-                }
-                else {
-                    ports.typescript = { outDir: rawPorts.typescript.outDir ?? "src/_gen" };
-                }
-            }
-            if (rawPorts.python) {
-                ports.python = { outDir: rawPorts.python.outDir };
-            }
-            if (rawPorts.go) {
-                ports.go = { modulePath: rawPorts.go.modulePath, outDir: rawPorts.go.outDir };
-            }
-            if (rawPorts.rust) {
-                ports.rust = { crateName: rawPorts.rust.crateName, outDir: rawPorts.rust.outDir };
-            }
-            sdk = {
-                name: c.sdk.name ?? "SDK",
-                ports,
-                specs: c.sdk.specs,
-            };
-        }
-    }
-    let openApi = false;
-    if (c?.openApi) {
-        const entries = Array.isArray(c.openApi) ? c.openApi : [c.openApi];
-        openApi = entries.map((entry) => ({
-            description: entry.description,
-            filterRoutes: entry.filterRoutes,
-            path: entry.path ?? "src/_gen/openapi.gen.json",
-            profile: entry.profile,
-            sanitize: entry.sanitize,
-            securitySchemes: entry.securitySchemes,
-            title: entry.title,
-            version: entry.version,
-        }));
-    }
-    let cli = false;
-    if (c?.cli !== undefined && c.cli !== false) {
-        if (c.cli === true) {
-            throw new Error("codegen.cli=true requires `out` and `binaryName` — pass an object { out, binaryName }");
-        }
-        if (!c.cli.out || !c.cli.binaryName) {
-            throw new Error("codegen.cli requires `out` and `binaryName`");
-        }
-        cli = {
-            binaryName: c.cli.binaryName,
-            configName: c.cli.configName,
-            defaultBaseURL: c.cli.defaultBaseURL,
-            envPrefix: c.cli.envPrefix,
-            modulePath: c.cli.modulePath,
-            out: c.cli.out,
-            sdkModulePath: c.cli.sdkModulePath,
-        };
-    }
-    return {
-        app: raw.app,
-        codegen: {
-            cli,
-            invalidate: c?.invalidate,
-            manifest: resolvePathFlag(c?.manifest, "src/_gen/manifest.gen.json", false),
-            mergeTree: c?.mergeTree,
-            openApi,
-            sdk,
-            tree: resolvePathFlag(c?.tree, "src/_gen/routes.gen.ts", true),
-            types,
-        },
-        watch: raw.watch ?? [],
-    };
-}
-/* ---- Config stash ---- */
-let _lastConfig;
-/**
- * Config of the most recent `honey()` call in this module instance.
- * @deprecated Read the config off the plugin object (`plugin.api.honeyConfig`); this is a single
- * global and does not survive a second module instance.
- */
-export function getLastHoneyConfig() {
-    return _lastConfig;
-}
-/* ---- Outputs ---- */
-const TS_SDK_FILES = [
-    "sdk.types.gen.ts",
-    "sdk.map.gen.ts",
-    "sdk.client.gen.ts",
-    "sdk.index.gen.ts",
-    "sdk.runtime.gen.ts",
-];
-/** Every file and directory a generation writes, as absolute paths. Watchers must ignore these. */
-export function generatedOutputs(config, root) {
-    const cg = config.codegen;
-    const files = [];
-    const dirs = [];
-    if (cg.tree)
-        files.push(resolve(root, cg.tree));
-    if (cg.types)
-        files.push(resolve(root, cg.types.path));
-    if (cg.manifest)
-        files.push(resolve(root, cg.manifest));
-    for (const entry of cg.openApi || []) {
-        const out = openApiOutputPaths(resolve(root, entry.path));
-        if (out.json)
-            files.push(out.json);
-        files.push(out.yaml);
-    }
-    if (cg.sdk) {
-        const ports = cg.sdk.ports;
-        if (ports.typescript) {
-            const outDir = resolve(root, ports.typescript.outDir);
-            files.push(...TS_SDK_FILES.map((name) => resolve(outDir, name)));
-        }
-        if (ports.python)
-            dirs.push(resolve(root, ports.python.outDir));
-        if (ports.go)
-            dirs.push(resolve(root, ports.go.outDir));
-        if (ports.rust)
-            dirs.push(resolve(root, ports.rust.outDir));
-    }
-    if (cg.cli)
-        dirs.push(resolve(root, cg.cli.out));
-    return { dirs, files };
-}
-export function isGeneratedOutput(file, outputs) {
-    const abs = resolve(file);
-    if (outputs.files.includes(abs))
-        return true;
-    return outputs.dirs.some((dir) => abs === dir || abs.startsWith(dir + sep));
-}
-async function loadAppOrTree(load, entryPath) {
-    const mod = await load(entryPath);
-    /* prefer named exports, then unwrap interop default */
-    if (mod.app && isHoneyApp(mod.app))
-        return mod.app;
-    if (mod.tree && isRouteTree(mod.tree))
-        return mod.tree;
-    if (mod.default) {
-        const def = mod.default;
-        /* interopDefault may wrap: { default: { app: Honey } } */
-        if (isHoneyApp(def))
-            return def;
-        if (isRouteTree(def))
-            return def;
-        if (def.app && isHoneyApp(def.app))
-            return def.app;
-        if (def.tree && isRouteTree(def.tree))
-            return def.tree;
-    }
-    return undefined;
-}
-function isHoneyApp(val) {
-    if (val === null || typeof val !== "object")
-        return false;
-    return typeof val.fetch === "function";
-}
-function isRouteTree(val) {
-    if (val === null || typeof val !== "object")
-        return false;
-    const obj = val;
-    return obj.root !== undefined && typeof obj.root === "object";
-}
-/* ---- Generation ---- */
-/**
- * The tree a `codegen.mergeTree` gateway serves: the merged downstream tree plus the routes
- * the gateway app registers itself. Its root wildcard stays out — the downstream leaves
- * delegate to it. Without a configured app the merged tree is served as is.
- */
-async function gatewayTree(load, source, appPath) {
-    if (appPath === undefined)
-        return source;
-    const exported = await loadAppOrTree(load, appPath);
-    if (!isHoneyApp(exported))
-        throw new Error(`Expected Honey app default export in ${appPath}`);
-    return exported._gatewayTree(source);
-}
-export async function generateAndWrite(config, root, options = {}) {
-    await prepareCodegen();
-    const cg = config.codegen;
-    let load = options.load ?? (await createModuleLoader({ fresh: true, from: resolve(root, "index.ts") }));
-    /* phase 1: route tree — from mergeTree source or app */
-    let mergeSource;
-    if (cg.tree && (cg.mergeTree || config.app)) {
-        const treeSrc = resolve(root, cg.mergeTree ?? config.app ?? "");
-        const exported = await loadAppOrTree(load, treeSrc);
-        let treeCode;
-        if (isHoneyApp(exported)) {
-            treeCode = generateRouteTreeFromApp(exported);
-        }
-        else if (isRouteTree(exported)) {
-            const appPath = cg.mergeTree && config.app ? resolve(root, config.app) : undefined;
-            const treePath = resolve(root, cg.tree);
-            let tree;
-            try {
-                tree = await gatewayTree(load, exported, appPath);
-            }
-            catch (err) {
-                /* first run: the gateway app imports the tree this pass writes. Write the merged
-                   downstream tree, then load the app again over it to add its own routes. */
-                if (appPath === undefined || existsSync(treePath))
-                    throw err;
-                writeGenFile(treePath, generateRouteTreeFromRouteTree(exported), "honey");
-                load = await createModuleLoader({ fresh: true, from: resolve(root, "index.ts") });
-                tree = await gatewayTree(load, exported, appPath);
-            }
-            treeCode = generateRouteTreeFromRouteTree(tree);
-            mergeSource = exported;
-        }
-        else {
-            throw new Error(`Expected Honey app or RouteTree default export in ${treeSrc}`);
-        }
-        writeGenFile(resolve(root, cg.tree), treeCode, "honey");
-    }
-    else if (cg.mergeTree && cg.openApi) {
-        const exported = await loadAppOrTree(load, resolve(root, cg.mergeTree));
-        if (isRouteTree(exported))
-            mergeSource = exported;
-    }
-    /* phase 2: types, manifest, openapi, sdk, cli — app needed unless sdk has specs */
-    const sdkHasSpecs = cg.sdk && cg.sdk.specs && cg.sdk.specs.length > 0;
-    const needsApp = cg.types || cg.manifest || cg.openApi || (cg.sdk && !sdkHasSpecs) || cg.cli;
-    let app;
-    let appPath;
-    if (needsApp) {
-        if (!config.app) {
-            throw new Error("No app configured — required for types/manifest/openapi/sdk without specs/cli");
-        }
-        appPath = resolve(root, config.app);
-        /* the loader evaluates each file once, so the tree pass above did not cost a second load */
-        const appExported = await loadAppOrTree(load, appPath);
-        if (!isHoneyApp(appExported)) {
-            throw new Error(`Expected Honey app default export in ${appPath}`);
-        }
-        app = appExported;
-        /* the app serves the intern tree (no schemas); document merged routes from their source */
-        if (mergeSource)
-            overlaySchemas(app, mergeSource);
-    }
-    /* manifest */
-    if (cg.manifest) {
-        if (!app)
-            throw new Error("Manifest generation requires a configured app");
-        const manifest = generateManifest(app);
-        writeGenJsonFile(resolve(root, cg.manifest), manifest, "honey");
-    }
-    /* openapi */
-    if (cg.openApi) {
-        if (!app)
-            throw new Error("OpenAPI generation requires a configured app");
-        for (const entry of cg.openApi) {
-            let spec = await generateOpenApi(app, {
-                filterRoutes: entry.filterRoutes,
-                info: {
-                    description: entry.description,
-                    title: entry.title,
-                    version: entry.version,
-                },
-                /* one report per generate, not one per emitted document */
-                invalidate: entry === cg.openApi[0] ? cg.invalidate : "off",
-                profile: entry.profile,
-                securitySchemes: entry.securitySchemes,
-            });
-            if (entry.sanitize) {
-                spec = sanitizeOpenApiSpec(spec, entry.sanitize);
-            }
-            const out = openApiOutputPaths(resolve(root, entry.path));
-            if (out.json)
-                writeGenJsonFile(out.json, spec, "honey");
-            writeGenYamlFile(out.yaml, spec, "honey");
-        }
-    }
-    /* types */
-    if (cg.types) {
-        const typesPath = resolve(root, cg.types.path);
-        const typesDir = dirname(typesPath);
-        if (!appPath) {
-            throw new Error("Type generation requires a configured app");
-        }
-        const { extractChainTypes } = await import("./type-extractor.js").catch(() => {
-            throw new Error('Type generation requires "ts-morph" — install it as a dev dependency');
-        });
-        /* prefer appBase (middleware-only, simpler type) over app (with routes) */
-        const appModule = await load(appPath);
-        const exportName = "appBase" in appModule ? "appBase" : "app";
-        const extracted = await extractChainTypes({
-            entryPath: appPath,
-            exportName,
-            outputDir: typesDir,
-        });
-        if (!app)
-            throw new Error("Type generation requires a configured app");
-        const typesCode = generateTypes(app, {
-            baseCtxName: cg.types.baseCtxName,
-            inlineEnvType: extracted.base.envType,
-            inlineMiddlewareType: extracted.base.middlewareType,
-            inlineTapsType: extracted.base.tapsType,
-            routeMiddleware: extracted.routeMiddleware,
-            routeMiddlewareProps: extracted.routeMiddlewareProps,
-        });
-        writeGenFile(typesPath, typesCode, "honey");
-    }
-    /* The SDK and Go CLI share one unfiltered document. With openApi outputs the invalidate check
-     * already ran on the first of them, so it is not reported again; without, it runs here once. */
-    let unfiltered;
-    const unfilteredSpec = (what) => {
-        if (!app)
-            throw new Error(`${what} generation requires a configured app`);
-        const primaryOA = cg.openApi && cg.openApi.length > 0 ? cg.openApi[0] : null;
-        /* routes name schemes the openApi outputs declare; checked against all of them, so a declared
-           scheme is not reported as missing. The document the SDK reads stays without them, as it
-           always was, so generated SDK auth does not change. */
-        const schemes = {};
-        for (const entry of cg.openApi || []) {
-            for (const [name, scheme] of Object.entries(entry.securitySchemes ?? {})) {
-                if (!Object.hasOwn(schemes, name))
-                    schemes[name] = scheme;
-            }
-        }
-        const declared = Object.keys(schemes).length > 0;
-        unfiltered ??= generateOpenApi(app, {
-            info: primaryOA ? { title: primaryOA.title, version: primaryOA.version } : { title: "API", version: "1.0.0" },
-            invalidate: primaryOA ? "off" : cg.invalidate,
-            ...(declared ? { securitySchemes: schemes } : {}),
-        }).then((spec) => {
-            if (!declared || !spec.components?.securitySchemes)
-                return spec;
-            const { securitySchemes: _schemes, ...components } = spec.components;
-            return { ...spec, components };
-        });
-        return unfiltered;
-    };
-    /* sdk */
-    if (cg.sdk) {
-        const { generateSDK: genSDK, mergeSpecs } = await import("./codegen.js");
-        let spec;
-        if (cg.sdk.specs && cg.sdk.specs.length > 0) {
-            const specs = cg.sdk.specs.map((s) => {
-                const abs = resolve(root, s);
-                return JSON.parse(readFileSync(abs, "utf-8"));
-            });
-            spec = mergeSpecs(...specs);
-        }
-        else {
-            spec = await unfilteredSpec("SDK");
-        }
-        const ports = cg.sdk.ports;
-        if (ports.typescript) {
-            const tsOutDir = resolve(root, ports.typescript.outDir);
-            const { files } = genSDK(spec, { name: cg.sdk.name, stem: "sdk" });
-            writeGenFile(resolve(tsOutDir, "sdk.types.gen.ts"), files.types, "honey");
-            writeGenFile(resolve(tsOutDir, "sdk.map.gen.ts"), files.map, "honey");
-            writeGenFile(resolve(tsOutDir, "sdk.client.gen.ts"), files.client, "honey");
-            writeGenFile(resolve(tsOutDir, "sdk.index.gen.ts"), files.index, "honey");
-            if (files.runtime) {
-                writeGenFile(resolve(tsOutDir, "sdk.runtime.gen.ts"), files.runtime, "honey");
-            }
-        }
-        if (ports.python) {
-            const { generatePythonSDK } = await import("./codegen-python.js");
-            const { files } = generatePythonSDK(spec, { name: cg.sdk.name });
-            writeOutputDir(resolve(root, ports.python.outDir), files);
-        }
-        if (ports.go) {
-            const { generateGoSDK } = await import("./codegen-go.js");
-            const { files } = generateGoSDK(spec, { modulePath: ports.go.modulePath });
-            writeOutputDir(resolve(root, ports.go.outDir), files);
-        }
-        if (ports.rust) {
-            const { generateRustSDK } = await import("./codegen-rust.js");
-            const { files } = generateRustSDK(spec, { crateName: ports.rust.crateName });
-            writeOutputDir(resolve(root, ports.rust.outDir), files);
-        }
-    }
-    /* cli */
-    if (cg.cli) {
-        const { generateGoCLI } = await import("./codegen-go-cli.js");
-        const spec = await unfilteredSpec("CLI");
-        const { files } = generateGoCLI(spec, {
-            binaryName: cg.cli.binaryName,
-            configName: cg.cli.configName,
-            defaultBaseURL: cg.cli.defaultBaseURL,
-            envPrefix: cg.cli.envPrefix,
-            modulePath: cg.cli.modulePath,
-            sdkModulePath: cg.cli.sdkModulePath,
-        });
-        writeOutputDir(resolve(root, cg.cli.out), files);
-    }
-}
-/* ---- Vite plugin ---- */
-const VIRTUAL_ROUTES = "virtual:honey/routes";
-const VIRTUAL_MANIFEST = "virtual:honey/manifest";
-const VIRTUAL_OPENAPI = "virtual:honey/openapi";
-const RESOLVED_ROUTES = `\0${VIRTUAL_ROUTES}`;
-const RESOLVED_MANIFEST = `\0${VIRTUAL_MANIFEST}`;
-const RESOLVED_OPENAPI = `\0${VIRTUAL_OPENAPI}`;
-/* the route tree codegen emits TypeScript; a virtual module must be JavaScript in dev */
-async function toJavaScript(code) {
-    try {
-        const vite = (await import("vite"));
-        if (vite.transformWithOxc) {
-            const out = await vite.transformWithOxc(code, "routes.gen.ts", { lang: "ts", sourcemap: false });
-            return { code: out.code, moduleType: "js" };
-        }
-    }
-    catch {
-        /* no Vite 8 transform available — let the bundler strip types */
-    }
-    return { code, moduleType: "ts" };
-}
-export function honey(config) {
-    _lastConfig = config;
-    const resolved = resolveHoneyConfig(config);
-    const watchPatterns = config.watch ?? [];
-    const matchesWatch = compileGlobs(watchPatterns);
-    let root = "";
-    let configFile;
-    let pluginIndex = -1;
-    let command = "build";
-    let mode = "production";
-    let outputs = { dirs: [], files: [] };
-    /* one generation at a time; any request during a run schedules exactly one more */
-    let running;
-    let rerun;
-    let starting;
-    const savesSeen = new Map();
-    async function generateOnce() {
-        if (configFile && pluginIndex >= 0) {
-            /* a child process: fresh module graph, and the app's side effects die with it */
-            await runCli(["generate", "--config", configFile, "--plugin", String(pluginIndex)], {
-                cwd: root,
-                env: { HONEY_VITE_COMMAND: command, HONEY_VITE_MODE: mode },
-            });
-            return;
-        }
-        await generateAndWrite(resolved, root);
-    }
-    function regenerate() {
-        if (!running) {
-            running = generateOnce().finally(() => {
-                running = undefined;
-            });
-            return running;
-        }
-        if (!rerun) {
-            rerun = running
-                .catch(() => undefined)
-                .then(() => {
-                rerun = undefined;
-                return regenerate();
-            });
-        }
-        return rerun;
-    }
-    const plugin = {
-        /** Read by `honey generate` to find this plugin's config in a loaded Vite config. */
-        api: { honeyConfig: config },
-        /* Vite calls this once per environment, back to back: the second joins the running
-         * generation instead of queueing another. A later buildStart (a watch rebuild) runs anew. */
-        async buildStart() {
-            starting ??= regenerate().finally(() => {
-                starting = undefined;
-            });
-            await starting;
-        },
-        configResolved(cfg) {
-            root = cfg.root;
-            configFile = cfg.configFile;
-            command = cfg.command ?? "build";
-            mode = cfg.mode ?? (command === "serve" ? "development" : "production");
-            outputs = generatedOutputs(resolved, root);
-            const honeyPlugins = (cfg.plugins ?? []).filter((p) => honeyConfigOf(p) !== undefined);
-            pluginIndex = honeyPlugins.findIndex((p) => p === plugin || honeyConfigOf(p) === config);
-        },
-        /**
-         * Regenerates when a watched file changes, then lets Vite's normal HMR proceed, adding the
-         * virtual route tree to the update. Vite calls this once per environment; the generation
-         * runs once per save.
-         */
-        async hotUpdate(ctx) {
-            if (watchPatterns.length === 0)
-                return undefined;
-            if (WATCH_IGNORE_RE.test(ctx.file) || isGeneratedOutput(ctx.file, outputs))
-                return undefined;
-            if (!matchesWatch(ctx.file, root))
-                return undefined;
-            const key = `${ctx.file}\0${ctx.timestamp ?? Date.now()}`;
-            let run = savesSeen.get(key);
-            if (!run) {
-                run = regenerate().catch((err) => {
-                    console.error("honey: generation failed", err);
-                });
-                savesSeen.set(key, run);
-                if (savesSeen.size > 64)
-                    savesSeen.delete(savesSeen.keys().next().value);
-            }
-            await run;
-            const graph = (this && this.environment?.moduleGraph) || ctx.server.moduleGraph;
-            const routes = graph.getModuleById(RESOLVED_ROUTES);
-            if (!routes || ctx.modules.includes(routes))
-                return undefined;
-            return [...ctx.modules, routes];
-        },
-        async load(id) {
-            if (id === RESOLVED_ROUTES) {
-                if (!resolved.codegen.mergeTree && !config.app) {
-                    throw new Error("Route tree virtual module requires app or mergeTree");
-                }
-                const treeSrc = resolved.codegen.mergeTree
-                    ? resolve(root, resolved.codegen.mergeTree)
-                    : resolve(root, config.app ?? "");
-                const load = await createModuleLoader({ fresh: true, from: treeSrc });
-                const exported = await loadAppOrTree(load, treeSrc);
-                let code;
-                if (isHoneyApp(exported)) {
-                    code = generateRouteTreeFromApp(exported);
-                }
-                else if (isRouteTree(exported)) {
-                    const appPath = resolved.codegen.mergeTree && config.app ? resolve(root, config.app) : undefined;
-                    code = generateRouteTreeFromRouteTree(await gatewayTree(load, exported, appPath));
-                }
-                else {
-                    throw new Error(`Expected Honey app or RouteTree in ${treeSrc}`);
-                }
-                return toJavaScript(code);
-            }
-            if (id === RESOLVED_MANIFEST && resolved.codegen.manifest) {
-                if (!config.app)
-                    throw new Error("Manifest virtual module requires app");
-                const appPath = resolve(root, config.app);
-                const exported = await loadAppOrTree(await createModuleLoader({ fresh: true, from: appPath }), appPath);
-                if (isHoneyApp(exported)) {
-                    const manifest = generateManifest(exported);
-                    return {
-                        code: `export default ${JSON.stringify(manifest, null, 2)};`,
-                        moduleType: "js",
-                    };
-                }
-            }
-            if (id === RESOLVED_OPENAPI && resolved.codegen.openApi) {
-                const primary = resolved.codegen.openApi[0];
-                if (!config.app)
-                    throw new Error("OpenAPI virtual module requires app");
-                const appPath = resolve(root, config.app);
-                const exported = await loadAppOrTree(await createModuleLoader({ fresh: true, from: appPath }), appPath);
-                if (isHoneyApp(exported)) {
-                    let spec = await generateOpenApi(exported, {
-                        filterRoutes: primary.filterRoutes,
-                        info: {
-                            description: primary.description,
-                            title: primary.title,
-                            version: primary.version,
-                        },
-                        /* generation already reported; a virtual module load must not repeat it */
-                        invalidate: "off",
-                        profile: primary.profile,
-                        securitySchemes: primary.securitySchemes,
-                    });
-                    if (primary.sanitize) {
-                        spec = sanitizeOpenApiSpec(spec, primary.sanitize);
-                    }
-                    return {
-                        code: `export default ${JSON.stringify(spec, null, 2)};`,
-                        moduleType: "js",
-                    };
-                }
-            }
-            return undefined;
-        },
-        name: "honey",
-        /**
-         * Imports the entries of optional features a module uses, ahead of its code, on the same
-         * line so line numbers stay put. Server environments only: browser code never serves.
-         */
-        transform(code, id) {
-            if (this && this.environment?.config?.consumer === "client")
-                return undefined;
-            if (id.includes("\0") || id.includes("node_modules"))
-                return undefined;
-            const features = [...detectFeaturesInSource(code)].filter((f) => !importsFeatureEntry(code, f));
-            if (features.length === 0)
-                return undefined;
-            const prelude = featurePrelude(features);
-            if (code.startsWith("#!")) {
-                const eol = code.indexOf("\n");
-                if (eol === -1)
-                    return { code: `${code}\n${prelude}`, map: null };
-                return { code: `${code.slice(0, eol + 1)}${prelude} ${code.slice(eol + 1)}`, map: null };
-            }
-            return { code: `${prelude} ${code}`, map: null };
-        },
-        resolveId(id) {
-            if (id === VIRTUAL_ROUTES)
-                return RESOLVED_ROUTES;
-            if (id === VIRTUAL_MANIFEST && resolved.codegen.manifest)
-                return RESOLVED_MANIFEST;
-            if (id === VIRTUAL_OPENAPI && resolved.codegen.openApi)
-                return RESOLVED_OPENAPI;
-            return undefined;
-        },
-    };
-    return [plugin];
-}
-export { generateRouteTree };
-//# sourceMappingURL=plugin.js.map