@bionicjs/core 0.1.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 bionicjs contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# bionicjs
+
+The core package of the BionicJS meta-framework: a fullstack framework where
+TypeScript owns the web (Vite + React + filesystem routing) and Python owns the
+intelligence (AI and background jobs).
+
+## Exports
+
+- `defineConfig` — typed entry for `bionicjs.config.ts`
+- `createAuthPlugin`, `createDatabasePlugin`, `createAiPlugin`,
+  `createJobsPlugin` — factories the `@bionicjs/*` packages build on
+- `api` — client-side RPC helper
+- `BionicJSRouter` — mounts the app's filesystem routes
+- `@bionicjs/core/server` — generated server exports (`auth`, `db`, `ai`, `jobs`)
+- `@bionicjs/core/router` — route parser, generator, and layout adapter
+- `runDevServer` — starts Vite + Nitro programmatically
+
+## Config
+
+```ts
+// bionicjs.config.ts
+import { defineConfig } from "@bionicjs/core";
+import { betterAuth } from "@bionicjs/better-auth";
+import { drizzle } from "@bionicjs/drizzle";
+
+export default defineConfig({
+  auth: betterAuth({ emailAndPassword: { enabled: true } }),
+  database: drizzle({ provider: "sqlite", url: "file:./db.sqlite" }),
+});
+```
+
+## Runtime
+
+```ts
+// client
+import { api } from "@bionicjs/core";
+const result = await api.users.sayHello({ name: "bionicjs" });
+
+// server
+import { auth, db, ai, jobs } from "@bionicjs/core/server";
+```
+
+## Development
+
+The package has no standalone test suite; its behavior is exercised through the
+end-to-end scaffolding tests in <code>create-bionicjs-app</code>.

package/bin/bionicjs.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import { createJiti } from "jiti";
+import { fileURLToPath } from "node:url";
+
+const jiti = createJiti(fileURLToPath(import.meta.url));
+
+const command = process.argv[2];
+
+if (command === "dev" || !command) {
+  const { runDevServer } = await jiti.import("@bionicjs/dev");
+  runDevServer().catch((err) => {
+    console.error("Error starting BionicJS dev server:", err);
+    process.exit(1);
+  });
+} else {
+  console.log(`Unknown command: ${command}`);
+  console.log("Usage: bionicjs dev");
+  process.exit(1);
+}

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+import React from 'react';
+export { runDevServer } from '@bionicjs/dev';
+
+declare function BionicJSRouter(): React.JSX.Element;
+
+declare const api: any;
+
+interface BionicJSPlugin<TName extends string = string, TExports = any> {
+    name: TName;
+    setup: (app: any) => void | Promise<void>;
+    generateExports?: () => string | Promise<string>;
+}
+type BionicJSConfig = {
+    [key: string]: BionicJSPlugin | any;
+};
+declare function defineConfig(config: BionicJSConfig): BionicJSConfig;
+
+/**
+ * bionicjs plugin factory utilities
+ *
+ * Inspired by Farm.js integrations — each provider package stays thin.
+ * Shared logic lives here so every integration has a consistent shape.
+ *
+ * Separation:
+ *   Config  = "what" and "which" (provider, model, path, feature flags)
+ *   Code    = "how"  (real handler, query builder, agent logic — lives in server/)
+ */
+
+interface BionicJSContext {
+    cwd: string;
+    mode: "development" | "production";
+}
+interface AuthPluginOptions<TOptions = unknown> {
+    /** e.g. "better-auth", "clerk" */
+    name: string;
+    options: TOptions;
+    /** Mount auth HTTP handler at this path pattern */
+    path?: string;
+    /** Called once at server startup */
+    setup?: (ctx: BionicJSContext, options: TOptions) => void | Promise<void>;
+    /** Returns runtime export code injected into .bionicjs/server.ts */
+    generateExports?: (options: TOptions) => string;
+}
+declare function createAuthPlugin<TOptions>(def: AuthPluginOptions<TOptions>): BionicJSPlugin;
+interface DatabasePluginOptions<TOptions = unknown> {
+    name: string;
+    options: TOptions;
+    setup?: (ctx: BionicJSContext, options: TOptions) => void | Promise<void>;
+    generateExports?: (options: TOptions) => string;
+}
+declare function createDatabasePlugin<TOptions>(def: DatabasePluginOptions<TOptions>): BionicJSPlugin;
+interface AiPluginOptions<TOptions = unknown> {
+    name: string;
+    options: TOptions;
+    setup?: (ctx: BionicJSContext, options: TOptions) => void | Promise<void>;
+    generateExports?: (options: TOptions) => string;
+}
+declare function createAiPlugin<TOptions>(def: AiPluginOptions<TOptions>): BionicJSPlugin;
+interface JobsPluginOptions<TOptions = unknown> {
+    name: string;
+    options: TOptions;
+    setup?: (ctx: BionicJSContext, options: TOptions) => void | Promise<void>;
+    generateExports?: (options: TOptions) => string;
+}
+declare function createJobsPlugin<TOptions>(def: JobsPluginOptions<TOptions>): BionicJSPlugin;
+
+export { type AiPluginOptions, type AuthPluginOptions, type BionicJSConfig, type BionicJSContext, type BionicJSPlugin, BionicJSRouter, type DatabasePluginOptions, type JobsPluginOptions, api, createAiPlugin, createAuthPlugin, createDatabasePlugin, createJobsPlugin, defineConfig };

package/dist/index.js

@@ -0,0 +1,88 @@
+// src/router.tsx
+import { lazy, Suspense } from "react";
+import { createBrowserRouter, RouterProvider } from "react-router";
+import { jsx } from "react/jsx-runtime";
+var LazyRoutes = lazy(
+  () => (
+    // @ts-expect-error Virtual module provided by bionicjsRoutesPlugin
+    import("virtual:bionicjs-routes").then((mod) => ({
+      default: function BionicJSRoutes() {
+        const router = createBrowserRouter(mod.routes);
+        return /* @__PURE__ */ jsx(RouterProvider, { router });
+      }
+    }))
+  )
+);
+function BionicJSRouter() {
+  return /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(LazyRoutes, {}) });
+}
+
+// src/api-client.ts
+var api = new Proxy({}, {
+  get(_, path) {
+    return new Proxy({}, {
+      get(_2, method) {
+        return async (...args) => {
+          const res = await fetch(`/api/${String(path)}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(args[0])
+          });
+          return res.json();
+        };
+      }
+    });
+  }
+});
+
+// src/index.ts
+import { runDevServer } from "@bionicjs/dev";
+
+// src/config.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/plugin-utils.ts
+function createAuthPlugin(def) {
+  return {
+    name: "auth",
+    setup: def.setup ? (app) => def.setup(app, def.options) : () => {
+    },
+    generateExports: def.generateExports ? () => def.generateExports(def.options) : void 0
+  };
+}
+function createDatabasePlugin(def) {
+  return {
+    name: "db",
+    setup: def.setup ? (app) => def.setup(app, def.options) : () => {
+    },
+    generateExports: def.generateExports ? () => def.generateExports(def.options) : void 0
+  };
+}
+function createAiPlugin(def) {
+  return {
+    name: "ai",
+    setup: def.setup ? (app) => def.setup(app, def.options) : () => {
+    },
+    generateExports: def.generateExports ? () => def.generateExports(def.options) : void 0
+  };
+}
+function createJobsPlugin(def) {
+  return {
+    name: "jobs",
+    setup: def.setup ? (app) => def.setup(app, def.options) : () => {
+    },
+    generateExports: def.generateExports ? () => def.generateExports(def.options) : void 0
+  };
+}
+export {
+  BionicJSRouter,
+  api,
+  createAiPlugin,
+  createAuthPlugin,
+  createDatabasePlugin,
+  createJobsPlugin,
+  defineConfig,
+  runDevServer
+};

package/dist/router/index.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+
+interface RouteManifestNode {
+    segment: string;
+    path?: string;
+    page?: string;
+    layout?: string;
+    children: RouteManifestNode[];
+}
+
+declare function parseRoutes(files: string[]): RouteManifestNode;
+
+declare function generateRouteModule(manifest: RouteManifestNode): string;
+
+interface BionicJSLayoutAdapterProps {
+    Layout: React.ComponentType<{
+        children?: React.ReactNode;
+    }>;
+}
+declare function BionicJSLayoutAdapter({ Layout }: BionicJSLayoutAdapterProps): React.JSX.Element;
+
+export { BionicJSLayoutAdapter, type RouteManifestNode, generateRouteModule, parseRoutes };

package/dist/router/index.js

@@ -0,0 +1,187 @@
+// src/router/conventions.ts
+var PAGE_FILE = "page.tsx";
+var LAYOUT_FILE = "layout.tsx";
+function isPageFile(filename) {
+  return filename === PAGE_FILE || filename.endsWith(`/${PAGE_FILE}`);
+}
+function isLayoutFile(filename) {
+  return filename === LAYOUT_FILE || filename.endsWith(`/${LAYOUT_FILE}`);
+}
+function isDynamicSegment(segment) {
+  return segment.startsWith("[") && segment.endsWith("]") && !segment.startsWith("[...");
+}
+function isCatchAllSegment(segment) {
+  return segment.startsWith("[...") && segment.endsWith("]");
+}
+function formatSegmentToRoutePath(segment) {
+  if (isCatchAllSegment(segment)) {
+    return "*";
+  }
+  if (isDynamicSegment(segment)) {
+    return `:${segment.slice(1, -1)}`;
+  }
+  return segment;
+}
+
+// src/router/parser.ts
+function parseRoutes(files) {
+  const root = {
+    segment: "",
+    children: []
+  };
+  const getOrCreateNode = (segments) => {
+    let current = root;
+    for (const segment of segments) {
+      const formattedPath = formatSegmentToRoutePath(segment);
+      const existingConflict = current.children.find((c) => {
+        if (c.segment === segment) return false;
+        if (isDynamicSegment(segment) && isDynamicSegment(c.segment)) return true;
+        if (isCatchAllSegment(segment) && isCatchAllSegment(c.segment)) return true;
+        return c.path === formattedPath;
+      });
+      if (existingConflict) {
+        throw new Error(
+          `BionicJS Route Conflict: Conflicting segments "${segment}" and "${existingConflict.segment}" at the same directory level.`
+        );
+      }
+      let child = current.children.find((c) => c.segment === segment);
+      if (!child) {
+        child = {
+          segment,
+          path: formattedPath,
+          children: []
+        };
+        current.children.push(child);
+      }
+      current = child;
+    }
+    return current;
+  };
+  for (const rawFile of files) {
+    let normalized = rawFile.replace(/\\/g, "/");
+    normalized = normalized.replace(/^(\.\/|\/)?(app\/|\/)?/, "");
+    const parts = normalized.split("/").filter(Boolean);
+    if (parts.length === 0) continue;
+    const filename = parts[parts.length - 1];
+    if (!isPageFile(filename) && !isLayoutFile(filename)) {
+      continue;
+    }
+    const dirSegments = parts.slice(0, parts.length - 1);
+    const targetNode = dirSegments.length === 0 ? root : getOrCreateNode(dirSegments);
+    const fullVitePath = rawFile.startsWith("/") ? rawFile : `/${rawFile}`;
+    if (isPageFile(filename)) {
+      targetNode.page = fullVitePath;
+    } else if (isLayoutFile(filename)) {
+      targetNode.layout = fullVitePath;
+    }
+  }
+  return root;
+}
+
+// src/router/generator.ts
+function generateNodeCode(node, isRoot) {
+  const parts = [];
+  if (node.layout) {
+    const layoutLazy = `lazy: async () => {
+      const mod = await import("${node.layout}");
+      return {
+        Component: () => React.createElement(BionicJSLayoutAdapter, { Layout: mod.default })
+      };
+    }`;
+    const childrenCode = [];
+    if (node.page) {
+      childrenCode.push(`{
+        index: true,
+        lazy: async () => {
+          const mod = await import("${node.page}");
+          return { Component: mod.default };
+        }
+      }`);
+    }
+    for (const child of node.children) {
+      childrenCode.push(generateNodeCode(child, false));
+    }
+    if (isRoot) {
+      return `{
+        ${layoutLazy},
+        children: [
+          ${childrenCode.join(",\n")}
+        ]
+      }`;
+    } else {
+      return `{
+        ${node.path ? `path: "${node.path}",` : ""}
+        ${layoutLazy},
+        children: [
+          ${childrenCode.join(",\n")}
+        ]
+      }`;
+    }
+  }
+  if (isRoot) {
+    const rootChildren = [];
+    if (node.page) {
+      rootChildren.push(`{
+        index: true,
+        lazy: async () => {
+          const mod = await import("${node.page}");
+          return { Component: mod.default };
+        }
+      }`);
+    }
+    for (const child of node.children) {
+      rootChildren.push(generateNodeCode(child, false));
+    }
+    return rootChildren.join(",\n");
+  }
+  const childCodes = node.children.map((c) => generateNodeCode(c, false));
+  if (node.page) {
+    const pageLazy = `lazy: async () => {
+      const mod = await import("${node.page}");
+      return { Component: mod.default };
+    }`;
+    if (childCodes.length > 0) {
+      return `{
+        path: "${node.path}",
+        ${pageLazy},
+        children: [
+          ${childCodes.join(",\n")}
+        ]
+      }`;
+    } else {
+      return `{
+        path: "${node.path}",
+        ${pageLazy}
+      }`;
+    }
+  } else {
+    return `{
+      path: "${node.path}",
+      children: [
+        ${childCodes.join(",\n")}
+      ]
+    }`;
+  }
+}
+function generateRouteModule(manifest) {
+  const routesCode = generateNodeCode(manifest, true);
+  return `import React from "react";
+import { BionicJSLayoutAdapter } from "@bionicjs/core/router";
+
+export const routes = [
+  ${routesCode}
+];
+`;
+}
+
+// src/router/adapter.tsx
+import { Outlet } from "react-router";
+import { jsx } from "react/jsx-runtime";
+function BionicJSLayoutAdapter({ Layout }) {
+  return /* @__PURE__ */ jsx(Layout, { children: /* @__PURE__ */ jsx(Outlet, {}) });
+}
+export {
+  BionicJSLayoutAdapter,
+  generateRouteModule,
+  parseRoutes
+};

package/dist/server.d.ts

@@ -0,0 +1,6 @@
+declare const auth: undefined;
+declare const db: undefined;
+declare const ai: undefined;
+declare const jobs: undefined;
+
+export { ai, auth, db, jobs };

package/dist/server.js

@@ -0,0 +1,11 @@
+// src/server.ts
+var auth = void 0;
+var db = void 0;
+var ai = void 0;
+var jobs = void 0;
+export {
+  ai,
+  auth,
+  db,
+  jobs
+};

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@bionicjs/core",
+  "version": "0.1.0",
+  "description": "The full-stack React framework for the AI era: React UI and Python intelligence in one codebase",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js",
+      "default": "./dist/server.js"
+    },
+    "./router": {
+      "types": "./dist/router/index.d.ts",
+      "import": "./dist/router/index.js",
+      "default": "./dist/router/index.js"
+    },
+    "./entry-client": "./src/entry-client.tsx",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "bin",
+    "README.md",
+    "!src/**/*.test.ts"
+  ],
+  "imports": {
+    "#bionicjs-api": "./src/api-client.ts"
+  },
+  "bin": {
+    "bionicjs": "./bin/bionicjs.js"
+  },
+  "dependencies": {
+    "@bionicjs/dev": "0.1.0",
+    "jiti": "^2.7.0",
+    "react-router": "^7"
+  },
+  "peerDependencies": {
+    "react": "^19",
+    "react-dom": "^19"
+  },
+  "devDependencies": {
+    "vite": "^8.3.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "tsx": "^4.23.15",
+    "@types/node": "^22",
+    "react": "^19",
+    "react-dom": "^19",
+    "@types/react": "^19",
+    "@types/react-dom": "^19"
+  },
+  "license": "MIT",
+  "keywords": [
+    "bionicjs",
+    "framework",
+    "react",
+    "python",
+    "vite",
+    "nitro"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bionicjs/bionicjs.git",
+    "directory": "packages/bionicjs"
+  },
+  "bugs": {
+    "url": "https://github.com/bionicjs/bionicjs/issues"
+  },
+  "homepage": "https://github.com/bionicjs/bionicjs#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup src/router/index.ts --format esm --dts --out-dir dist/router && tsup src/index.ts src/server.ts --format esm --target node20 --dts --external virtual:bionicjs-routes",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx src/router/router.test.ts && tsx src/router/integration.test.ts && tsx src/router/vite-e2e.test.ts"
+  }
+}

package/src/api-client.ts

@@ -0,0 +1,19 @@
+// AUTO-GENERATED by BionicJS — do not edit
+// This is a stub. The real client is generated into .bionicjs/api-client.ts at dev/build time.
+// The Vite plugin resolves "#bionicjs-api" to .bionicjs/api-client.ts.
+export const api = new Proxy({} as any, {
+  get(_, path) {
+    return new Proxy({} as any, {
+      get(_, method) {
+        return async (...args: any[]) => {
+          const res = await fetch(`/api/${String(path)}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(args[0]),
+          });
+          return res.json();
+        };
+      },
+    });
+  },
+});

package/src/config.ts

@@ -0,0 +1,13 @@
+export interface BionicJSPlugin<TName extends string = string, TExports = any> {
+  name: TName;
+  setup: (app: any) => void | Promise<void>;
+  generateExports?: () => string | Promise<string>;
+}
+
+export type BionicJSConfig = {
+  [key: string]: BionicJSPlugin | any;
+};
+
+export function defineConfig(config: BionicJSConfig): BionicJSConfig {
+  return config;
+}

package/src/entry-client.tsx

@@ -0,0 +1,10 @@
+import React, { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { BionicJSRouter } from "./router";
+import "/app/globals.css"; // Ensure user's globals.css is imported
+
+createRoot(document.getElementById("root")!).render(
+  <StrictMode>
+    <BionicJSRouter />
+  </StrictMode>
+);

package/src/index.ts

@@ -0,0 +1,16 @@
+export { BionicJSRouter } from "./router";
+export { api } from "./api-client";
+export { runDevServer } from "@bionicjs/dev";
+
+export { defineConfig, type BionicJSConfig, type BionicJSPlugin } from "./config";
+export {
+  createAuthPlugin,
+  createDatabasePlugin,
+  createAiPlugin,
+  createJobsPlugin,
+  type BionicJSContext,
+  type AuthPluginOptions,
+  type DatabasePluginOptions,
+  type AiPluginOptions,
+  type JobsPluginOptions,
+} from "./plugin-utils";

package/src/plugin-utils.ts

@@ -0,0 +1,116 @@
+/**
+ * bionicjs plugin factory utilities
+ *
+ * Inspired by Farm.js integrations — each provider package stays thin.
+ * Shared logic lives here so every integration has a consistent shape.
+ *
+ * Separation:
+ *   Config  = "what" and "which" (provider, model, path, feature flags)
+ *   Code    = "how"  (real handler, query builder, agent logic — lives in server/)
+ */
+
+import type { BionicJSPlugin } from "./config.ts";
+
+// ─── Shared app context ───────────────────────────────────────────────────────
+
+export interface BionicJSContext {
+  cwd: string;
+  mode: "development" | "production";
+}
+
+// ─── Auth ─────────────────────────────────────────────────────────────────────
+
+export interface AuthPluginOptions<TOptions = unknown> {
+  /** e.g. "better-auth", "clerk" */
+  name: string;
+  options: TOptions;
+  /** Mount auth HTTP handler at this path pattern */
+  path?: string;
+  /** Called once at server startup */
+  setup?: (ctx: BionicJSContext, options: TOptions) => void | Promise<void>;
+  /** Returns runtime export code injected into .bionicjs/server.ts */
+  generateExports?: (options: TOptions) => string;
+}
+
+export function createAuthPlugin<TOptions>(
+  def: AuthPluginOptions<TOptions>,
+): BionicJSPlugin {
+  return {
+    name: "auth",
+    setup: def.setup
+      ? (app: any) => def.setup!(app as BionicJSContext, def.options)
+      : () => {},
+    generateExports: def.generateExports
+      ? () => def.generateExports!(def.options)
+      : undefined,
+  };
+}
+
+// ─── Database ─────────────────────────────────────────────────────────────────
+
+export interface DatabasePluginOptions<TOptions = unknown> {
+  name: string;
+  options: TOptions;
+  setup?: (ctx: BionicJSContext, options: TOptions) => void | Promise<void>;
+  generateExports?: (options: TOptions) => string;
+}
+
+export function createDatabasePlugin<TOptions>(
+  def: DatabasePluginOptions<TOptions>,
+): BionicJSPlugin {
+  return {
+    name: "db",
+    setup: def.setup
+      ? (app: any) => def.setup!(app as BionicJSContext, def.options)
+      : () => {},
+    generateExports: def.generateExports
+      ? () => def.generateExports!(def.options)
+      : undefined,
+  };
+}
+
+// ─── AI ───────────────────────────────────────────────────────────────────────
+
+export interface AiPluginOptions<TOptions = unknown> {
+  name: string;
+  options: TOptions;
+  setup?: (ctx: BionicJSContext, options: TOptions) => void | Promise<void>;
+  generateExports?: (options: TOptions) => string;
+}
+
+export function createAiPlugin<TOptions>(
+  def: AiPluginOptions<TOptions>,
+): BionicJSPlugin {
+  return {
+    name: "ai",
+    setup: def.setup
+      ? (app: any) => def.setup!(app as BionicJSContext, def.options)
+      : () => {},
+    generateExports: def.generateExports
+      ? () => def.generateExports!(def.options)
+      : undefined,
+  };
+}
+
+// ─── Jobs ─────────────────────────────────────────────────────────────────────
+
+export interface JobsPluginOptions<TOptions = unknown> {
+  name: string;
+  options: TOptions;
+  setup?: (ctx: BionicJSContext, options: TOptions) => void | Promise<void>;
+  generateExports?: (options: TOptions) => string;
+}
+
+export function createJobsPlugin<TOptions>(
+  def: JobsPluginOptions<TOptions>,
+): BionicJSPlugin {
+  return {
+    name: "jobs",
+    setup: def.setup
+      ? (app: any) => def.setup!(app as BionicJSContext, def.options)
+      : () => {},
+    generateExports: def.generateExports
+      ? () => def.generateExports!(def.options)
+      : undefined,
+  };
+}

package/src/router/adapter.tsx

@@ -0,0 +1,14 @@
+import React from "react";
+import { Outlet } from "react-router";
+
+export interface BionicJSLayoutAdapterProps {
+  Layout: React.ComponentType<{ children?: React.ReactNode }>;
+}
+
+export function BionicJSLayoutAdapter({ Layout }: BionicJSLayoutAdapterProps) {
+  return (
+    <Layout>
+      <Outlet />
+    </Layout>
+  );
+}

package/src/router/conventions.ts

@@ -0,0 +1,28 @@
+export const PAGE_FILE = "page.tsx";
+export const LAYOUT_FILE = "layout.tsx";
+
+export function isPageFile(filename: string): boolean {
+  return filename === PAGE_FILE || filename.endsWith(`/${PAGE_FILE}`);
+}
+
+export function isLayoutFile(filename: string): boolean {
+  return filename === LAYOUT_FILE || filename.endsWith(`/${LAYOUT_FILE}`);
+}
+
+export function isDynamicSegment(segment: string): boolean {
+  return segment.startsWith("[") && segment.endsWith("]") && !segment.startsWith("[...");
+}
+
+export function isCatchAllSegment(segment: string): boolean {
+  return segment.startsWith("[...") && segment.endsWith("]");
+}
+
+export function formatSegmentToRoutePath(segment: string): string {
+  if (isCatchAllSegment(segment)) {
+    return "*";
+  }
+  if (isDynamicSegment(segment)) {
+    return `:${segment.slice(1, -1)}`;
+  }
+  return segment;
+}

package/src/router/generator.ts

@@ -0,0 +1,113 @@
+import { RouteManifestNode } from "./types";
+
+function generateNodeCode(node: RouteManifestNode, isRoot: boolean): string {
+  const parts: string[] = [];
+
+  // Handle Layout wrapper if node has a layout file
+  if (node.layout) {
+    const layoutLazy = `lazy: async () => {
+      const mod = await import("${node.layout}");
+      return {
+        Component: () => React.createElement(BionicJSLayoutAdapter, { Layout: mod.default })
+      };
+    }`;
+
+    const childrenCode: string[] = [];
+
+    // Add page as index route under layout if page exists
+    if (node.page) {
+      childrenCode.push(`{
+        index: true,
+        lazy: async () => {
+          const mod = await import("${node.page}");
+          return { Component: mod.default };
+        }
+      }`);
+    }
+
+    // Process child subdirectories
+    for (const child of node.children) {
+      childrenCode.push(generateNodeCode(child, false));
+    }
+
+    if (isRoot) {
+      return `{
+        ${layoutLazy},
+        children: [
+          ${childrenCode.join(",\n")}
+        ]
+      }`;
+    } else {
+      return `{
+        ${node.path ? `path: "${node.path}",` : ""}
+        ${layoutLazy},
+        children: [
+          ${childrenCode.join(",\n")}
+        ]
+      }`;
+    }
+  }
+
+  // Node does NOT have a layout file
+  if (isRoot) {
+    const rootChildren: string[] = [];
+    if (node.page) {
+      rootChildren.push(`{
+        index: true,
+        lazy: async () => {
+          const mod = await import("${node.page}");
+          return { Component: mod.default };
+        }
+      }`);
+    }
+    for (const child of node.children) {
+      rootChildren.push(generateNodeCode(child, false));
+    }
+    return rootChildren.join(",\n");
+  }
+
+  // Non-root node without layout
+  const childCodes = node.children.map((c) => generateNodeCode(c, false));
+
+  if (node.page) {
+    const pageLazy = `lazy: async () => {
+      const mod = await import("${node.page}");
+      return { Component: mod.default };
+    }`;
+
+    if (childCodes.length > 0) {
+      return `{
+        path: "${node.path}",
+        ${pageLazy},
+        children: [
+          ${childCodes.join(",\n")}
+        ]
+      }`;
+    } else {
+      return `{
+        path: "${node.path}",
+        ${pageLazy}
+      }`;
+    }
+  } else {
+    // Transparent directory segment without layout or page
+    return `{
+      path: "${node.path}",
+      children: [
+        ${childCodes.join(",\n")}
+      ]
+    }`;
+  }
+}
+
+export function generateRouteModule(manifest: RouteManifestNode): string {
+  const routesCode = generateNodeCode(manifest, true);
+
+  return `import React from "react";
+import { BionicJSLayoutAdapter } from "@bionicjs/core/router";
+
+export const routes = [
+  ${routesCode}
+];
+`;
+}

package/src/router/index.ts

@@ -0,0 +1,4 @@
+export { parseRoutes } from "./parser";
+export { generateRouteModule } from "./generator";
+export { BionicJSLayoutAdapter } from "./adapter";
+export type { RouteManifestNode } from "./types";

package/src/router/parser.ts

@@ -0,0 +1,80 @@
+import { RouteManifestNode } from "./types";
+import {
+  formatSegmentToRoutePath,
+  isPageFile,
+  isLayoutFile,
+  isDynamicSegment,
+  isCatchAllSegment,
+} from "./conventions";
+
+export function parseRoutes(files: string[]): RouteManifestNode {
+  const root: RouteManifestNode = {
+    segment: "",
+    children: [],
+  };
+
+  const getOrCreateNode = (segments: string[]): RouteManifestNode => {
+    let current = root;
+    for (const segment of segments) {
+      const formattedPath = formatSegmentToRoutePath(segment);
+
+      // Check for route conflicts:
+      // 1. Multiple dynamic parameter segments at the same level (e.g. [id] vs [userId])
+      // 2. Multiple catch-all segments at the same level
+      const existingConflict = current.children.find((c) => {
+        if (c.segment === segment) return false;
+        if (isDynamicSegment(segment) && isDynamicSegment(c.segment)) return true;
+        if (isCatchAllSegment(segment) && isCatchAllSegment(c.segment)) return true;
+        return c.path === formattedPath;
+      });
+
+      if (existingConflict) {
+        throw new Error(
+          `BionicJS Route Conflict: Conflicting segments "${segment}" and "${existingConflict.segment}" at the same directory level.`
+        );
+      }
+
+      let child = current.children.find((c) => c.segment === segment);
+      if (!child) {
+        child = {
+          segment,
+          path: formattedPath,
+          children: [],
+        };
+        current.children.push(child);
+      }
+      current = child;
+    }
+    return current;
+  };
+
+  for (const rawFile of files) {
+    // Normalize path to remove leading dot/slash and /app prefix
+    let normalized = rawFile.replace(/\\/g, "/");
+    normalized = normalized.replace(/^(\.\/|\/)?(app\/|\/)?/, "");
+
+    const parts = normalized.split("/").filter(Boolean);
+    if (parts.length === 0) continue;
+
+    const filename = parts[parts.length - 1];
+
+    // Only process page.tsx and layout.tsx files
+    if (!isPageFile(filename) && !isLayoutFile(filename)) {
+      continue;
+    }
+
+    const dirSegments = parts.slice(0, parts.length - 1);
+    const targetNode = dirSegments.length === 0 ? root : getOrCreateNode(dirSegments);
+
+    // Ensure page/layout paths retain standard Vite root format (e.g. /app/...)
+    const fullVitePath = rawFile.startsWith("/") ? rawFile : `/${rawFile}`;
+
+    if (isPageFile(filename)) {
+      targetNode.page = fullVitePath;
+    } else if (isLayoutFile(filename)) {
+      targetNode.layout = fullVitePath;
+    }
+  }
+
+  return root;
+}

package/src/router/types.ts

@@ -0,0 +1,11 @@
+export interface RouteManifestNode {
+  segment: string;
+  path?: string;
+  page?: string;
+  layout?: string;
+  children: RouteManifestNode[];
+}
+
+export interface ParseOptions {
+  appDir?: string;
+}

package/src/router.tsx

@@ -0,0 +1,23 @@
+import React, { lazy, Suspense } from "react";
+import { createBrowserRouter, RouterProvider } from "react-router";
+
+// virtual:bionicjs-routes is provided by the bionicjs-routes Vite plugin. It is loaded
+// lazily so that importing @bionicjs/core never touches the virtual module outside
+// a browser (Node-side config loading, plugin packages, etc. stay crash-free).
+const LazyRoutes = lazy(() =>
+  // @ts-expect-error Virtual module provided by bionicjsRoutesPlugin
+  import("virtual:bionicjs-routes").then((mod) => ({
+    default: function BionicJSRoutes() {
+      const router = createBrowserRouter(mod.routes);
+      return <RouterProvider router={router} />;
+    },
+  })),
+);
+
+export function BionicJSRouter() {
+  return (
+    <Suspense fallback={null}>
+      <LazyRoutes />
+    </Suspense>
+  );
+}

package/src/server.ts

@@ -0,0 +1,7 @@
+// AUTO-GENERATED by BionicJS — do not edit
+// This file re-exports server-only helpers wired through the plugin system.
+// Import these from "@bionicjs/core/server" in your server-side code.
+export const auth = undefined;
+export const db = undefined;
+export const ai = undefined;
+export const jobs = undefined;