@anaemia/bundler 0.0.1

package/dist/rules.js

@@ -0,0 +1,42 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export function createStyleRules(config) {
+    const useSass = config.styles?.sass !== false;
+    const useModules = config.styles?.modules ?? true;
+    const baseLoaders = useSass ? [{ loader: require.resolve("sass-loader"), options: { api: "modern" } }] : [];
+    return {
+        client: {
+            test: /\.(c|sc|sa)ss$/,
+            type: useModules ? "css/auto" : "css",
+            use: baseLoaders,
+        },
+        server: {
+            test: /\.(c|sc|sa)ss$/,
+            type: useModules ? "css/auto" : "css",
+            generator: {
+                css: {
+                    exportOnlyLocals: true,
+                },
+            },
+            use: baseLoaders,
+        },
+    };
+}
+export function createBabelRule({ isServer, isDev, plugins = [], }) {
+    const generateMode = isServer ? "ssr" : "dom";
+    return {
+        test: /\.[jt]sx?$/,
+        use: [
+            {
+                loader: require.resolve("babel-loader"),
+                options: {
+                    presets: [
+                        [require.resolve("babel-preset-solid"), { generate: generateMode, hydratable: true, dev: isDev }],
+                        require.resolve("@babel/preset-typescript"),
+                    ],
+                    plugins: plugins,
+                },
+            },
+        ],
+    };
+}

package/dist/server-function-id.d.ts

@@ -0,0 +1,2 @@
+export declare function createServerFunctionId(filename: string, start: number | null | undefined): string;
+//# sourceMappingURL=server-function-id.d.ts.map

package/dist/server-function-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-function-id.d.ts","sourceRoot":"","sources":["../src/server-function-id.ts"],"names":[],"mappings":"AAAA,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,UAExF"}

package/dist/server-function-id.js

@@ -0,0 +1,3 @@
+export function createServerFunctionId(filename, start) {
+    return Buffer.from(`${filename}:${start ?? 0}`).toString("base64url");
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@anaemia/bundler",
+  "version": "0.0.1",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@babel/types": "^7.29.7",
+    "jiti": "^2.7.0",
+    "@anaemia/core": "0.0.1"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.29.7",
+    "@babel/preset-typescript": "^7.29.7",
+    "@rspack/cli": "^2.0.4",
+    "@rspack/core": "^2.0.4",
+    "@types/babel__core": "^7.20.5",
+    "@types/node": "^25.9.1",
+    "babel-loader": "^10.1.1",
+    "babel-preset-solid": "^1.9.12",
+    "glob": "^13.0.6",
+    "sass": "^1.100.0",
+    "sass-loader": "^17.0.0",
+    "solid-refresh": "^0.7.8"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "pnpm run build && node --test test/*.test.mjs"
+  }
+}

package/src/aliases.ts

@@ -0,0 +1,11 @@
+import path from "path";
+
+export function getAliases(appRoot: string) {
+  return {
+    "~": path.resolve(appRoot, "./src"),
+    "@core": path.resolve(appRoot, "./src/core"),
+    "@shared": path.resolve(appRoot, "./src/shared"),
+    "@features": path.resolve(appRoot, "./src/features"),
+    "@routes": path.resolve(appRoot, "./src/routes"),
+  };
+}

package/src/index.ts

@@ -0,0 +1,170 @@
+import { Configuration, rspack } from "@rspack/core";
+import path from "path";
+import fs from "node:fs";
+import type { AnaemiaConfig } from "@anaemia/core/config";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+import clientServerFnTransform from "./plugins/babel-transform-server.js";
+import serverHashInjector from "./plugins/babel-hash-injector-server.js";
+import { AnaemiaManifestHydrationPlugin } from "./plugins/rspack-manifest-hydration.js";
+
+import { scanRoutes, scanServerRoutes } from "./router/scan.js";
+import { writeManifest } from "./router/manifest.js";
+import { generateRouterEntry } from "./router/generate-entry.js";
+import { generateServerRoutes } from "./router/generate-server-routes.js";
+import { getAliases } from "./aliases.js";
+
+import { createStyleRules, createBabelRule } from "./rules.js";
+import { getClientOptimization, getPerformanceProfile } from "./optimization.js";
+
+const require = createRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function getRspackConfig(appRoot: string, config: AnaemiaConfig = {}): Promise<[Configuration, Configuration]> {
+  const isDev = process.env.NODE_ENV !== "production";
+  const coreRuntimeDir = path.dirname(require.resolve("@anaemia/core/package.json"));
+
+  const routes = await scanRoutes(appRoot);
+  const serverRoutes = scanServerRoutes(appRoot);
+  writeManifest(appRoot, routes);
+
+  const frameworkInternalDir = path.resolve(appRoot, "./.anaemia");
+  if (!fs.existsSync(frameworkInternalDir)) {
+    fs.mkdirSync(frameworkInternalDir, { recursive: true });
+  }
+
+  const entryFile = generateRouterEntry(appRoot, routes);
+  const serverRoutesFile = generateServerRoutes(appRoot, serverRoutes);
+
+  const styleRules = createStyleRules(config);
+  const extraClientBabelPlugins = config.plugins?.flatMap((p) => p.babelPlugins?.client ?? []) ?? [];
+  const extraServerBabelPlugins = config.plugins?.flatMap((p) => p.babelPlugins?.server ?? []) ?? [];
+  const solidRefreshPlugin = [require.resolve("solid-refresh/babel"), { bundler: "rspack-esm", jsx: false }];
+
+  const sharedResolve = {
+    extensions: [".tsx", ".ts", ".jsx", ".js", ".json", ".scss", ".css"],
+    extensionAlias: { ".js": [".ts", ".js"], ".jsx": [".tsx", ".jsx"] },
+    alias: { "anaemia-user-app": entryFile, ...getAliases(appRoot) },
+  };
+
+  let clientConfig: Configuration = {
+    name: "client",
+    context: appRoot,
+    target: "web",
+    devtool: isDev ? "eval-cheap-module-source-map" : false,
+    cache: isDev,
+    entry: {
+      client: [...(isDev ? [require.resolve("solid-refresh")] : []), path.resolve(coreRuntimeDir, "./src/runtime/entry-client.tsx")],
+    },
+    output: {
+      path: path.resolve(appRoot, "./dist/client"),
+      filename: isDev ? "assets/[name].js" : "assets/[name].[contenthash:8].js",
+      chunkFilename: isDev ? "assets/[name].chunk.js" : "assets/[name].[contenthash:8].chunk.js",
+      cssFilename: isDev ? "assets/[name].css" : "assets/[name].[contenthash:8].css",
+      publicPath: "/",
+    },
+    performance: getPerformanceProfile(isDev),
+    optimization: getClientOptimization(isDev),
+    resolve: {
+      ...sharedResolve,
+      conditionNames: ["solid", "browser", ...(isDev ? ["development"] : []), "import", "..."],
+      alias: {
+        ...sharedResolve.alias,
+        "solid-refresh": require.resolve("solid-refresh"),
+        [path.resolve(coreRuntimeDir, "./src/runtime/context.ts")]: path.resolve(coreRuntimeDir, "./src/runtime/context.browser.ts"),
+        [path.resolve(coreRuntimeDir, "./dist/runtime/context.js")]: path.resolve(coreRuntimeDir, "./src/runtime/context.browser.ts"),
+      },
+      fallback: { async_hooks: false, "node:async_hooks": false, fs: false, "node:fs": false, path: false, "node:path": false },
+    },
+    devServer: isDev
+      ? {
+          hot: true,
+          liveReload: false,
+          port: (config.port ?? 3000) + 1,
+          allowedHosts: "all",
+          headers: { "Access-Control-Allow-Origin": "*" },
+          client: { webSocketURL: `ws://localhost:${(config.port ?? 3000) + 2}` },
+        }
+      : undefined,
+    plugins: [
+      new rspack.HtmlRspackPlugin({ template: path.resolve(appRoot, "./index.html"), filename: "index.html", inject: false }),
+      new rspack.DefinePlugin({
+        __ANAEMIA_RUNTIME_CONFIG__: JSON.stringify({ port: config.port, assets: config.assets, styles: config.styles }),
+        ...config.define?.client,
+      }),
+      new rspack.NormalModuleReplacementPlugin(/^node:/, (resource) => { resource.request = resource.request.replace(/^node:/, ""); }),
+      new rspack.NormalModuleReplacementPlugin(
+        /\.server\.(ts|tsx|js|jsx)$/,
+        (() => {
+          const srcPath = path.resolve(__dirname, "./runtime/empty-module.cjs");
+          if (fs.existsSync(srcPath)) return srcPath;
+          
+          return path.resolve(__dirname, "../src/runtime/empty-module.cjs");
+        })()
+      ),
+      new AnaemiaManifestHydrationPlugin({ appRoot }),
+    ],
+    module: {
+      parser: { "css/auto": { namedExports: false } },
+      rules: [
+        styleRules.client,
+        {
+          ...createBabelRule({ isServer: false, isDev, plugins: [clientServerFnTransform, ...(isDev ? [solidRefreshPlugin] : []), ...extraClientBabelPlugins] }),
+          exclude: /[\\/]node_modules[\\/]/,
+        },
+        {
+          ...createBabelRule({ isServer: false, isDev, plugins: [clientServerFnTransform, ...(isDev ? [solidRefreshPlugin] : []), ...extraClientBabelPlugins] }),
+          include: /[\\/]node_modules[\\/]@solidjs[\\/]router/,
+        }
+      ],
+    },
+  };
+
+  let serverConfig: Configuration = {
+    name: "server",
+    context: appRoot,
+    target: "node",
+    entry: { server: path.resolve(coreRuntimeDir, "./src/runtime/entry-server.tsx") },
+    output: { path: path.resolve(appRoot, "./dist/server"), filename: "index.js", module: true, chunkFormat: "module", chunkLoading: "import" },
+    optimization: { nodeEnv: false },
+    resolve: {
+      ...sharedResolve,
+      conditionNames: ["node", "solid", ...(isDev ? ["development"] : []), "import", "..."],
+      alias: {
+        ...sharedResolve.alias,
+        "solid-refresh": require.resolve("solid-refresh"),
+        "@anaemia/core/config": path.resolve(coreRuntimeDir, "./src/config.ts"),
+        "@anaemia/core": path.resolve(coreRuntimeDir, "./src/index.ts"),
+        __anaemia_user_config__: path.resolve(appRoot, "./anaemia.config.ts"),
+        __anaemia_server_routes__: serverRoutesFile,
+      },
+    },
+    plugins: [new rspack.DefinePlugin({ ...config.define?.server })],
+    module: {
+      parser: { "css/auto": { namedExports: false } },
+      rules: [
+        styleRules.server,
+        {
+          ...createBabelRule({ isServer: true, isDev, plugins: [serverHashInjector, ...extraServerBabelPlugins] }),
+          exclude: /[\\/]node_modules[\\/]/,
+        },
+        {
+          ...createBabelRule({ isServer: true, isDev, plugins: [...extraServerBabelPlugins] }),
+          include: /[\\/]node_modules[\\/]@solidjs[\\/]router/,
+        }
+      ],
+    },
+  };
+
+  for (const plugin of config.plugins ?? []) {
+    if (plugin.clientRspackConfig) clientConfig = plugin.clientRspackConfig(clientConfig);
+    if (plugin.serverRspackConfig) serverConfig = plugin.serverRspackConfig(serverConfig);
+  }
+
+  return [clientConfig, serverConfig];
+}
+
+export { scanRoutes } from "./router/scan.js";
+export { writeManifest } from "./router/manifest.js";

package/src/optimization.ts

@@ -0,0 +1,37 @@
+import { rspack } from "@rspack/core";
+
+export function getClientOptimization(isDev: boolean) {
+  return {
+    sideEffects: true,
+    usedExports: true,
+    splitChunks: isDev
+      ? (false as const)
+      : ({
+          chunks: "all" as const,
+          maxInitialRequests: 25,
+          minSize: 20000,
+          cacheGroups: {
+            framework: {
+              chunks: "all" as const,
+              name: "framework",
+              test: /[\\/]node_modules[\\/](solid-js|@solidjs[\\/]router)[\\/]/,
+              priority: 40,
+              enforce: true,
+            },
+            vendor: {
+              chunks: "all" as const,
+              name: "vendor",
+              test: /[\\/]node_modules[\\/]/,
+              priority: 30,
+            },
+          },
+        } as const),
+    minimizer: isDev ? [] : [new rspack.SwcJsMinimizerRspackPlugin()],
+  };
+}
+
+export function getPerformanceProfile(isDev: boolean) {
+  return isDev
+    ? { hints: false as const, maxAssetSize: 1000000, maxEntrypointSize: 1000000 }
+    : { hints: "warning" as const, maxAssetSize: 307200, maxEntrypointSize: 512000 };
+}

package/src/plugins/babel-hash-injector-server.ts

@@ -0,0 +1,19 @@
+import { createServerFunctionId } from "../server-function-id.js";
+
+export default function serverHashInjector({ types: t }: any) {
+  return {
+    name: "anaemia-server-hash-injector",
+    visitor: {
+      CallExpression(path: any, state: any) {
+        if (path.node.callee.name === "runOnServer") {
+          const filename = state.file.opts.filename || "unknown";
+          const functionHash = createServerFunctionId(filename, path.node.start);
+
+          if (path.node.arguments.length === 1) {
+            path.node.arguments.push(t.stringLiteral(functionHash));
+          }
+        }
+      }
+    }
+  };
+}

package/src/plugins/babel-transform-server.ts

@@ -0,0 +1,144 @@
+import { createServerFunctionId } from "../server-function-id.js";
+
+export default function clientServerFnTransform({ types: t }: any) {
+  return {
+    name: "anaemia-client-server-fn-transform",
+    visitor: {
+      Program: {
+        enter(path: any, state: any) {
+          state.hasRunOnServer = false;
+        },
+        exit(path: any, state: any) {
+          if (state.hasRunOnServer) {
+            const importDeclaration = t.importDeclaration(
+              [t.importSpecifier(t.identifier("$$executeClientRpc"), t.identifier("$$executeClientRpc"))],
+              t.stringLiteral("@anaemia/core")
+            );
+            path.node.body.unshift(importDeclaration);
+          }
+        }
+      },
+      CallExpression(path: any, state: any) {
+        if (path.node.callee.name === "runOnServer") {
+          state.hasRunOnServer = true;
+          const filename = state.file.opts.filename || "unknown";
+
+          const serverFunctionCallback = path.node.arguments[0];
+          const explicitId = path.node.arguments[1];
+
+          const functionHash = t.isStringLiteral(explicitId)
+            ? explicitId.value
+            : createServerFunctionId(filename, path.node.start);
+
+          if (serverFunctionCallback) {
+            path.get('arguments.0').remove();
+          }
+
+          // this whole thing is just magic bro
+          path.replaceWith(
+            t.callExpression(
+              t.arrowFunctionExpression(
+                [],
+                t.blockStatement([
+                  t.variableDeclaration("const", [
+                    t.variableDeclarator(
+                      t.identifier("_rpc"),
+                      t.arrowFunctionExpression(
+                        [t.restElement(t.identifier("args"))],
+                        t.callExpression(
+                          t.callExpression(t.identifier("$$executeClientRpc"), [
+                            t.stringLiteral(functionHash)
+                          ]),
+                          [t.spreadElement(t.identifier("args"))]
+                        )
+                      )
+                    )
+                  ]),
+                  // ✅ Inside the blockStatement array, not a 3rd arg to arrowFunctionExpression
+                  t.expressionStatement(
+                    t.assignmentExpression(
+                      "=",
+                      t.memberExpression(t.identifier("_rpc"), t.identifier("id")),
+                      t.stringLiteral(functionHash)
+                    )
+                  ),
+                  t.expressionStatement(
+                    t.assignmentExpression(
+                      "=",
+                      t.memberExpression(t.identifier("_rpc"), t.identifier("readHydrationCache")),
+                      t.arrowFunctionExpression(
+                        [t.identifier("sourceArg")],
+                        t.blockStatement([
+                          t.variableDeclaration("const", [
+                            t.variableDeclarator(
+                              t.identifier("__el"),
+                              t.callExpression(
+                                t.memberExpression(t.identifier("document"), t.identifier("getElementById")),
+                                [t.stringLiteral("__ANAEMIA_DATA__")]
+                              )
+                            )
+                          ]),
+                          t.ifStatement(
+                            t.unaryExpression("!", t.identifier("__el")),
+                            t.returnStatement(t.identifier("undefined"))
+                          ),
+                          t.tryStatement(
+                            t.blockStatement([
+                              t.variableDeclaration("const", [
+                                t.variableDeclarator(
+                                  t.identifier("__data"),
+                                  t.callExpression(
+                                    t.memberExpression(t.identifier("JSON"), t.identifier("parse")),
+                                    [t.memberExpression(t.identifier("__el"), t.identifier("textContent"))]
+                                  )
+                                )
+                              ]),
+                              t.variableDeclaration("const", [
+                                t.variableDeclarator(
+                                  t.identifier("__cache"),
+                                  t.optionalMemberExpression(
+                                    t.memberExpression(
+                                      t.identifier("__data"),
+                                      t.identifier("__SERVER_FUNCTION_DATA__")
+                                    ),
+                                    t.stringLiteral(functionHash),
+                                    true,
+                                    true
+                                  )
+                                )
+                              ]),
+                              t.ifStatement(
+                                t.unaryExpression("!", t.identifier("__cache")),
+                                t.returnStatement(t.identifier("undefined"))
+                              ),
+                              t.returnStatement(
+                                t.memberExpression(
+                                  t.identifier("__cache"),
+                                  t.callExpression(
+                                    t.memberExpression(t.identifier("JSON"), t.identifier("stringify")),
+                                    [t.arrayExpression([t.identifier("sourceArg")])]
+                                  ),
+                                  true
+                                )
+                              )
+                            ]),
+                            t.catchClause(
+                              t.identifier("_"),
+                              t.blockStatement([t.returnStatement(t.identifier("undefined"))])
+                            )
+                          )
+                        ])
+                      )
+                    )
+                  ),
+                  t.returnStatement(t.identifier("_rpc"))
+                ])
+              ),
+              []
+            )
+          );
+        }
+      }
+    },
+  };
+}

package/src/plugins/rspack-manifest-hydration.ts

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { RspackPluginInstance, Compiler } from "@rspack/core";
+
+interface HydrationPluginOptions {
+  appRoot: string;
+}
+
+export class AnaemiaManifestHydrationPlugin implements RspackPluginInstance {
+  private appRoot: string;
+
+  constructor(options: HydrationPluginOptions) {
+    this.appRoot = options.appRoot;
+  }
+
+  apply(compiler: Compiler) {
+    compiler.hooks.emit.tap("AnaemiaManifestHydrationPlugin", (compilation) => {
+      const manifestPath = path.resolve(this.appRoot, "./dist/route-manifest.json");
+
+      if (!fs.existsSync(manifestPath)) return;
+
+      try {
+        const currentManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+
+        if (!currentManifest.chunks) {
+          currentManifest.chunks = {};
+        }
+
+        for (const chunk of compilation.chunks) {
+          if (!chunk.name) continue;
+
+          const files = Array.from(chunk.files);
+
+          const jsFiles = files.filter(
+            (f) => f.endsWith(".js") && !f.includes(".hot-update.") && !f.endsWith(".js.map")
+          );
+
+          const cssFiles = files.filter(
+            (f) => f.endsWith(".css") && !f.includes(".hot-update.") && !f.endsWith(".css.map")
+          );
+
+          if (jsFiles.length > 0 || cssFiles.length > 0) {
+            currentManifest.chunks[chunk.name] = {
+              js: jsFiles.map((f) => `/${f}`),
+              css: cssFiles.map((f) => `/${f}`),
+            };
+          }
+        }
+
+        fs.writeFileSync(manifestPath, JSON.stringify(currentManifest, null, 2));
+      } catch (e: any) {
+        console.error("[anaemia compiler] failed updating route-manifest with assets:", e.message);
+      }
+    });
+  }
+}