hono-preact 0.1.0

package/dist/server/sse.js

@@ -0,0 +1,83 @@
+import { streamSSE } from 'hono/streaming';
+function encodeErrorPayload(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const name = err instanceof Error ? err.name : 'Error';
+    return JSON.stringify({ message, name });
+}
+/**
+ * Wrap an async generator as an SSE response.
+ *
+ * Each yield is JSON-encoded and written as a `data:` event.
+ * If `emitResult` is true and the generator's return value is defined,
+ * it is written as `event: result\ndata: <json>` before the stream closes.
+ * If the generator throws, an `event: error\ndata: {"message","name"}` frame
+ * is written and the stream closes cleanly (Hono's default error handler is
+ * never invoked because we catch inside the callback).
+ */
+export function sseGeneratorResponse(c, gen, options = {}) {
+    const { emitResult = false } = options;
+    return streamSSE(c, async (stream) => {
+        try {
+            while (!stream.aborted) {
+                const step = await gen.next();
+                if (step.done) {
+                    if (emitResult && step.value !== undefined) {
+                        await stream.writeSSE({
+                            event: 'result',
+                            data: JSON.stringify(step.value),
+                        });
+                    }
+                    return;
+                }
+                await stream.writeSSE({ data: JSON.stringify(step.value) });
+            }
+            // Aborted; release the generator cleanly.
+            await gen.return(undefined).catch(() => {
+                /* swallow */
+            });
+        }
+        catch (err) {
+            await gen.return(undefined).catch(() => {
+                /* swallow */
+            });
+            await stream.writeSSE({
+                event: 'error',
+                data: encodeErrorPayload(err),
+            });
+        }
+    });
+}
+/**
+ * Wrap a ReadableStream<T> (with T a JSON-encodable value) as an SSE response.
+ * Each enqueued chunk is JSON-encoded and written as a `data:` event.
+ */
+export function sseReadableStreamResponse(c, source) {
+    return streamSSE(c, async (stream) => {
+        const reader = source.getReader();
+        try {
+            while (!stream.aborted) {
+                const { done, value } = await reader.read();
+                if (done)
+                    return;
+                await stream.writeSSE({ data: JSON.stringify(value) });
+            }
+        }
+        catch (err) {
+            await stream.writeSSE({
+                event: 'error',
+                data: encodeErrorPayload(err),
+            });
+        }
+        finally {
+            reader.cancel().catch(() => {
+                /* swallow */
+            });
+        }
+    });
+}
+export function isAsyncGenerator(value) {
+    return (value != null &&
+        typeof value === 'object' &&
+        typeof value[Symbol.asyncIterator] === 'function' &&
+        typeof value.next === 'function');
+}

package/dist/server.d.ts

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

package/dist/server.d.ts.map

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

package/dist/server.js

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

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

@@ -0,0 +1,10 @@
+import type { Plugin } from 'vite';
+export declare const VIRTUAL_CLIENT_ENTRY_ID = "virtual:hono-preact/client";
+export interface GenerateClientEntrySourceOptions {
+    routesAbsPath: string;
+}
+export declare function generateClientEntrySource(opts: GenerateClientEntrySourceOptions): string;
+export interface ClientEntryPluginOptions {
+    routes: string;
+}
+export declare function clientEntryPlugin(opts: ClientEntryPluginOptions): Plugin;

package/dist/vite/client-entry.js

@@ -0,0 +1,47 @@
+import * as path from 'node:path';
+export const VIRTUAL_CLIENT_ENTRY_ID = 'virtual:hono-preact/client';
+const RESOLVED_ID = '\0' + VIRTUAL_CLIENT_ENTRY_ID;
+export function generateClientEntrySource(opts) {
+    return (`import { h, hydrate } from 'preact';\n` +
+        `import { LocationProvider } from 'preact-iso';\n` +
+        `import { Routes } from 'hono-preact';\n` +
+        `import { __dispatchRouteChange, installStreamRegistry } from 'hono-preact/internal';\n` +
+        `import routes from '${opts.routesAbsPath}';\n` +
+        `\n` +
+        `installStreamRegistry();\n` +
+        `\n` +
+        `let lastPath;\n` +
+        `function onRouteChange(path) {\n` +
+        `  const from = lastPath;\n` +
+        `  lastPath = path;\n` +
+        `  __dispatchRouteChange(path, from);\n` +
+        `}\n` +
+        `\n` +
+        `hydrate(\n` +
+        `  h(LocationProvider, null,\n` +
+        `    h(Routes, { routes, onRouteChange })\n` +
+        `  ),\n` +
+        `  document.getElementById('app')\n` +
+        `);\n`);
+}
+export function clientEntryPlugin(opts) {
+    let routesAbsPath = '';
+    return {
+        name: 'hono-preact:client-entry',
+        enforce: 'pre',
+        configResolved(config) {
+            routesAbsPath = path.isAbsolute(opts.routes)
+                ? opts.routes
+                : path.resolve(config.root, opts.routes);
+        },
+        resolveId(id) {
+            if (id === VIRTUAL_CLIENT_ENTRY_ID)
+                return RESOLVED_ID;
+        },
+        load(id) {
+            if (id !== RESOLVED_ID)
+                return;
+            return generateClientEntrySource({ routesAbsPath });
+        },
+    };
+}

package/dist/vite/client-shim.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from 'vite';
+/**
+ * Defines a minimal `process` object on the global so libraries that read
+ * `process.env.NODE_ENV` at module-evaluation time in the browser do not
+ * throw a `ReferenceError`. The shim is `??=` so it never clobbers an
+ * existing `process` (other shims, polyfills, runtime injection).
+ *
+ * Mounted by transforming the configured client entry to prepend an import
+ * of a virtual module that carries the shim source. This guarantees the
+ * shim runs first regardless of the order of the user's other imports.
+ */
+export declare function clientShimPlugin(clientEntry: string): Plugin;

package/dist/vite/client-shim.js

@@ -0,0 +1,62 @@
+import path from 'node:path';
+const VIRTUAL_ID = 'virtual:hono-preact/client-shim';
+const RESOLVED_ID = '\0' + VIRTUAL_ID;
+/**
+ * Defines a minimal `process` object on the global so libraries that read
+ * `process.env.NODE_ENV` at module-evaluation time in the browser do not
+ * throw a `ReferenceError`. The shim is `??=` so it never clobbers an
+ * existing `process` (other shims, polyfills, runtime injection).
+ *
+ * Mounted by transforming the configured client entry to prepend an import
+ * of a virtual module that carries the shim source. This guarantees the
+ * shim runs first regardless of the order of the user's other imports.
+ */
+export function clientShimPlugin(clientEntry) {
+    let resolvedEntry = null;
+    let shimSource = '';
+    return {
+        name: 'hono-preact:client-shim',
+        enforce: 'pre',
+        apply(_, { command, mode }) {
+            // Inject during dev (`vite serve`) and the client build only. The SSR
+            // build runs in Node/Workers and does not need the shim.
+            return command === 'serve' || (command === 'build' && mode === 'client');
+        },
+        configResolved(config) {
+            resolvedEntry = path.resolve(config.root, clientEntry);
+            const nodeEnv = config.isProduction ? 'production' : 'development';
+            shimSource = `globalThis.process ??= { env: { NODE_ENV: ${JSON.stringify(nodeEnv)} } };\n`;
+        },
+        resolveId(id) {
+            if (id === VIRTUAL_ID)
+                return RESOLVED_ID;
+        },
+        load(id) {
+            if (id === RESOLVED_ID)
+                return shimSource;
+        },
+        transform(code, id) {
+            if (resolvedEntry === null)
+                return;
+            // Virtual client entry: matches the resolved virtual id directly. The
+            // configured `clientEntry` carries the unresolved `virtual:` form, which
+            // we mirror here so the shim still injects.
+            if (clientEntry.startsWith('virtual:') && id === '\0' + clientEntry) {
+                return {
+                    code: `import '${VIRTUAL_ID}';\n${code}`,
+                    map: null,
+                };
+            }
+            // Disk-based entry: equal, or `<entry>?<query>`.
+            if (!id.startsWith(resolvedEntry))
+                return;
+            const tail = id.length - resolvedEntry.length;
+            if (tail !== 0 && id.charCodeAt(resolvedEntry.length) !== 63 /* '?' */)
+                return;
+            return {
+                code: `import '${VIRTUAL_ID}';\n${code}`,
+                map: null,
+            };
+        },
+    };
+}

package/dist/vite/guard-strip.d.ts

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

package/dist/vite/guard-strip.js

@@ -0,0 +1,96 @@
+import { parse } from '@babel/parser';
+import MagicString from 'magic-string';
+import { BABEL_PARSER_PLUGINS } from './parser-options.js';
+const ISO_PACKAGE_SOURCES = new Set(['../iso/index.js', 'hono-preact']);
+const NOOP_IMPORT_SOURCE = 'hono-preact/internal';
+const NOOP_LOCAL_NAME = '__$guardNoop_hpiso';
+function collectLocalBindings(ast, targets) {
+    const bindings = new Map();
+    for (const node of ast.program.body) {
+        if (node.type !== 'ImportDeclaration')
+            continue;
+        const imp = node;
+        if (!ISO_PACKAGE_SOURCES.has(imp.source.value))
+            continue;
+        for (const spec of imp.specifiers) {
+            if (spec.type !== 'ImportSpecifier')
+                continue;
+            if (spec.imported.type !== 'Identifier')
+                continue;
+            const name = spec.imported.name;
+            if (name === 'defineServerGuard' || name === 'defineClientGuard') {
+                if (targets.has(name)) {
+                    bindings.set(spec.local.name, name);
+                }
+            }
+        }
+    }
+    return bindings;
+}
+function findCallsByLocalName(node, bindings, hits) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (Array.isArray(node)) {
+        for (const child of node)
+            findCallsByLocalName(child, bindings, hits);
+        return;
+    }
+    const n = node;
+    if (n.type === 'CallExpression' &&
+        n.callee?.type === 'Identifier' &&
+        n.callee.name &&
+        bindings.has(n.callee.name) &&
+        n.arguments &&
+        n.arguments.length >= 1 &&
+        n.arguments[0].start !== undefined &&
+        n.arguments[0].end !== undefined) {
+        hits.push({
+            start: n.start,
+            end: n.end,
+            argStart: n.arguments[0].start,
+            argEnd: n.arguments[0].end,
+        });
+    }
+    for (const key of Object.keys(node)) {
+        if (key === 'loc' ||
+            key === 'leadingComments' ||
+            key === 'trailingComments')
+            continue;
+        findCallsByLocalName(node[key], bindings, hits);
+    }
+}
+export function guardStripPlugin() {
+    return {
+        name: 'hono-preact:guard-strip',
+        enforce: 'pre',
+        transform(code, id, options) {
+            if (!/\.[jt]sx?$/.test(id))
+                return;
+            if (/\.server\.[jt]sx?$/.test(id))
+                return;
+            const stripping = options?.ssr
+                ? 'defineClientGuard'
+                : 'defineServerGuard';
+            if (!code.includes(stripping))
+                return;
+            const ast = parse(code, {
+                sourceType: 'module',
+                plugins: BABEL_PARSER_PLUGINS,
+                errorRecovery: true,
+            });
+            const bindings = collectLocalBindings(ast, new Set([stripping]));
+            if (bindings.size === 0)
+                return;
+            const hits = [];
+            findCallsByLocalName(ast.program, bindings, hits);
+            if (hits.length === 0)
+                return;
+            const s = new MagicString(code);
+            for (const hit of [...hits].reverse()) {
+                s.overwrite(hit.argStart, hit.argEnd, NOOP_LOCAL_NAME);
+            }
+            s.prepend(`import { ${NOOP_LOCAL_NAME} } from '${NOOP_IMPORT_SOURCE}';\n`);
+            return { code: s.toString(), map: s.generateMap({ hires: true }) };
+        },
+    };
+}

package/dist/vite/hono-preact.d.ts

@@ -0,0 +1,12 @@
+import { type BuildEnvironmentOptions, type Plugin } from 'vite';
+export interface HonoPreactOptions {
+    layout?: string;
+    routes?: string;
+    api?: string;
+    clientEntry?: string;
+    entry?: string;
+    clientBuild?: BuildEnvironmentOptions;
+    serverBuild?: BuildEnvironmentOptions;
+    sharedBuild?: BuildEnvironmentOptions;
+}
+export declare function honoPreact(options?: HonoPreactOptions): Plugin[];

package/dist/vite/hono-preact.js

@@ -0,0 +1,111 @@
+import build from '@hono/vite-build/cloudflare-workers';
+import devServer, { defaultOptions } from '@hono/vite-dev-server';
+import cloudflareAdapter from '@hono/vite-dev-server/cloudflare';
+import preact from '@preact/preset-vite';
+import { clientShimPlugin } from './client-shim.js';
+import { clientEntryPlugin, VIRTUAL_CLIENT_ENTRY_ID } from './client-entry.js';
+import { serverLoaderValidationPlugin } from './server-loader-validation.js';
+import { moduleKeyPlugin } from './module-key-plugin.js';
+import { serverOnlyPlugin } from './server-only.js';
+import { guardStripPlugin } from './guard-strip.js';
+import { GENERATED_SERVER_ENTRY_RELATIVE, generatedServerEntryAbsPath, serverEntryPlugin, } from './server-entry.js';
+export function honoPreact(options = {}) {
+    const { layout = 'src/Layout.tsx', routes = 'src/routes.ts', api = 'src/api.ts', clientEntry = VIRTUAL_CLIENT_ENTRY_ID, entry, clientBuild = {}, serverBuild = {}, sharedBuild = {}, } = options;
+    const useGeneratedEntry = entry === undefined;
+    const resolvedEntry = entry ?? GENERATED_SERVER_ENTRY_RELATIVE;
+    const configPlugin = {
+        name: 'hono-preact:config',
+        config(_, { mode }) {
+            const shared = {
+                resolve: {
+                    dedupe: ['preact', 'preact/compat', 'preact/hooks', 'preact-iso'],
+                },
+                build: {
+                    target: 'esnext',
+                    assetsDir: 'static',
+                    ssrEmitAssets: true,
+                    minify: true,
+                    ...sharedBuild,
+                },
+            };
+            if (mode === 'client') {
+                const { rollupOptions: userRollup, ...restClientBuild } = clientBuild;
+                return {
+                    ...shared,
+                    build: {
+                        ...shared.build,
+                        sourcemap: true,
+                        cssCodeSplit: true,
+                        copyPublicDir: false,
+                        ...restClientBuild,
+                        rollupOptions: {
+                            input: userRollup?.input ?? [clientEntry],
+                            output: {
+                                entryFileNames: 'static/client.js',
+                                chunkFileNames: 'static/[name]-[hash].js',
+                                assetFileNames: 'static/[name]-[hash].[ext]',
+                                // Array-form output is not supported; use an OutputOptions object to
+                                // override individual fields (entryFileNames, chunkFileNames, etc.).
+                                ...(userRollup?.output && !Array.isArray(userRollup.output)
+                                    ? userRollup.output
+                                    : {}),
+                            },
+                        },
+                    },
+                };
+            }
+            return {
+                ...shared,
+                ssr: {
+                    noExternal: ['preact-render-to-string', 'preact-iso', 'hono-preact'],
+                },
+                build: {
+                    ...shared.build,
+                    // Inline sourcemaps so SSR error stacks point at user source
+                    // (e.g. `pages/issue.server.ts:42`) instead of the rolled-up
+                    // Worker chunk. We pick `inline` over a separate .map file because
+                    // SSR is a single bundle and Workers tooling will not look at a
+                    // sibling .map. Bundle size grows; for typical app server bundles
+                    // this is a few hundred KB at most and is worth the debuggability.
+                    // Users can override by passing `serverBuild.sourcemap: false`.
+                    sourcemap: 'inline',
+                    ...serverBuild,
+                },
+            };
+        },
+    };
+    return [
+        configPlugin,
+        clientShimPlugin(clientEntry),
+        clientEntryPlugin({ routes }),
+        ...(useGeneratedEntry
+            ? [
+                serverEntryPlugin({
+                    layout,
+                    routes,
+                    api,
+                    outputPath: generatedServerEntryAbsPath(),
+                }),
+            ]
+            : []),
+        serverLoaderValidationPlugin(),
+        moduleKeyPlugin(),
+        serverOnlyPlugin(),
+        guardStripPlugin(),
+        Object.assign(build({ entry: resolvedEntry }), {
+            apply: (_, { command, mode }) => command === 'build' && mode !== 'client',
+        }),
+        Object.assign(devServer({
+            entry: resolvedEntry,
+            exclude: [
+                ...defaultOptions.exclude,
+                /\.scss/,
+                /\.css/,
+                /\?url/,
+                /\?inline/,
+            ],
+            adapter: cloudflareAdapter,
+        }), { apply: 'serve' }),
+        ...preact(),
+    ];
+}

package/dist/vite/index.d.ts

@@ -0,0 +1,7 @@
+export { honoPreact } from './hono-preact.js';
+export { serverLoaderValidationPlugin } from './server-loader-validation.js';
+export { serverOnlyPlugin, VITE_ROOT_ACCESSOR } from './server-only.js';
+export { moduleKeyPlugin } from './module-key-plugin.js';
+export { GENERATED_SERVER_ENTRY_RELATIVE, generatedServerEntryAbsPath, serverEntryPlugin, } from './server-entry.js';
+export { clientEntryPlugin, VIRTUAL_CLIENT_ENTRY_ID } from './client-entry.js';
+export { guardStripPlugin } from './guard-strip.js';

package/dist/vite/index.js

@@ -0,0 +1,7 @@
+export { honoPreact } from './hono-preact.js';
+export { serverLoaderValidationPlugin } from './server-loader-validation.js';
+export { serverOnlyPlugin, VITE_ROOT_ACCESSOR } from './server-only.js';
+export { moduleKeyPlugin } from './module-key-plugin.js';
+export { GENERATED_SERVER_ENTRY_RELATIVE, generatedServerEntryAbsPath, serverEntryPlugin, } from './server-entry.js';
+export { clientEntryPlugin, VIRTUAL_CLIENT_ENTRY_ID } from './client-entry.js';
+export { guardStripPlugin } from './guard-strip.js';

package/dist/vite/module-key-plugin.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from 'vite';
+/**
+ * Transforms `.server.*` files to inject a stable module-level
+ * `__moduleKey` export and to thread that key into `defineLoader` calls.
+ * The key is path-derived (see `deriveModuleKey`), so it survives builds
+ * and HMR, and is unique per file.
+ *
+ * Pairs with `serverOnlyPlugin`, which transforms client-side imports of
+ * `.server.*` files. Both plugins compute the same key from the same
+ * absolute path + viteRoot.
+ */
+export declare function moduleKeyPlugin(): Plugin;

package/dist/vite/module-key-plugin.js

@@ -0,0 +1,114 @@
+import { parse } from '@babel/parser';
+import MagicString from 'magic-string';
+import { deriveModuleKey } from './module-key.js';
+import { parseServerLoaders } from './server-loaders-parser.js';
+import { BABEL_PARSER_PLUGINS } from './parser-options.js';
+/**
+ * Transforms `.server.*` files to inject a stable module-level
+ * `__moduleKey` export and to thread that key into `defineLoader` calls.
+ * The key is path-derived (see `deriveModuleKey`), so it survives builds
+ * and HMR, and is unique per file.
+ *
+ * Pairs with `serverOnlyPlugin`, which transforms client-side imports of
+ * `.server.*` files. Both plugins compute the same key from the same
+ * absolute path + viteRoot.
+ */
+export function moduleKeyPlugin() {
+    let viteRoot;
+    return {
+        name: 'module-key',
+        enforce: 'pre',
+        configResolved(config) {
+            viteRoot = config.root;
+        },
+        // transform receives an `options.ssr` argument from Vite, but we want
+        // __moduleKey injected into both the client and SSR builds (so the SSR
+        // runtime sees the same routing key the handler reads), so we ignore the
+        // flag and always run.
+        transform(code, id) {
+            if (viteRoot === undefined)
+                return;
+            if (!/\.server\.[jt]sx?$/.test(id))
+                return;
+            if (!id.startsWith(viteRoot + '/'))
+                return;
+            if (/^\s*export\s+const\s+__moduleKey\s*=/m.test(code))
+                return;
+            const key = deriveModuleKey(id, viteRoot);
+            const s = new MagicString(code);
+            s.prepend(`export const __moduleKey = ${JSON.stringify(key)};\n`);
+            // Walk the AST for top-level CallExpressions whose callee is the
+            // identifier `defineLoader` and which have exactly one argument.
+            // Rewrite to `defineLoader(<arg>, { __moduleKey: '<key>' })`.
+            let ast;
+            try {
+                ast = parse(code, {
+                    sourceType: 'module',
+                    plugins: BABEL_PARSER_PLUGINS,
+                    errorRecovery: true,
+                });
+            }
+            catch {
+                // If the file fails to parse we still emit the prepended
+                // __moduleKey so the routing layer works even if loader threading
+                // doesn't. Surface the parse error to Vite so the user sees it.
+                return { code: s.toString(), map: s.generateMap({ hires: true }) };
+            }
+            // Rewrite a defineLoader call to include __moduleKey and, when inside
+            // a serverLoaders object, __loaderName. Handles both the single-arg
+            // form (appends a new opts object) and the two-arg form (merges into
+            // the existing opts ObjectExpression).
+            const visitCallWithName = (node, loaderName) => {
+                if (node.callee.type !== 'Identifier' ||
+                    node.callee.name !== 'defineLoader') {
+                    return;
+                }
+                if (node.arguments.length === 0 || node.arguments.length > 2)
+                    return;
+                const fnArg = node.arguments[0];
+                if (fnArg.type === 'StringLiteral')
+                    return; // not a valid defineLoader fn form; skip
+                if (node.arguments.length === 1) {
+                    const insertAt = fnArg.end;
+                    if (insertAt == null)
+                        return;
+                    const namePart = loaderName
+                        ? `, __loaderName: ${JSON.stringify(loaderName)}`
+                        : '';
+                    s.appendRight(insertAt, `, { __moduleKey: ${JSON.stringify(key)}${namePart} }`);
+                    return;
+                }
+                // arguments.length === 2: merge __moduleKey/__loaderName into the
+                // existing opts object literal. Bail if it isn't an ObjectExpression.
+                const optsArg = node.arguments[1];
+                if (optsArg.type !== 'ObjectExpression')
+                    return;
+                const insertAt = optsArg.properties[0]?.start ?? optsArg.start + 1;
+                const namePart = loaderName
+                    ? `__loaderName: ${JSON.stringify(loaderName)}, `
+                    : '';
+                s.appendRight(insertAt, `__moduleKey: ${JSON.stringify(key)}, ${namePart}`);
+            };
+            // Walk serverLoaders entries via the shared parser, then mutate each call.
+            for (const entry of parseServerLoaders(ast.program)) {
+                visitCallWithName(entry.call, entry.name);
+            }
+            // Top-level fallthrough: legacy `export const loader = defineLoader(...)`
+            // (single-loader path). defineLoader is overwhelmingly used at module
+            // scope; we don't recurse into nested function bodies to keep the plugin cheap.
+            for (const stmt of ast.program.body) {
+                if (stmt.type === 'ExportNamedDeclaration' &&
+                    stmt.declaration?.type === 'VariableDeclaration') {
+                    for (const decl of stmt.declaration.declarations) {
+                        if (decl.id.type === 'Identifier' &&
+                            decl.id.name !== 'serverLoaders' &&
+                            decl.init?.type === 'CallExpression') {
+                            visitCallWithName(decl.init, undefined);
+                        }
+                    }
+                }
+            }
+            return { code: s.toString(), map: s.generateMap({ hires: true }) };
+        },
+    };
+}

package/dist/vite/module-key.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Derive the stable module key for a `.server.*` file.
+ *
+ * The key is the file's path relative to the Vite project root, with the
+ * `.server.{ts,tsx,js,jsx}` extension stripped, and path separators
+ * normalized to forward slashes (so the key is identical on Windows and
+ * POSIX). Used as the routing key for `__loaders`/`__actions` RPC, the
+ * payload of `Symbol.for(...)` for `__id`, and the value of the
+ * module-level `__moduleKey` export.
+ */
+export declare function deriveModuleKey(absPath: string, viteRoot: string): string;

package/dist/vite/module-key.js

@@ -0,0 +1,20 @@
+import * as path from 'node:path';
+/**
+ * Derive the stable module key for a `.server.*` file.
+ *
+ * The key is the file's path relative to the Vite project root, with the
+ * `.server.{ts,tsx,js,jsx}` extension stripped, and path separators
+ * normalized to forward slashes (so the key is identical on Windows and
+ * POSIX). Used as the routing key for `__loaders`/`__actions` RPC, the
+ * payload of `Symbol.for(...)` for `__id`, and the value of the
+ * module-level `__moduleKey` export.
+ */
+export function deriveModuleKey(absPath, viteRoot) {
+    // Normalize backslashes to forward slashes before computing the relative
+    // path so that Windows-style inputs work correctly on any platform.
+    const normalizedAbs = absPath.replace(/\\/g, '/');
+    const normalizedRoot = viteRoot.replace(/\\/g, '/');
+    const rel = path.posix.relative(normalizedRoot, normalizedAbs);
+    const stripped = rel.replace(/\.server\.[jt]sx?$/, '');
+    return stripped;
+}

package/dist/vite/parser-options.d.ts

@@ -0,0 +1,16 @@
+import type { ParserOptions } from '@babel/parser';
+/**
+ * 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 declare const BABEL_PARSER_PLUGINS: ParserOptions['plugins'];