@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/build/loaders.js

@@ -0,0 +1,105 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * The build tooling's loaders: user modules (the Vite config, the app) through jiti on Node, so `honey generate`
+ * reads a TypeScript config on plain Node (H70b), and through Bun's own import on Bun; and Effect's JSON Schema converter, when effect is
+ * installed, for the documents core generates (core never imports a validator, F2).
+ */
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+/**
+ * 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 async function createModuleLoader(options, registry = bunRegistry()) {
+    const evaluate = registry === undefined ? await jitiEvaluator(options) : bunEvaluator(registry, options);
+    const loaded = new Map();
+    return (path) => {
+        const abs = resolve(path);
+        let mod = loaded.get(abs);
+        if (!mod) {
+            mod = evaluate(abs);
+            loaded.set(abs, mod);
+        }
+        return mod;
+    };
+}
+function bunRegistry() {
+    return typeof globalThis.Bun === "undefined" ? undefined : createRequire(import.meta.url).cache;
+}
+async function jitiEvaluator(options) {
+    const { createJiti } = await import("jiti");
+    const jiti = createJiti(options.from, { fsCache: false, interopDefault: true, moduleCache: !options.fresh });
+    return (path) => jiti.import(path);
+}
+function bunEvaluator(registry, options) {
+    /* Bun keeps a module for the process: evicted, the next import evaluates it anew. Every module outside
+     * node_modules goes, what a user may have edited or a generation written (a gateway's tree) */
+    const evicted = options.fresh ? Object.keys(registry).filter((key) => !/[\\/]node_modules[\\/]/.test(key)) : [];
+    for (const key of evicted)
+        delete registry[key];
+    /* a registry keyed otherwise than this reads (a Bun upgrade) leaves a reload the stale graph: said, not served */
+    if (options.reload === true && evicted.length === 0)
+        throw new Error("Bun's module registry held none of the project's modules to evict: a reload would read them stale");
+    return (path) => import(__rewriteRelativeImportExtension(pathToFileURL(path).href));
+}
+export const VITE_CONFIG_FILES = [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vite.config.cts",
+    "vite.config.js",
+    "vite.config.mjs",
+    "vite.config.cjs",
+];
+/** The Vite config file in `cwd`, by Vite's own order; undefined when there is none. */
+export function findViteConfig(cwd) {
+    return VITE_CONFIG_FILES.map((name) => join(cwd, name)).find((path) => existsSync(path));
+}
+/**
+ * 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 async function loadPluginConfigs(configPath, load, env) {
+    const mod = await load(configPath);
+    let config = "default" in mod ? mod.default : mod;
+    if (typeof config === "function") {
+        config = config({ ...env, isPreview: false, isSsrBuild: false });
+    }
+    const plugins = await flattened((await config));
+    return plugins.flatMap((plugin) => {
+        const p = plugin;
+        return p?.name === "honey" && p.api?.honeyConfig !== undefined ? [p.api.honeyConfig] : [];
+    });
+}
+async function flattened(config) {
+    const flat = async (value) => {
+        const resolved = await value;
+        if (Array.isArray(resolved))
+            return (await Promise.all(resolved.map(flat))).flat();
+        return resolved ? [resolved] : [];
+    };
+    return flat(config?.plugins);
+}
+/** Effect's `JSONSchema.make` for core's converters, when effect is installed; else undefined. */
+export async function effectConverter(specifier = ["eff", "ect"].join("")) {
+    try {
+        /* an opaque specifier: a literal one is folded into a Worker bundle, pulling the optional dependency in */
+        const effect = (await import(__rewriteRelativeImportExtension(specifier)));
+        const make = effect.JSONSchema?.make;
+        return typeof make === "function" ? make : undefined;
+    }
+    catch {
+        /* effect is not installed: core then documents each Effect schema unconstrained and reports it */
+        return undefined;
+    }
+}

package/dist/build/plugin.d.ts

@@ -0,0 +1,52 @@
+import { type HoneyVitePluginConfig } from "./config.ts";
+export type { HoneyCodegenConfig, HoneyOpenApiOutputConfig, HoneyVitePluginConfig } from "./config.ts";
+type ModuleGraph = {
+    getModuleById(id: string): unknown;
+};
+type ResolvedViteConfig = {
+    command?: "build" | "serve";
+    configFile?: string;
+    mode?: string;
+    plugins?: readonly unknown[];
+    root: string;
+};
+type HotUpdate = {
+    file: string;
+    modules: unknown[];
+    server: {
+        moduleGraph: ModuleGraph;
+    };
+    timestamp?: number;
+};
+/** `honey generate <args>` in a child (core's own bin on this runtime); resolves when it exits 0. */
+export declare function runGenerate(args: readonly string[], options: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}): Promise<void>;
+/** `generate` serialized: one run at a time, and any call during a run joins the one run queued behind it. */
+export declare function serialized(generate: () => Promise<unknown>): () => Promise<unknown>;
+/** How many recent saves a dev server remembers: Vite reports a save once per environment, back to back. */
+export declare const SAVES_REMEMBERED = 64;
+/** `run` once per key, the last `limit` keys remembered: a call with a remembered key joins its run. */
+export declare function oncePerKey(run: () => Promise<unknown>, limit: number): (key: string) => Promise<unknown>;
+/** The route tree module as JavaScript: a dev server serves a virtual module untransformed. */
+export declare function toJavaScript(code: string, vite?: () => Promise<unknown>): Promise<{
+    code: string;
+    moduleType: string;
+}>;
+export declare function honey(config: HoneyVitePluginConfig): {
+    /** read by `honey generate` to find this plugin's config in a loaded Vite config */
+    api: {
+        honeyConfig: HoneyVitePluginConfig;
+    };
+    buildStart(): Promise<void>;
+    configResolved(cfg: ResolvedViteConfig): void;
+    /** Regenerates on a watched save, then lets HMR go on with the virtual route tree added; once per save. */
+    hotUpdate(this: unknown, ctx: HotUpdate): Promise<unknown[] | undefined>;
+    load: (id: string) => Promise<{
+        code: string;
+        moduleType: string;
+    } | undefined>;
+    name: string;
+    resolveId(id: string): string | undefined;
+}[];

package/dist/build/plugin.js

@@ -0,0 +1,146 @@
+/**
+ * `honey()`, the Vite plugin (`@lovrozagar/honey/plugin`, bit 19 h2): it writes the app's artifacts at build start
+ * and, in dev, again on each save a `watch` glob matches, one generation at a time with at most one more queued, and
+ * one per save across Vite's environments. With a config file, each generation runs in a `honey generate` child, so
+ * it sees edits to every module the app imports and nothing the app starts outlives it. `virtual:honey/routes`,
+ * `/manifest` and `/openapi` serve the same artifacts in memory. Its config rides on the plugin object
+ * (`api.honeyConfig`), where `honey generate` reads it.
+ */
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { generatedOutputs, isGeneratedOutput, resolveHoneyConfig, } from "./config.js";
+import { generateAndWrite, inAppGraph, loadClients } from "./generate.js";
+import { compileGlobs, WATCH_IGNORE_RE } from "./glob.js";
+const VIRTUAL = { manifest: "virtual:honey/manifest", openApi: "virtual:honey/openapi", routes: "virtual:honey/routes" };
+const RESOLVED = { manifest: `\0${VIRTUAL.manifest}`, openApi: `\0${VIRTUAL.openApi}`, routes: `\0${VIRTUAL.routes}` };
+/** `honey generate <args>` in a child (core's own bin on this runtime); resolves when it exits 0. */
+export function runGenerate(args, options) {
+    const bin = fileURLToPath(new URL("../../bin/honey.js", import.meta.url));
+    return new Promise((done, fail) => {
+        const child = spawn(process.execPath, [bin, "generate", ...args], {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env, HONEY_NO_BUN_HANDOFF: "1" },
+            stdio: ["ignore", "inherit", "inherit"],
+        });
+        child.on("error", fail);
+        child.on("exit", (code, signal) => code === 0 ? done() : fail(new Error(`honey generate failed (${signal ?? `exit ${code}`})`)));
+    });
+}
+/** `generate` serialized: one run at a time, and any call during a run joins the one run queued behind it. */
+export function serialized(generate) {
+    let running;
+    let queued;
+    const regenerate = () => {
+        if (running === undefined) {
+            running = generate().finally(() => (running = undefined));
+            return running;
+        }
+        queued ??= running
+            /* the running generation's failure is its own caller's: the one queued behind it runs regardless */
+            .catch(() => undefined)
+            .then(() => {
+            queued = undefined;
+            return regenerate();
+        });
+        return queued;
+    };
+    return regenerate;
+}
+/** How many recent saves a dev server remembers: Vite reports a save once per environment, back to back. */
+export const SAVES_REMEMBERED = 64;
+/** `run` once per key, the last `limit` keys remembered: a call with a remembered key joins its run. */
+export function oncePerKey(run, limit) {
+    const seen = new Map();
+    return (key) => {
+        const known = seen.get(key);
+        if (known !== undefined)
+            return known;
+        const started = run();
+        seen.set(key, started);
+        if (seen.size > limit)
+            seen.delete(seen.keys().next().value);
+        return started;
+    };
+}
+/** The route tree module as JavaScript: a dev server serves a virtual module untransformed. */
+export async function toJavaScript(code, vite = () => import("vite")) {
+    /* no Vite to transform with: the tree is served as TypeScript, which the bundler strips */
+    const loaded = (await vite().catch(() => ({})));
+    if (loaded.transformWithOxc === undefined)
+        return { code, moduleType: "ts" };
+    return { code: (await loaded.transformWithOxc(code, "routes.gen.ts", { lang: "ts" })).code, moduleType: "js" };
+}
+/** A virtual module's code, from a fresh load of the app (or a gateway's merge entry); none for any other id. */
+async function virtualModule(id, config, root) {
+    const kind = Object.keys(RESOLVED).find((key) => RESOLVED[key] === id);
+    if (kind === undefined || (kind === "manifest" && config.codegen.manifest === false))
+        return undefined;
+    if (kind === "openApi" && config.codegen.openApi.length === 0)
+        return undefined;
+    const code = await (await inAppGraph(root)).virtualCode(kind, config, { codegen: () => loadClients(), root });
+    return kind === "routes" ? toJavaScript(code) : { code, moduleType: "js" };
+}
+/** Whether `plugin` is a `honey()` plugin, as `honey generate` finds one. */
+const isHoneyPlugin = (plugin) => plugin?.name === "honey" &&
+    plugin.api?.honeyConfig !== undefined;
+export function honey(config) {
+    const resolved = resolveHoneyConfig(config);
+    const matchesWatch = compileGlobs(resolved.watch);
+    const at = { command: "build", configFile: undefined, index: -1 };
+    let [root, mode, outputs] = [process.cwd(), "production", generatedOutputs(resolved, process.cwd())];
+    let starting;
+    const regenerate = serialized(async () => {
+        if (at.configFile === undefined || at.index < 0)
+            return generateAndWrite(resolved, root);
+        /* a child: a fresh module graph, and whatever the app starts dies with it */
+        return runGenerate(["--config", at.configFile, "--plugin", String(at.index)], {
+            cwd: root,
+            env: { HONEY_VITE_COMMAND: at.command, HONEY_VITE_MODE: mode },
+        });
+    });
+    const perSave = oncePerKey(
+    /* reported on stderr: a failed generation must not stop the dev server's HMR */
+    () => regenerate().catch((error) => process.stderr.write(`honey: generation failed: ${error}\n`)), SAVES_REMEMBERED);
+    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 first's generation */
+        async buildStart() {
+            starting ??= regenerate().finally(() => (starting = undefined));
+            await starting;
+        },
+        configResolved(cfg) {
+            Object.assign(at, { command: cfg.command ?? "build", configFile: cfg.configFile });
+            at.index = (cfg.plugins ?? []).filter(isHoneyPlugin).indexOf(plugin);
+            root = cfg.root;
+            mode = cfg.mode ?? (at.command === "serve" ? "development" : "production");
+            outputs = generatedOutputs(resolved, root);
+        },
+        /** Regenerates on a watched save, then lets HMR go on with the virtual route tree added; once per save. */
+        async hotUpdate(ctx) {
+            if (WATCH_IGNORE_RE.test(ctx.file) || isGeneratedOutput(ctx.file, outputs))
+                return undefined;
+            if (resolved.watch.length === 0 || !matchesWatch(ctx.file, root))
+                return undefined;
+            await perSave(`${ctx.file}\0${ctx.timestamp ?? Date.now()}`);
+            /* Vite passes the environment as `this`; its graph, else the server's */
+            const environment = this?.environment;
+            const routes = (environment?.moduleGraph ?? ctx.server.moduleGraph).getModuleById(RESOLVED.routes);
+            return routes === undefined || routes === null || ctx.modules.includes(routes)
+                ? undefined
+                : [...ctx.modules, routes];
+        },
+        load: (id) => virtualModule(id, resolved, root),
+        name: "honey",
+        resolveId(id) {
+            if (id === VIRTUAL.routes)
+                return RESOLVED.routes;
+            if (id === VIRTUAL.manifest && resolved.codegen.manifest !== false)
+                return RESOLVED.manifest;
+            if (id === VIRTUAL.openApi && resolved.codegen.openApi.length > 0)
+                return RESOLVED.openApi;
+            return undefined;
+        },
+    };
+    return [plugin];
+}

package/dist/build/source.d.ts

@@ -0,0 +1,21 @@
+import { type Honey } from "../routing/app.ts";
+import type { RouteTree } from "../routing/tree.ts";
+import type { ResolvedHoneyConfig } from "./config.ts";
+export type App = Honey<unknown>;
+/** The app a generation documents, and the module and export its types are read from (none, no types). */
+export type Documented = {
+    app: App;
+    entry: string;
+    exportName: string | undefined;
+};
+/** The tree a generation writes; whether the documented app loads it (so it is written first); that app, on demand. */
+export type Source = {
+    documented: () => Promise<Documented>;
+    loadsTree: boolean;
+    tree: RouteTree;
+};
+/**
+ * The app `config` names, or a gateway's (`first` lets a gateway's first run bootstrap); each module imported once.
+ * Its tree holds no output key `.output()`'s types refuse: a generated tree is checked here, never where it is served.
+ */
+export declare function sourceOf(config: ResolvedHoneyConfig, root: string, first?: boolean): Promise<Source>;

package/dist/build/source.js

@@ -0,0 +1,100 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * What a generation reads (bit 19 h2): the tree it writes, and the app its documents, manifest and types come from,
+ * resolved only once that tree is current. An app is its module's `app` export, else its default. A gateway
+ * (`codegen.mergeTree`, ruled at h2, v0's shape) writes gatewayTree(the merge entry's `app` export, else config.app,
+ * merged): its services' routes plus its own. Its documents come from config.app, imported over the current tree
+ * and given its services' schemas, so its settings and errors are its own; with no config.app, from an app booted on
+ * that tree. A first run, whose config.app imports a tree not yet written, is given the merged tree first. Runs inside
+ * the app's module graph, as artifacts.ts does.
+ */
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { assertTreeOutputKeys } from "../openapi/output-keys.js";
+import { honey } from "../routing/app.js";
+import { gatewayTree, overlaySchemas } from "../routing/gateway-tree.js";
+const isApp = (value) => typeof value?.fetch === "function";
+const isTree = (value) => typeof value?.root === "object" && typeof value?.routes === "object";
+/** `run()`, an app's stale-tree failure named for what it is: the app loads the tree this generation writes. */
+async function unlessStale(run, config) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        if (!/Run `honey generate`/.test(String(error)))
+            throw error;
+        const { mergeTree, tree } = config.codegen;
+        const fix = mergeTree === undefined
+            ? "generate from an entry that builds the app without it, or set codegen.mergeTree for a gateway"
+            : `export the gateway's app, built without its tree, from ${mergeTree} as app`;
+        throw new Error(`${config.app} loads the route tree generation writes (${tree || "its routes.gen.ts"}), and that tree is stale: ${fix}`, { cause: error });
+    }
+}
+/** The app `config.app` names. */
+async function appOf(config, root) {
+    const entry = resolve(root, config.app);
+    const mod = (await unlessStale(() => import(__rewriteRelativeImportExtension(entry)), config));
+    const exportName = ["app", "default"].find((name) => isApp(mod[name]));
+    if (exportName === undefined)
+        throw new Error(`Expected a honey app as the app or default export of ${entry}`);
+    return { app: mod[exportName], entry, exportName };
+}
+/** A gateway's source, as the header says. */
+async function gatewayOf(config, root, first) {
+    const entry = resolve(root, config.codegen.mergeTree);
+    const mod = (await import(__rewriteRelativeImportExtension(entry)));
+    const merged = [mod.tree, mod.routeTree, mod.default].find(isTree);
+    if (merged === undefined)
+        throw new Error(`Expected a route tree as the tree or default export of ${entry}`);
+    const own = isApp(mod.app) ? { app: mod.app, entry, exportName: "app" } : undefined;
+    if (config.app === undefined) {
+        const tree = own === undefined ? merged : await unlessStale(() => gatewayTree(own.app, merged), config);
+        const app = honey().routeTree(tree);
+        overlaySchemas(app, merged);
+        return { documented: async () => ({ app, entry, exportName: own?.exportName }), loadsTree: false, tree };
+    }
+    let served;
+    if (own === undefined) {
+        const path = config.codegen.tree === false ? undefined : resolve(root, config.codegen.tree);
+        const bootstrap = first && path !== undefined && !existsSync(path);
+        served = await appOf(config, root).catch((error) => {
+            if (bootstrap)
+                return undefined;
+            throw error;
+        });
+        if (served === undefined)
+            return { documented: () => appOf(config, root), loadsTree: true, tree: merged };
+    }
+    const builder = (own ?? served);
+    const tree = await unlessStale(() => gatewayTree(builder.app, merged), config);
+    const documented = async () => {
+        const app = served ?? (await appOf(config, root));
+        overlaySchemas(app.app, merged);
+        return app;
+    };
+    return { documented, loadsTree: true, tree };
+}
+/** The app `config` names: its snapshot is the tree written. */
+async function appSource(config, root) {
+    if (config.app === undefined)
+        throw new Error("No app configured: set app, or codegen.mergeTree for a gateway");
+    const documented = await appOf(config, root);
+    const tree = await unlessStale(() => documented.app.toRouteTree(), config);
+    return { documented: async () => documented, loadsTree: false, tree };
+}
+/**
+ * The app `config` names, or a gateway's (`first` lets a gateway's first run bootstrap); each module imported once.
+ * Its tree holds no output key `.output()`'s types refuse: a generated tree is checked here, never where it is served.
+ */
+export async function sourceOf(config, root, first = false) {
+    const source = config.codegen.mergeTree === undefined ? await appSource(config, root) : await gatewayOf(config, root, first);
+    assertTreeOutputKeys(source.tree);
+    return source;
+}

package/dist/build/targets.d.ts

@@ -0,0 +1,59 @@
+export type BuildTarget = "bun" | "cloudflare" | "node";
+export type HoneyBuildConfig = {
+    /** modules left out of the bundle beside node's builtins */
+    external?: string[];
+    minify?: boolean;
+    outDir?: string;
+    /** a node or bun server's port when PORT is unset; default 3000 */
+    port?: number;
+    target: BuildTarget;
+};
+/** The app module the entry imports and its export's name, `default` for the default export. */
+export type BuildApp = {
+    entry: string;
+    export: string;
+};
+/** What the plugin asks of the build: the app entry resolved, and its module's export names. */
+type EntryContext = {
+    resolve(source: string): Promise<{
+        id: string;
+    } | null>;
+    load(module: {
+        id: string;
+    }): Promise<{
+        exports?: readonly string[] | null;
+    }>;
+};
+/** The Vite plugin that builds `app` for `config.target`: `vite build` with it emits `<outDir>/index.js`. */
+export declare function createBuildPlugin(config: HoneyBuildConfig, app: BuildApp): {
+    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";
+        };
+    };
+    load(this: EntryContext, id: string): Promise<{
+        code: string;
+        moduleType: "js";
+    }> | {
+        code: string;
+        moduleType: "js";
+    } | undefined;
+    name: string;
+    resolveId(id: string): string | undefined;
+};
+export {};

package/dist/build/targets.js

@@ -0,0 +1,107 @@
+/**
+ * The build plugin (`@lovrozagar/honey/build`): bundles the app for node, bun or a Cloudflare Worker (H15)
+ * from a virtual entry that imports it and starts it the way that target runs an app. Nothing is detected or
+ * injected: v1 code-splits through plain dynamic import() (Q4, H23). Bit 21 h: a Worker's module also exports every
+ * other named export of the app's entry (a Durable Object class, a WorkerEntrypoint, a Workflow), since a Worker's
+ * bindings name classes its main module exports; its default stays honey's fetch. A value workerd takes as no
+ * entrypoint (a string, a number) is exported as an inert empty object, so it never stops the Worker.
+ */
+import { builtinModules } from "node:module";
+const VIRTUAL_ENTRY = "virtual:honey-build-entry";
+const RESOLVED_ENTRY = `\0${VIRTUAL_ENTRY}`;
+function importApp(app) {
+    if (app.export === "default")
+        return `import app from "./${app.entry}"`;
+    return `import { ${app.export} as app } from "./${app.entry}"`;
+}
+/** A server on every interface, as `serve(app)` starts one: the process's env, PORT before the configured port. */
+function serverEntry(app, port) {
+    return [
+        'import { serve } from "@lovrozagar/honey/serve"',
+        importApp(app),
+        "",
+        `await serve(app, { env: process.env, hostname: "0.0.0.0", port: Number(process.env.PORT ?? ${port}) })`,
+    ].join("\n");
+}
+/** A Worker: the app is its fetch, its entry's `named` exports its own, and there is nothing to listen on. */
+function workerEntry(app, _port, named) {
+    /* an export name need not be an identifier (`export { x as "a-b" }`) */
+    const names = named.map((name) => (/^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name)));
+    /*
+     * workerd loads a module only when its every named export is a function (a class among them) or an object: one
+     * string, number, boolean, null or undefined stops the Worker (`not of type 'function or ExportedHandler'`). Only
+     * the names are known here, so each value passes through as it is, or, being none of those, as an inert empty
+     * object: an entrypoint with no handler, which keeps an entry's `export const VERSION = "1"` from stopping it.
+     */
+    const passed = named.length === 0
+        ? []
+        : [
+            `import * as entry from "./${app.entry}"`,
+            'const entrypoint = (value) => (typeof value === "function" || (typeof value === "object" && value !== null) ? value : {})',
+            ...named.map((name, at) => `const named${at} = entrypoint(entry[${JSON.stringify(name)}])`),
+            `export { ${names.map((name, at) => `named${at} as ${name}`).join(", ")} }`,
+        ];
+    return [
+        importApp(app),
+        ...passed,
+        "",
+        "export default {",
+        "  fetch: (req, env, ctx) => app.fetch(req, env, ctx),",
+        "}",
+    ].join("\n");
+}
+/** The app entry's exports a Worker passes on: all but the app's own and `default`, which honey's fetch handler is. */
+async function passedOn(context, app) {
+    const resolved = await context.resolve(`./${app.entry}`);
+    if (resolved === null)
+        throw new Error(`honey build: cannot resolve the app entry ./${app.entry}`);
+    const exports = (await context.load({ id: resolved.id })).exports ?? [];
+    if (app.export !== "default" && exports.includes("default"))
+        throw new Error(`honey build: ${app.entry} exports a default beside its app "${app.export}": a Worker's default export is ` +
+            "honey's fetch handler, so the entry's own default would be lost; drop it, or export the app as the default");
+    return exports.filter((name) => name !== "default" && name !== app.export);
+}
+const TARGETS = {
+    bun: { entry: serverEntry, named: false, noExternal: false, ssrTarget: "node" },
+    cloudflare: { entry: workerEntry, named: true, noExternal: true, ssrTarget: "webworker" },
+    node: { entry: serverEntry, named: false, noExternal: false, ssrTarget: "node" },
+};
+/** The Vite plugin that builds `app` for `config.target`: `vite build` with it emits `<outDir>/index.js`. */
+export function createBuildPlugin(config, app) {
+    if (!Object.hasOwn(TARGETS, config.target)) {
+        throw new Error(`honey build: unknown target "${config.target}"; expected node, bun or cloudflare`);
+    }
+    const target = TARGETS[config.target];
+    return {
+        apply: "build",
+        config() {
+            return {
+                build: {
+                    emptyOutDir: false,
+                    minify: config.minify ?? true,
+                    outDir: config.outDir ?? "./dist",
+                    rolldownOptions: {
+                        external: [...builtinModules, ...builtinModules.map((m) => `node:${m}`), ...(config.external ?? [])],
+                        input: VIRTUAL_ENTRY,
+                        output: { entryFileNames: "index.js" },
+                    },
+                    ssr: true,
+                },
+                /* node and bun install dependencies beside the bundle; inlining them would inline native addons too */
+                ssr: { ...(target.noExternal ? { noExternal: true } : {}), target: target.ssrTarget },
+            };
+        },
+        load(id) {
+            if (id !== RESOLVED_ENTRY)
+                return undefined;
+            const port = config.port ?? 3000;
+            const module = (named) => ({ code: target.entry(app, port, named), moduleType: "js" });
+            /* only a Worker passes exports on, which needs the build to read its entry */
+            return target.named ? passedOn(this, app).then(module) : module([]);
+        },
+        name: "honey:build",
+        resolveId(id) {
+            return id === VIRTUAL_ENTRY ? RESOLVED_ENTRY : undefined;
+        },
+    };
+}