@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/build/generate.js

@@ -0,0 +1,80 @@
+/**
+ * One generation (bit 19 h2): the app's artifacts made inside its module graph (artifacts.ts, loaded through the
+ * loader that imports the app, from the app's own @lovrozagar/honey) and each written only when it changed, through
+ * honey-clients's write.ts (Q1).
+ * honey-clients is an optional peer, imported on demand (Q2), so a missing one is a named error only when a
+ * generation runs.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { ARTIFACTS } from "./artifacts.js";
+import { createModuleLoader } from "./loaders.js";
+const CLIENTS = "@lovrozagar/honey-clients";
+const CORE = "@lovrozagar/honey";
+/** honey-clients, or a named error when it is not installed. */
+export async function loadClients(load = () => import("@lovrozagar/honey-clients")) {
+    try {
+        return await load();
+    }
+    catch (error) {
+        if (error.code !== "ERR_MODULE_NOT_FOUND" || !String(error).includes(CLIENTS))
+            throw error;
+        throw new Error(`honey: generating the app's artifacts needs ${CLIENTS}: add it to your devDependencies`, {
+            cause: error,
+        });
+    }
+}
+/** The root of the @lovrozagar/honey package holding `file`, found up its directories. */
+function packageOf(file) {
+    for (let dir = dirname(file); dirname(dir) !== dir; dir = dirname(dir)) {
+        const manifest = join(dir, "package.json");
+        if (existsSync(manifest) && JSON.parse(readFileSync(manifest, "utf8")).name === CORE)
+            return dir;
+    }
+    return undefined;
+}
+/**
+ * artifacts.ts as the app at `root` resolves @lovrozagar/honey (node_modules up from it), at the path it has in this
+ * package, so it shares the app's core even when the plugin was loaded from another copy; else this package's own.
+ */
+export function artifactsFor(root, own = ARTIFACTS) {
+    const pkg = packageOf(own);
+    if (pkg === undefined)
+        return own;
+    for (let dir = resolve(root);; dir = dirname(dir)) {
+        const candidate = join(dir, "node_modules", CORE, relative(pkg, own));
+        if (existsSync(candidate))
+            return candidate;
+        if (dirname(dir) === dir)
+            return own;
+    }
+}
+/** artifacts.ts as `load` evaluates it, so the app it imports shares its core; a fresh loader from `root` by default. */
+export async function inAppGraph(root, load) {
+    const loader = load ?? (await createModuleLoader({ fresh: true, from: resolve(root, "index.ts") }));
+    return (await loader(artifactsFor(root)));
+}
+/** Every artifact `config` asks for, written under `root`; the files it rewrote. */
+export async function generateAndWrite(config, root, options = {}) {
+    const { manifest, mcp, openApi, tree, types } = config.codegen;
+    if (tree === false && manifest === false && openApi.length === 0 && types === false && mcp === false)
+        return [];
+    const codegen = await loadClients();
+    const report = options.report ?? ((message) => void process.stderr.write(`honey: ${message}\n`));
+    const run = { codegen, report, root };
+    let graph = await inAppGraph(root, options.load);
+    let { rewrite, source } = await graph.prepare(config, { ...run, first: true });
+    const written = [];
+    if (rewrite !== undefined) {
+        /* a gateway app imports the tree this writes: written first, then the pass redone over it on a fresh graph */
+        codegen.writeFileIfChanged(resolve(root, rewrite[0]), rewrite[1]);
+        written.push(resolve(root, rewrite[0]));
+        graph = await inAppGraph(root, await createModuleLoader({ fresh: true, from: resolve(root, "index.ts"), reload: true }));
+        ({ source } = await graph.prepare(config, { ...run, first: false }));
+    }
+    /* the tree just written is the same text again, so it is not rewritten nor listed twice */
+    for (const [path, text] of await graph.artifactsOf(config, run, source))
+        if (codegen.writeFileIfChanged(resolve(root, path), text))
+            written.push(resolve(root, path));
+    return written;
+}

package/dist/build/glob.d.ts

@@ -0,0 +1,8 @@
+/** `pattern` as a RegExp over a root-relative path: anchored, so `src/**` never matches `node_modules/x/src/a.ts`. */
+export declare function globToRegExp(pattern: string): RegExp;
+/** A matcher for `patterns`, compiled once: whether `file` (absolute, or relative to `root`) matches; outside never. */
+export declare function compileGlobs(patterns: readonly string[]): (file: string, root: string) => boolean;
+/** Whether `file` (absolute, or relative to `root`) matches any of `patterns`; a file outside `root` never does. */
+export declare function matchesGlob(file: string, patterns: readonly string[], root: string): boolean;
+/** What a watch never regenerates for: `_gen/` and `_gen` itself, `*.gen.*`, dependencies, an atomic write's `.tmp`. */
+export declare const WATCH_IGNORE_RE: RegExp;

package/dist/build/glob.js

@@ -0,0 +1,97 @@
+/**
+ * The build's watch globs: a `watch` pattern as a RegExp anchored at the project root, and the paths a watch never
+ * regenerates for. `**` spans segments; `*` and `?` stay in one; `{a,b}` alternates; `[...]` is a class (`[!...]`
+ * negates).
+ */
+import { isAbsolute, relative } from "node:path";
+/** `pattern` as a RegExp over a root-relative path: anchored, so `src/**` never matches `node_modules/x/src/a.ts`. */
+export function globToRegExp(pattern) {
+    const segments = pattern
+        .replaceAll("\\", "/")
+        .replace(/^(\.\/)+/, "")
+        .split("/");
+    let re = "^";
+    segments.forEach((segment, i) => {
+        const last = i === segments.length - 1;
+        if (segment === "**")
+            re += last ? ".*" : "(?:[^/]*/)*";
+        else
+            re += segmentToRegExp(segment) + (last ? "" : "/");
+    });
+    return new RegExp(`${re}$`);
+}
+/** One path segment's pattern as RegExp source; a character a glob gives no meaning is literal. */
+function segmentToRegExp(segment) {
+    let out = "";
+    for (let i = 0; i < segment.length; i++) {
+        const ch = segment[i];
+        if (ch === "*") {
+            /* a stray `**` inside a segment means `*` */
+            while (segment[i + 1] === "*")
+                i++;
+            out += "[^/]*";
+        }
+        else if (ch === "?")
+            out += "[^/]";
+        else if (ch === "[" && segment.indexOf("]", i + 2) !== -1) {
+            const close = segment.indexOf("]", i + 2);
+            const body = segment.slice(i + 1, close);
+            out += `[${(body.startsWith("!") ? `^${body.slice(1)}` : body).replaceAll("\\", "\\\\").replaceAll("/", "")}]`;
+            i = close;
+        }
+        else if (ch === "{" && matchingBrace(segment, i) !== -1) {
+            const close = matchingBrace(segment, i);
+            out += `(?:${splitTopLevel(segment.slice(i + 1, close))
+                .map(segmentToRegExp)
+                .join("|")})`;
+            i = close;
+        }
+        else
+            out += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+    return out;
+}
+function matchingBrace(s, open) {
+    let depth = 0;
+    for (let i = open; i < s.length; i++) {
+        if (s[i] === "{")
+            depth++;
+        else if (s[i] === "}" && --depth === 0)
+            return i;
+    }
+    return -1;
+}
+/** `body`'s alternatives, split at its top-level commas. */
+function splitTopLevel(body) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < body.length; i++) {
+        if (body[i] === "{")
+            depth++;
+        else if (body[i] === "}")
+            depth--;
+        else if (body[i] === "," && depth === 0) {
+            parts.push(body.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(body.slice(start));
+    return parts;
+}
+/** A matcher for `patterns`, compiled once: whether `file` (absolute, or relative to `root`) matches; outside never. */
+export function compileGlobs(patterns) {
+    const regexps = patterns.map(globToRegExp);
+    return (file, root) => {
+        const rel = (isAbsolute(file) ? relative(root, file) : file).replaceAll("\\", "/");
+        if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute(rel))
+            return false;
+        return regexps.some((re) => re.test(rel));
+    };
+}
+/** Whether `file` (absolute, or relative to `root`) matches any of `patterns`; a file outside `root` never does. */
+export function matchesGlob(file, patterns, root) {
+    return compileGlobs(patterns)(file, root);
+}
+/** What a watch never regenerates for: `_gen/` and `_gen` itself, `*.gen.*`, dependencies, an atomic write's `.tmp`. */
+export const WATCH_IGNORE_RE = /(^|[/\\])_gen([/\\]|$)|\.gen\.(tsx?|json|ya?ml|d\.ts)$|[/\\]node_modules[/\\]|\.tmp$/;

package/dist/build/index.d.ts

@@ -1,58 +1,3 @@
-import { type HoneyFeature } from "../feature-detect.ts";
-export type HoneyBuildConfig = {
-    external?: string[];
-    /**
-     * Force optional features on or off. Unset features are detected by scanning the app's
-     * import graph for `.openapi()` / `.manifest()`, `.errorI18n()` and `.serve()` calls.
-     */
-    features?: Partial<Record<HoneyFeature, boolean>>;
-    minify?: boolean;
-    outDir?: string;
-    port?: number;
-    target: "bun" | "cloudflare" | "deno" | "node";
-};
-type ParseContext = {
-    parse?: (code: string, options?: {
-        lang?: "js" | "jsx" | "ts" | "tsx";
-    }) => unknown;
-    resolve?: (source: string, importer?: string) => Promise<{
-        external?: unknown;
-        id: string;
-    } | null>;
-};
-export declare function createBuildPlugin(buildConfig: HoneyBuildConfig, shared: {
-    entry: string;
-    export: string;
-}): {
-    apply: "build";
-    config(): {
-        build: {
-            emptyOutDir: boolean;
-            minify: boolean;
-            outDir: string;
-            rolldownOptions: {
-                external: string[];
-                input: string;
-                output: {
-                    entryFileNames: string;
-                };
-            };
-            ssr: boolean;
-        };
-        ssr: {
-            noExternal?: boolean | undefined;
-            target: "node" | "webworker";
-        };
-    };
-    configResolved(cfg: {
-        root: string;
-    }): void;
-    load(this: ParseContext | undefined, id: string): Promise<{
-        code: string;
-        moduleType: string;
-    } | undefined>;
-    name: string;
-    resolveId(id: string): string | undefined;
-};
-export {};
-//# sourceMappingURL=index.d.ts.map
+/** `@lovrozagar/honey/build`: the Vite plugins, honey() (the app's artifacts) and the build target plugin. */
+export { type HoneyCodegenConfig, type HoneyOpenApiOutputConfig, type HoneyVitePluginConfig, honey } from "./plugin.ts";
+export { type BuildApp, type BuildTarget, createBuildPlugin, type HoneyBuildConfig } from "./targets.ts";

package/dist/build/index.js

@@ -1,173 +1,3 @@
-import { existsSync, readFileSync } from "node:fs";
-import { builtinModules } from "node:module";
-import { extname, resolve } from "node:path";
-import { detectFeaturesInSource, FEATURES, featurePrelude, scanProgram } from "../feature-detect.js";
-/* ---- Entry helpers ---- */
-function importApp(entry, exportName) {
-    if (exportName === "default")
-        return `import app from "./${entry}"`;
-    return `import { ${exportName} as app } from "./${entry}"`;
-}
-/* server targets start through the same code path as `app.serve()`: WS adapter, env, hostname */
-function serverEntry(config, runtime, env, port) {
-    return [
-        'import { startHoneyServer } from "@lovrozagar/honey/serve"',
-        importApp(config.entry, config.export),
-        "",
-        `const port = Number(${port})`,
-        `await startHoneyServer(app, { env: ${env}, hostname: "0.0.0.0", port, runtime: "${runtime}" })`,
-    ].join("\n");
-}
-/* ---- Adapter definitions ---- */
-const adapters = {
-    bun: {
-        entry: (config) => serverEntry(config, "bun", "process.env", `process.env.PORT ?? ${config.port}`),
-        noExternal: false,
-        skipFeatures: [],
-        ssrTarget: "node",
-    },
-    cloudflare: {
-        entry(config) {
-            return [
-                importApp(config.entry, config.export),
-                "",
-                "export default {",
-                "  fetch: (req, env, ctx) => app.fetch(req, env, ctx),",
-                "}",
-            ].join("\n");
-        },
-        noExternal: true,
-        /* a Worker cannot listen; serve would pull node:http into the bundle */
-        skipFeatures: ["serve"],
-        ssrTarget: "webworker",
-    },
-    deno: {
-        entry: (config) => serverEntry(config, "deno", "Deno.env.toObject()", `Deno.env.get("PORT") ?? "${config.port}"`),
-        noExternal: true,
-        skipFeatures: [],
-        ssrTarget: "webworker",
-    },
-    node: {
-        entry: (config) => serverEntry(config, "node", "process.env", `process.env.PORT ?? ${config.port}`),
-        noExternal: false,
-        skipFeatures: [],
-        ssrTarget: "node",
-    },
-};
-/* ---- Feature detection over the import graph ---- */
-const SCANNED_EXT = /\.(?:[cm]?[jt]sx?)$/;
-function langOf(file) {
-    const ext = extname(file);
-    if (ext === ".tsx")
-        return "tsx";
-    if (ext === ".jsx")
-        return "jsx";
-    return /^\.[cm]?ts$/.test(ext) ? "ts" : "js";
-}
-/**
- * Walks the app's own modules (never node_modules) from `entry`, following static and dynamic
- * imports, and collects feature calls. Comments and strings do not count.
- */
-async function detectGraphFeatures(ctx, entry) {
-    const features = new Set();
-    const seen = new Set();
-    const queue = [entry];
-    while (queue.length > 0) {
-        const file = queue.pop();
-        if (seen.has(file))
-            continue;
-        seen.add(file);
-        if (!SCANNED_EXT.test(file) || file.includes("node_modules") || !existsSync(file))
-            continue;
-        const code = readFileSync(file, "utf-8");
-        let imports = [];
-        let program;
-        try {
-            program = ctx.parse?.(code, { lang: langOf(file) });
-        }
-        catch {
-            program = undefined;
-        }
-        if (program) {
-            const scanned = scanProgram(program);
-            for (const f of scanned.features)
-                features.add(f);
-            imports = scanned.imports;
-        }
-        else {
-            for (const f of detectFeaturesInSource(code))
-                features.add(f);
-        }
-        if (!ctx.resolve)
-            continue;
-        for (const source of imports) {
-            const resolved = await ctx.resolve(source, file).catch(() => null);
-            if (!resolved || resolved.external || resolved.id.startsWith("\0"))
-                continue;
-            queue.push(resolved.id.split("?")[0]);
-        }
-    }
-    return features;
-}
-/* ---- Virtual module constants ---- */
-const VIRTUAL_BUILD_ENTRY = "virtual:honey-build-entry";
-const RESOLVED_BUILD_ENTRY = `\0${VIRTUAL_BUILD_ENTRY}`;
-/* ---- Build plugin factory ---- */
-export function createBuildPlugin(buildConfig, shared) {
-    const adapter = adapters[buildConfig.target];
-    const resolvedConfig = {
-        entry: shared.entry,
-        export: shared.export,
-        port: buildConfig.port ?? 3000,
-    };
-    let root = "";
-    return {
-        apply: "build",
-        config() {
-            return {
-                build: {
-                    emptyOutDir: false,
-                    minify: buildConfig.minify ?? true,
-                    outDir: buildConfig.outDir ?? "./dist",
-                    rolldownOptions: {
-                        external: [...builtinModules, ...builtinModules.map((m) => `node:${m}`), ...(buildConfig.external ?? [])],
-                        input: VIRTUAL_BUILD_ENTRY,
-                        output: { entryFileNames: "index.js" },
-                    },
-                    ssr: true,
-                },
-                ssr: {
-                    /* node and bun install dependencies next to the bundle; inlining them would also inline native addons */
-                    ...(adapter.noExternal ? { noExternal: true } : {}),
-                    target: adapter.ssrTarget,
-                },
-            };
-        },
-        configResolved(cfg) {
-            root = cfg.root;
-        },
-        async load(id) {
-            if (id !== RESOLVED_BUILD_ENTRY)
-                return undefined;
-            const appPath = resolve(root || ".", shared.entry);
-            const detected = await detectGraphFeatures(this ?? {}, appPath);
-            const features = FEATURES.filter((feature) => {
-                if (adapter.skipFeatures.includes(feature))
-                    return false;
-                return buildConfig.features?.[feature] ?? detected.has(feature);
-            });
-            const prelude = featurePrelude(features);
-            return {
-                code: `${prelude ? `${prelude}\n` : ""}${adapter.entry(resolvedConfig)}`,
-                moduleType: "js",
-            };
-        },
-        name: "honey:build",
-        resolveId(id) {
-            if (id === VIRTUAL_BUILD_ENTRY)
-                return RESOLVED_BUILD_ENTRY;
-            return undefined;
-        },
-    };
-}
-//# sourceMappingURL=index.js.map
+/** `@lovrozagar/honey/build`: the Vite plugins, honey() (the app's artifacts) and the build target plugin. */
+export { honey } from "./plugin.js";
+export { createBuildPlugin } from "./targets.js";

package/dist/build/init.d.ts

@@ -0,0 +1,3 @@
+import type { InitFlags } from "./cli-args.ts";
+/** Scaffold `cwd`; an existing file is refused, naming it, unless `flags.force`. */
+export declare function runInit(cwd: string, flags: InitFlags, out: (line: string) => void): void;

package/dist/build/init.js

@@ -0,0 +1,131 @@
+/**
+ * `honey init`: a new project's app, server and Vite config, and with `--cf` a Worker and its wrangler.jsonc. An
+ * existing file is refused unless `--force`; an existing package.json keeps its own scripts and `type` unless
+ * `--force`, each kept value reported. Lines go to `out` (the CLI's stdout): core prints only through it.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+const APP_TS = `import { honey } from "@lovrozagar/honey"
+import { serveOpenApi } from "@lovrozagar/honey/openapi"
+
+export const app = serveOpenApi(
+	honey()
+		.get("/health")
+		.handler((ctx) => ctx.res.text("ok", "ok")),
+	{ docs: "scalar", title: "Honey", version: "0.0.1" },
+)
+`;
+const SERVER_TS = `import { serve } from "@lovrozagar/honey/serve"
+import { app } from "./app.ts"
+
+await serve(app, { port: Number(process.env.PORT ?? 3000) })
+`;
+const VITE_CONFIG_TS = `import { honey } from "@lovrozagar/honey/plugin"
+
+export default {
+	plugins: [
+		honey({
+			app: "src/app.ts",
+		}),
+	],
+}
+`;
+const WORKER_TS = `import { cfWebSocket } from "@lovrozagar/honey/ws/cloudflare"
+import { app } from "./app.ts"
+
+app.wsAdapter(cfWebSocket())
+
+export default {
+	fetch: (...args: Parameters<typeof app.fetch>) => app.fetch(...args),
+}
+`;
+/** The scoped package the templates import: unscoped `honey` on npm is someone else's. */
+const PACKAGE_NAME = "@lovrozagar/honey";
+const SCRIPTS = { dev: "bun --watch src/server.ts", generate: "honey generate" };
+/** Scaffold `cwd`; an existing file is refused, naming it, unless `flags.force`. */
+export function runInit(cwd, flags, out) {
+    const files = {
+        "src/app.ts": APP_TS,
+        "src/server.ts": SERVER_TS,
+        "vite.config.ts": VITE_CONFIG_TS,
+    };
+    if (flags.cf) {
+        files["src/worker.ts"] = WORKER_TS;
+        files["wrangler.jsonc"] = wranglerJsonc(packageNameOf(cwd));
+    }
+    const collision = Object.keys(files).find((rel) => existsSync(join(cwd, rel)));
+    if (collision !== undefined && !flags.force)
+        throw new Error(`${collision} already exists: rerun with --force to overwrite it`);
+    for (const [rel, contents] of Object.entries(files))
+        writeText(join(cwd, rel), contents);
+    for (const note of writePackageJson(cwd, flags.force))
+        out(`honey: ${note}`);
+    out("honey: initialized");
+}
+function wranglerJsonc(name) {
+    return `{
+	"compatibility_date": "2026-01-20",
+	"compatibility_flags": ["nodejs_compat"],
+	"main": "src/worker.ts",
+	"name": ${JSON.stringify(name)},
+	"workers_dev": true
+}
+`;
+}
+/** Write package.json, or add what is missing to the one there; what it kept, as notes. */
+function writePackageJson(cwd, force) {
+    const path = join(cwd, "package.json");
+    const exists = existsSync(path);
+    const existing = exists ? readPackageJson(path) : {};
+    const notes = [];
+    const scripts = { ...existing.scripts };
+    for (const [name, command] of Object.entries(SCRIPTS)) {
+        const current = scripts[name];
+        if (current === undefined || current === command || force)
+            scripts[name] = command;
+        else
+            notes.push(`kept scripts.${name} (${JSON.stringify(current)}); honey expects ${JSON.stringify(command)}`);
+    }
+    const dependencies = { ...existing.dependencies };
+    if (dependencies[PACKAGE_NAME] === undefined || force)
+        dependencies[PACKAGE_NAME] = `^${honeyVersion()}`;
+    const next = { ...existing, dependencies, scripts };
+    if (!exists)
+        Object.assign(next, { name: packageNameOf(cwd), private: true });
+    /* an explicit `type` is the project's choice, kept even under --force */
+    if (existing.type === undefined && (!exists || force))
+        next.type = "module";
+    else if (existing.type === undefined)
+        notes.push('package.json has no "type"; the scaffold is ESM: set "type": "module", or rerun with --force');
+    writeText(path, `${JSON.stringify(next, null, "\t")}\n`);
+    return notes;
+}
+function readPackageJson(path) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new Error("package.json is not valid JSON");
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("package.json must be an object");
+    return parsed;
+}
+function writeText(path, contents) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, contents, "utf8");
+}
+/** A package name from the directory's: lower case, npm's characters only, else `honey-app`. */
+function packageNameOf(dir) {
+    const base = basename(dir)
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^[-.]+|[-.]+$/g, "");
+    return base || "honey-app";
+}
+/** This package's version, the dependency range the scaffold asks for. */
+function honeyVersion() {
+    return JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"))
+        .version;
+}

package/dist/build/loaders.d.ts

@@ -0,0 +1,33 @@
+import type { EffectConverter } from "../schema/to-json-schema.ts";
+export type ModuleLoader = (path: string) => Promise<Record<string, unknown>>;
+export type ModuleLoaderOptions = {
+    /** no module shared with an earlier fresh loader: a generation's redo pass sees the tree its first pass wrote */
+    fresh: boolean;
+    /** the file imports resolve from */
+    from: string;
+    /** a fresh loader after one that evaluated the project in this process: on Bun it must evict some module */
+    reload?: boolean;
+};
+/** Bun's module registry, its ES modules included, keyed by path: what a fresh loader evicts. */
+export type ModuleRegistry = Record<string, unknown>;
+/**
+ * A loader for one generation: each path evaluated at most once, so the app never runs twice. Through jiti on Node;
+ * on Bun (`registry` is its module registry), Bun's own import: jiti there re-evaluates a module that threw through
+ * its Babel, whose stack hook then breaks Bun (bit 20 k-fix).
+ */
+export declare function createModuleLoader(options: ModuleLoaderOptions, registry?: ModuleRegistry | undefined): Promise<ModuleLoader>;
+export declare const VITE_CONFIG_FILES: readonly string[];
+/** The Vite config file in `cwd`, by Vite's own order; undefined when there is none. */
+export declare function findViteConfig(cwd: string): string | undefined;
+export type ViteConfigEnv = {
+    command: "build" | "serve";
+    mode: string;
+};
+/**
+ * The config each `honey()` plugin in a Vite config file carries, in plugin order: a function-form config is called
+ * with `env`, and nested and promised plugin arrays flatten as Vite flattens them. Read off the plugin object (its
+ * name `honey`, its `api.honeyConfig`), so it holds across module instances and runtimes.
+ */
+export declare function loadPluginConfigs<T>(configPath: string, load: ModuleLoader, env: ViteConfigEnv): Promise<T[]>;
+/** Effect's `JSONSchema.make` for core's converters, when effect is installed; else undefined. */
+export declare function effectConverter(specifier?: string): Promise<EffectConverter | undefined>;