hono-preact 0.1.0

package/dist/vite/parser-options.js

@@ -0,0 +1,22 @@
+/**
+ * Shared `@babel/parser` options for every code-walk in this package.
+ *
+ * Keep this list permissive: we parse user code (`.server.ts`, `routes.ts`,
+ * `api.ts`, etc.), not just framework-authored code, so any stage-3 syntax a
+ * user might reasonably write should round-trip. A user who writes
+ * `class Foo { @inject() bar }` or `import data from './x.json' with { type: 'json' }`
+ * should not get a silent code-walk failure where the framework expected to
+ * find a `defineLoader(...)` call and ran past it.
+ *
+ * Each call site adds `sourceType: 'module'` and `errorRecovery: true`
+ * separately because both are universal at our call sites and the
+ * `ParserOptions` shape carries them as top-level fields.
+ */
+export const BABEL_PARSER_PLUGINS = [
+    'typescript',
+    'jsx',
+    'decorators',
+    'decoratorAutoAccessors',
+    'importAttributes',
+    'explicitResourceManagement',
+];

package/dist/vite/server-entry.d.ts

@@ -0,0 +1,26 @@
+import type { Plugin } from 'vite';
+export interface GenerateServerEntrySourceOptions {
+    layoutAbsPath: string;
+    routesAbsPath: string;
+    apiAbsPath: string | undefined;
+}
+export declare function generateServerEntrySource(opts: GenerateServerEntrySourceOptions): string;
+export type CatchAllWarning = {
+    kind: 'wildcard';
+    method: string;
+    pattern: string;
+    line: number | undefined;
+} | {
+    kind: 'notFound';
+    line: number | undefined;
+};
+export declare function findApiCatchAllRoutes(source: string): CatchAllWarning[];
+export declare const GENERATED_SERVER_ENTRY_RELATIVE = "node_modules/.vite/hono-preact/server-entry.tsx";
+export declare function generatedServerEntryAbsPath(cwd?: string): string;
+export interface ServerEntryPluginOptions {
+    layout: string;
+    routes: string;
+    api: string;
+    outputPath: string;
+}
+export declare function serverEntryPlugin(opts: ServerEntryPluginOptions): Plugin;

package/dist/vite/server-entry.js

@@ -0,0 +1,201 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { parse } from '@babel/parser';
+import { BABEL_PARSER_PLUGINS } from './parser-options.js';
+export function generateServerEntrySource(opts) {
+    const { layoutAbsPath, routesAbsPath, apiAbsPath } = opts;
+    const apiImport = apiAbsPath ? `import userApp from '${apiAbsPath}';\n` : '';
+    const apiMount = apiAbsPath ? `  .route('/', userApp)\n` : '';
+    // The generated source is loaded as a virtual module, which Vite/esbuild
+    // treats as plain JS by default. Use h() to construct vnodes rather than
+    // JSX so the source compiles without a TSX loader hint.
+    return (`import { Hono } from 'hono';\n` +
+        `import { h } from 'preact';\n` +
+        `import { LocationProvider } from 'preact-iso';\n` +
+        `import { Routes, env } from 'hono-preact';\n` +
+        `import {\n` +
+        `  actionsHandler,\n` +
+        `  loadersHandler,\n` +
+        `  renderPage,\n` +
+        `  routeServerModules,\n` +
+        `} from 'hono-preact/server';\n` +
+        `import Layout from '${layoutAbsPath}';\n` +
+        `import routes from '${routesAbsPath}';\n` +
+        apiImport +
+        `\n` +
+        `env.current = 'server';\n` +
+        `const serverModules = routeServerModules(routes);\n` +
+        `const handlerOpts = { dev: import.meta.env.DEV };\n` +
+        `\n` +
+        `export const app = new Hono()\n` +
+        `  .post('/__loaders', loadersHandler(serverModules, handlerOpts))\n` +
+        `  .post('/__actions', actionsHandler(serverModules, handlerOpts))\n` +
+        apiMount +
+        `  .get('*', (c) => renderPage(c, h(Layout, null, h(LocationProvider, null, h(Routes, { routes })))));\n` +
+        `\n` +
+        `export default app;\n`);
+}
+const HONO_METHODS = new Set([
+    'get',
+    'post',
+    'put',
+    'patch',
+    'delete',
+    'options',
+    'head',
+    'all',
+    'on',
+]);
+const WILDCARD_PATTERNS = new Set(['*', '/*']);
+// Walk treats these as opaque: their bodies are user handlers, not route
+// registrations. Skipping the body keeps `c.notFound()` inside a handler
+// from being mistaken for `app.notFound(...)` at registration time.
+const FUNCTION_BODY_PARENTS = new Set([
+    'FunctionDeclaration',
+    'FunctionExpression',
+    'ArrowFunctionExpression',
+    'ObjectMethod',
+    'ClassMethod',
+]);
+export function findApiCatchAllRoutes(source) {
+    const warnings = [];
+    let ast;
+    try {
+        ast = parse(source, {
+            sourceType: 'module',
+            plugins: BABEL_PARSER_PLUGINS,
+            errorRecovery: true,
+        });
+    }
+    catch (err) {
+        // If api.ts won't parse, the build will fail elsewhere with a clearer
+        // error. Surface a note so the framework user can correlate a missing
+        // catch-all warning with a parse-time syntax issue rather than wondering
+        // why nothing was reported.
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[hono-preact] Failed to parse api.ts for catch-all route detection: ${msg}. ` +
+            `The build will surface the real syntax error; this warning explains why ` +
+            `route-overlap warnings may be missing.`);
+        return warnings;
+    }
+    walk(ast.program, warnings);
+    return warnings;
+}
+function walk(node, warnings) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (Array.isArray(node)) {
+        for (const child of node)
+            walk(child, warnings);
+        return;
+    }
+    const n = node;
+    if (n.type === 'CallExpression' &&
+        n.callee?.type === 'MemberExpression' &&
+        n.callee.property?.type === 'Identifier' &&
+        typeof n.callee.property.name === 'string') {
+        const method = n.callee.property.name;
+        const line = n.loc?.start?.line;
+        if (method === 'notFound') {
+            warnings.push({ kind: 'notFound', line });
+        }
+        else if (HONO_METHODS.has(method)) {
+            const firstArg = n.arguments?.[0];
+            if (firstArg?.type === 'StringLiteral' &&
+                typeof firstArg.value === 'string' &&
+                WILDCARD_PATTERNS.has(firstArg.value)) {
+                warnings.push({
+                    kind: 'wildcard',
+                    method,
+                    pattern: firstArg.value,
+                    line,
+                });
+            }
+        }
+    }
+    const isFunctionParent = typeof n.type === 'string' && FUNCTION_BODY_PARENTS.has(n.type);
+    for (const key of Object.keys(node)) {
+        if (key === 'loc' ||
+            key === 'leadingComments' ||
+            key === 'trailingComments')
+            continue;
+        if (isFunctionParent && key === 'body')
+            continue;
+        walk(node[key], warnings);
+    }
+}
+// Project-relative path of the on-disk file the plugin writes during
+// configResolved. We use a relative path because @hono/vite-build prepends
+// `/` to the entry when constructing its `import.meta.glob([...])`, and
+// absolute paths produce a `//Users/...` double-slash that's brittle in the
+// Cloudflare Workers runtime. Project-relative keeps the resulting glob
+// pattern (`/node_modules/.vite/hono-preact/server-entry.tsx`) clean.
+//
+// We write to disk rather than register a virtual module because
+// @hono/vite-build resolves its entry via `import.meta.glob([entry])`, which
+// cannot match a `virtual:*` id. The Cloudflare Workers runtime then fails
+// with "Can't import modules from ['/virtual:...']" when it tries to load the
+// generated bundle.
+export const GENERATED_SERVER_ENTRY_RELATIVE = 'node_modules/.vite/hono-preact/server-entry.tsx';
+export function generatedServerEntryAbsPath(cwd = process.cwd()) {
+    return path.resolve(cwd, GENERATED_SERVER_ENTRY_RELATIVE);
+}
+export function serverEntryPlugin(opts) {
+    // Paths resolved during configResolved (cheap) — actual disk write
+    // happens in buildStart so config-only Vite invocations (IDE probes,
+    // typecheck-only runs, dependency-optimizer cold runs) don't side-effect
+    // the cache directory. Writing on every config resolution was a tax that
+    // showed up when integration tests loaded vite.config.ts to inspect the
+    // plugin chain.
+    let layoutAbsPath;
+    let routesAbsPath;
+    let apiAbsPath;
+    return {
+        name: 'hono-preact:server-entry',
+        enforce: 'pre',
+        configResolved(config) {
+            layoutAbsPath = path.isAbsolute(opts.layout)
+                ? opts.layout
+                : path.resolve(config.root, opts.layout);
+            routesAbsPath = path.isAbsolute(opts.routes)
+                ? opts.routes
+                : path.resolve(config.root, opts.routes);
+            const candidateApi = path.isAbsolute(opts.api)
+                ? opts.api
+                : path.resolve(config.root, opts.api);
+            apiAbsPath = fs.existsSync(candidateApi) ? candidateApi : undefined;
+        },
+        buildStart() {
+            // configResolved must have run first. Bail loudly if not — silent
+            // emission of a stub would be much harder to debug.
+            if (!layoutAbsPath || !routesAbsPath) {
+                throw new Error('[hono-preact] server-entry buildStart fired before configResolved; ' +
+                    'layout/routes paths were never resolved.');
+            }
+            const source = generateServerEntrySource({
+                layoutAbsPath,
+                routesAbsPath,
+                apiAbsPath,
+            });
+            fs.mkdirSync(path.dirname(opts.outputPath), { recursive: true });
+            fs.writeFileSync(opts.outputPath, source, 'utf8');
+            if (!apiAbsPath)
+                return;
+            const apiSource = fs.readFileSync(apiAbsPath, 'utf8');
+            const warnings = findApiCatchAllRoutes(apiSource);
+            for (const w of warnings) {
+                const where = `${apiAbsPath}${w.line != null ? `:${w.line}` : ''}`;
+                if (w.kind === 'notFound') {
+                    this.warn(`[hono-preact] ${where}: app.notFound(...) acts as a catch-all and ` +
+                        `will be shadowed by the framework's renderPage handler. ` +
+                        `Move the behavior to a more specific path, or accept that it won't fire.`);
+                }
+                else {
+                    this.warn(`[hono-preact] ${where}: app.${w.method}('${w.pattern}', ...) is a ` +
+                        `catch-all route and will be shadowed by the framework's renderPage ` +
+                        `handler. Move it to a more specific path, or accept that it won't fire.`);
+                }
+            }
+        },
+    };
+}

package/dist/vite/server-loader-validation.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export declare function serverLoaderValidationPlugin(): Plugin;

package/dist/vite/server-loader-validation.js

@@ -0,0 +1,73 @@
+import { parse } from '@babel/parser';
+import { BABEL_PARSER_PLUGINS } from './parser-options.js';
+const ALLOWED_NAMED_EXPORTS = new Set([
+    'serverActions',
+    'actionGuards',
+    'serverLoaders',
+]);
+const ALLOWED_NAMED_EXPORTS_LIST = [...ALLOWED_NAMED_EXPORTS]
+    .map((n) => `'${n}'`)
+    .join(', ');
+export function serverLoaderValidationPlugin() {
+    return {
+        name: 'server-loader-validation',
+        enforce: 'pre',
+        transform(code, id) {
+            if (!/\.server\.[jt]sx?$/.test(id))
+                return;
+            const ast = parse(code, {
+                sourceType: 'module',
+                plugins: BABEL_PARSER_PLUGINS,
+                errorRecovery: true,
+            });
+            let hasDefault = false;
+            const namedExports = [];
+            const errors = [];
+            for (const node of ast.program.body) {
+                if (node.type === 'ExportDefaultDeclaration') {
+                    hasDefault = true;
+                }
+                else if (node.type === 'ExportAllDeclaration') {
+                    errors.push(`${id}: .server files may not use 'export * from ...'. Use explicit named exports only.`);
+                }
+                else if (node.type === 'ExportNamedDeclaration') {
+                    const named = node;
+                    if (named.exportKind === 'type')
+                        continue;
+                    for (const s of named.specifiers) {
+                        namedExports.push(s.exported.type === 'Identifier'
+                            ? s.exported.name
+                            : s.exported.value);
+                    }
+                    if (named.declaration?.type === 'FunctionDeclaration' &&
+                        named.declaration.id) {
+                        namedExports.push(named.declaration.id.name);
+                    }
+                    else if (named.declaration?.type === 'VariableDeclaration') {
+                        for (const decl of named.declaration.declarations) {
+                            if (decl.id.type === 'Identifier')
+                                namedExports.push(decl.id.name);
+                        }
+                    }
+                }
+            }
+            const disallowedExports = namedExports.filter((n) => !ALLOWED_NAMED_EXPORTS.has(n));
+            if (disallowedExports.length > 0) {
+                errors.push(`${id}: .server files may only export ${ALLOWED_NAMED_EXPORTS_LIST} as named exports (found: ${disallowedExports.join(', ')}). ` +
+                    `Export the server loader as the default export only.`);
+            }
+            if (hasDefault) {
+                errors.push(`${id}: .server files may not use a default export. ` +
+                    `Use \`export const serverLoaders = { default: defineLoader(...) }\` instead.`);
+            }
+            if (!namedExports.includes('serverActions') &&
+                !namedExports.includes('serverLoaders')) {
+                errors.push(`${id}: .server files must export either 'serverLoaders' or 'serverActions'. ` +
+                    `Use \`export const serverLoaders = { default: defineLoader(fn) }\` to define loaders.`);
+            }
+            if (errors.length > 0) {
+                this.error(errors.join('\n'));
+            }
+        },
+    };
+}

package/dist/vite/server-loaders-parser.d.ts

@@ -0,0 +1,22 @@
+import type { Program, CallExpression, ObjectExpression } from '@babel/types';
+export type ParsedLoaderEntry = {
+    /** Loader name (the key in serverLoaders, e.g. "summary"). */
+    name: string;
+    /** The defineLoader(...) CallExpression node -- for AST-mutation consumers. */
+    call: CallExpression;
+    /** The opts ObjectExpression if defineLoader has 2 args; otherwise null. */
+    optsArg: ObjectExpression | null;
+};
+/**
+ * Walk a parsed program for `export const serverLoaders = { name: defineLoader(fn, opts?), ... }`.
+ * Returns one entry per object property whose value is a defineLoader(...) call.
+ * Non-matching properties (spread elements, computed keys, non-call values) are silently skipped.
+ * If `serverLoaders` is absent or has the wrong shape, returns [].
+ */
+export declare function parseServerLoaders(program: Program): ParsedLoaderEntry[];
+/**
+ * Read the `params` option from a defineLoader opts ObjectExpression literal.
+ * Returns `string[]` for array literals of string literals, `'*'` for the
+ * wildcard string literal, or undefined if not present or unsupported shape.
+ */
+export declare function readParamsOpt(opts: ObjectExpression): string[] | '*' | undefined;

package/dist/vite/server-loaders-parser.js

@@ -0,0 +1,64 @@
+/**
+ * Walk a parsed program for `export const serverLoaders = { name: defineLoader(fn, opts?), ... }`.
+ * Returns one entry per object property whose value is a defineLoader(...) call.
+ * Non-matching properties (spread elements, computed keys, non-call values) are silently skipped.
+ * If `serverLoaders` is absent or has the wrong shape, returns [].
+ */
+export function parseServerLoaders(program) {
+    const entries = [];
+    for (const stmt of program.body) {
+        if (stmt.type !== 'ExportNamedDeclaration' ||
+            stmt.declaration?.type !== 'VariableDeclaration')
+            continue;
+        for (const decl of stmt.declaration.declarations) {
+            if (decl.id.type !== 'Identifier' ||
+                decl.id.name !== 'serverLoaders' ||
+                decl.init?.type !== 'ObjectExpression')
+                continue;
+            const obj = decl.init;
+            for (const prop of obj.properties) {
+                if (prop.type !== 'ObjectProperty' ||
+                    prop.key.type !== 'Identifier' ||
+                    prop.value.type !== 'CallExpression')
+                    continue;
+                const call = prop.value;
+                if (call.callee.type !== 'Identifier' ||
+                    call.callee.name !== 'defineLoader')
+                    continue;
+                const secondArg = call.arguments[1];
+                const optsArg = secondArg?.type === 'ObjectExpression'
+                    ? secondArg
+                    : null;
+                entries.push({ name: prop.key.name, call, optsArg });
+            }
+        }
+    }
+    return entries;
+}
+/**
+ * Read the `params` option from a defineLoader opts ObjectExpression literal.
+ * Returns `string[]` for array literals of string literals, `'*'` for the
+ * wildcard string literal, or undefined if not present or unsupported shape.
+ */
+export function readParamsOpt(opts) {
+    for (const prop of opts.properties) {
+        if (prop.type !== 'ObjectProperty' ||
+            prop.key.type !== 'Identifier' ||
+            prop.key.name !== 'params')
+            continue;
+        const val = prop.value;
+        if (val.type === 'StringLiteral' && val.value === '*') {
+            return '*';
+        }
+        if (val.type === 'ArrayExpression') {
+            const items = [];
+            for (const el of val.elements) {
+                if (el?.type === 'StringLiteral')
+                    items.push(el.value);
+            }
+            if (items.length > 0)
+                return items;
+        }
+    }
+    return undefined;
+}

package/dist/vite/server-only.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export declare const VITE_ROOT_ACCESSOR: unique symbol;
+export declare function serverOnlyPlugin(): Plugin;

package/dist/vite/server-only.js

@@ -0,0 +1,244 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { parse } from '@babel/parser';
+import MagicString from 'magic-string';
+import { deriveModuleKey } from './module-key.js';
+import { parseServerLoaders, readParamsOpt } from './server-loaders-parser.js';
+import { BABEL_PARSER_PLUGINS } from './parser-options.js';
+// Symbol-keyed accessor used by unit tests to verify `configResolved` fires
+// and captures the root. Hidden behind a Symbol so it does not appear in IDE
+// autocomplete for the public Plugin surface.
+export const VITE_ROOT_ACCESSOR = Symbol.for('@hono-preact/vite/server-only/viteRoot');
+/**
+ * Reads a .server.* file synchronously and extracts the `params` option from
+ * each entry in the `serverLoaders` ObjectExpression. Returns a map of
+ * { loaderName -> params } for loaders that declare non-default params.
+ * Returns an empty object if the file cannot be parsed or has no serverLoaders.
+ */
+function readSourceWithExtensionFallback(absServerPath) {
+    // TypeScript NodeNext convention: source code imports `.server.js` even
+    // though the file on disk is `.server.ts` (or .tsx). Try the literal path
+    // first (handles plain `.js` cases), then the TS-extension swaps.
+    const tries = [
+        absServerPath,
+        absServerPath.replace(/\.js$/, '.ts'),
+        absServerPath.replace(/\.jsx$/, '.tsx'),
+    ];
+    for (const p of tries) {
+        try {
+            return fs.readFileSync(p, 'utf8');
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return null;
+}
+function extractServerLoadersMeta(absServerPath) {
+    const src = readSourceWithExtensionFallback(absServerPath);
+    if (src == null)
+        return {};
+    let ast;
+    try {
+        ast = parse(src, {
+            sourceType: 'module',
+            plugins: BABEL_PARSER_PLUGINS,
+            errorRecovery: true,
+        });
+    }
+    catch {
+        return {};
+    }
+    const entries = parseServerLoaders(ast.program);
+    const meta = {};
+    for (const entry of entries) {
+        if (!entry.optsArg)
+            continue;
+        const params = readParamsOpt(entry.optsArg);
+        if (params !== undefined)
+            meta[entry.name] = params;
+    }
+    return meta;
+}
+function findDynamicServerImports(node, found) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (Array.isArray(node)) {
+        for (const child of node)
+            findDynamicServerImports(child, found);
+        return;
+    }
+    const n = node;
+    if (n.type === 'CallExpression' &&
+        n.callee?.type === 'Import' &&
+        n.arguments?.[0]?.type === 'StringLiteral' &&
+        typeof n.arguments[0].value === 'string' &&
+        /\.server(\.[jt]sx?)?$/.test(n.arguments[0].value)) {
+        found.push({
+            start: n.start,
+            end: n.end,
+            source: n.arguments[0].value,
+        });
+    }
+    for (const key of Object.keys(node)) {
+        if (key === 'loc' ||
+            key === 'leadingComments' ||
+            key === 'trailingComments')
+            continue;
+        findDynamicServerImports(node[key], found);
+    }
+}
+export function serverOnlyPlugin() {
+    let viteRoot;
+    return {
+        name: 'server-only',
+        enforce: 'pre',
+        configResolved(config) {
+            viteRoot = config.root;
+        },
+        [VITE_ROOT_ACCESSOR]: () => viteRoot,
+        transform(code, id, options) {
+            if (options?.ssr)
+                return;
+            if (!/\.[jt]sx?$/.test(id))
+                return;
+            if (/\.server\.[jt]sx?$/.test(id))
+                return;
+            if (!code.includes('.server'))
+                return;
+            const ast = parse(code, {
+                sourceType: 'module',
+                plugins: BABEL_PARSER_PLUGINS,
+                errorRecovery: true,
+            });
+            for (const node of ast.program.body) {
+                if ((node.type === 'ExportNamedDeclaration' ||
+                    node.type === 'ExportAllDeclaration') &&
+                    node.source &&
+                    /\.server(\.[jt]sx?)?$/.test(node.source.value)) {
+                    throw new Error(`${id}: re-export from '${node.source.value}' (a .server.* module) is not supported. ` +
+                        `Import the named member directly instead, e.g. ` +
+                        `\`import { loader } from '${node.source.value}';\``);
+                }
+            }
+            const isServerImport = (node) => node.type === 'ImportDeclaration' &&
+                /\.server(\.[jt]sx?)?$/.test(node.source.value);
+            const serverImports = ast.program.body.filter(isServerImport);
+            const dynamicServerImports = [];
+            findDynamicServerImports(ast.program, dynamicServerImports);
+            if (serverImports.length === 0 && dynamicServerImports.length === 0)
+                return;
+            if (serverImports.length > 0 && viteRoot === undefined) {
+                this.warn(`serverOnlyPlugin: configResolved hasn't fired before transform on ${id}. ` +
+                    `.server.* imports will not be transformed; this can leak server code into the client bundle. ` +
+                    `Ensure moduleKeyPlugin and serverOnlyPlugin are added to the Vite config under the standard plugin pipeline.`);
+                return;
+            }
+            const importerDir = path.dirname(id);
+            const s = new MagicString(code);
+            let needsCreateLoaderStubImport = false;
+            let needsUseActionImport = false;
+            for (const serverImport of [...serverImports].reverse()) {
+                if (serverImport.importKind ===
+                    'type') {
+                    s.overwrite(serverImport.start, serverImport.end, '');
+                    continue;
+                }
+                // viteRoot is guaranteed defined here: the early-return above bails when
+                // we have static imports without a viteRoot. Dynamic-only files skip this
+                // loop entirely.
+                const absServerPath = path.resolve(importerDir, serverImport.source.value);
+                const moduleKey = deriveModuleKey(absServerPath, viteRoot);
+                if (moduleKey.startsWith('..')) {
+                    this.warn(`serverOnlyPlugin: import of '${serverImport.source.value}' from '${id}' resolves outside the Vite root (${viteRoot}). ` +
+                        `Generated module key '${moduleKey}' will not match any server-side moduleKeyPlugin output, so RPC calls will return 404. ` +
+                        `Move the .server.* file inside the Vite root, or restructure the import.`);
+                }
+                const stubs = [];
+                let hasValueSpecifier = false;
+                for (const specifier of serverImport.specifiers) {
+                    if (specifier.importKind ===
+                        'type') {
+                        continue;
+                    }
+                    hasValueSpecifier = true;
+                    if (specifier.type === 'ImportSpecifier' &&
+                        specifier.imported.type === 'Identifier' &&
+                        specifier.imported.name === 'serverLoaders') {
+                        needsCreateLoaderStubImport = true;
+                        const absServerPath = path.resolve(importerDir, serverImport.source.value);
+                        const loadersMeta = extractServerLoadersMeta(absServerPath);
+                        const metaVar = `__$serverLoadersMeta_${specifier.local.name}`;
+                        const metaJson = JSON.stringify(loadersMeta);
+                        stubs.push(`const ${metaVar} = ${metaJson};\n` +
+                            `const ${specifier.local.name} = new Proxy({}, {\n` +
+                            `  get(_, name) {\n` +
+                            `    const __meta = ${metaVar}[String(name)];\n` +
+                            `    return __$createLoaderStub_hpiso({\n` +
+                            `      __moduleKey: ${JSON.stringify(moduleKey)},\n` +
+                            `      __loaderName: String(name),\n` +
+                            `      params: __meta,\n` +
+                            `    });\n` +
+                            `  }\n` +
+                            `});`);
+                    }
+                    else if (specifier.type === 'ImportSpecifier' &&
+                        specifier.imported.type === 'Identifier' &&
+                        specifier.imported.name === 'actionGuards') {
+                        stubs.push(`const ${specifier.local.name} = [];`);
+                    }
+                    else if (specifier.type === 'ImportSpecifier' &&
+                        specifier.imported.type === 'Identifier' &&
+                        specifier.imported.name === 'serverActions') {
+                        needsUseActionImport = true;
+                        stubs.push(`const ${specifier.local.name} = new Proxy({}, {\n` +
+                            `  get(_, action) {\n` +
+                            `    const stub = { __module: ${JSON.stringify(moduleKey)}, __action: String(action) };\n` +
+                            `    stub.useAction = (opts) => __$useAction_hpiso(stub, opts);\n` +
+                            `    return stub;\n` +
+                            `  }\n` +
+                            `});`);
+                    }
+                    else {
+                        const importedName = specifier.type === 'ImportSpecifier' &&
+                            specifier.imported.type === 'Identifier'
+                            ? specifier.imported.name
+                            : specifier.type === 'ImportNamespaceSpecifier'
+                                ? '* as ' + specifier.local.name
+                                : '<unknown>';
+                        throw new Error(`${id}: \`${importedName}\` is not a recognized export from a *.server.* module. ` +
+                            `Allowed: serverLoaders, serverActions, actionGuards.`);
+                    }
+                }
+                if (stubs.length > 0) {
+                    s.overwrite(serverImport.start, serverImport.end, stubs.join('\n'));
+                }
+                else if (!hasValueSpecifier) {
+                    s.overwrite(serverImport.start, serverImport.end, '');
+                }
+            }
+            for (const imp of [...dynamicServerImports].reverse()) {
+                // Preserve __moduleKey in the client stub so callers (e.g.
+                // defineRoutes' wrapWithRouteLocations) can identify which server
+                // module this lazy import represents, even though the body is
+                // replaced with an empty resolved promise.
+                let stubContent = '{}';
+                if (viteRoot !== undefined) {
+                    const absServerPath = path.resolve(importerDir, imp.source);
+                    const moduleKey = deriveModuleKey(absServerPath, viteRoot);
+                    if (!moduleKey.startsWith('..')) {
+                        stubContent = `{ __moduleKey: ${JSON.stringify(moduleKey)} }`;
+                    }
+                }
+                s.overwrite(imp.start, imp.end, `Promise.resolve(${stubContent})`);
+            }
+            if (needsCreateLoaderStubImport) {
+                s.prepend(`import { __$createLoaderStub_hpiso } from 'hono-preact/internal';\n`);
+            }
+            if (needsUseActionImport) {
+                s.prepend(`import { useAction as __$useAction_hpiso } from 'hono-preact';\n`);
+            }
+            return { code: s.toString(), map: s.generateMap({ hires: true }) };
+        },
+    };
+}

package/dist/vite.d.ts

@@ -0,0 +1 @@
+export * from './vite/index';

package/dist/vite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../src/vite.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/vite.js

@@ -0,0 +1 @@
+export * from './vite/index.js';