mm: added diff event + plugin to write down diffs

fix schema modals
2026-08-02 08:06:00 +00:00 · 2025-07-08 09:54:56 +02:00 · 2025-07-07 16:45:38 +02:00 · 2025-07-07 16:38:39 +02:00 · 2025-07-07 16:09:29 +02:00 · 2025-07-07 08:41:06 +02:00
514 changed files with 10459 additions and 23123 deletions
@@ -1,10 +0,0 @@
-{
-  "mcpServers": {
-    "bknd": {
-      "url": "http://localhost:3000/mcp",
-      "headers": {
-        "API_KEY": "value"
-      }
-    }
-  }
-}
@@ -20,7 +20,7 @@ jobs:
      - name: Setup Bun
        uses: oven-sh/setup-bun@v1
        with:
-          bun-version: "1.2.19"
+          bun-version: "1.2.14"

      - name: Install dependencies
        working-directory: ./app
@@ -31,6 +31,4 @@ packages/media/.env
 .git_old
 docker/tmp
 .debug
-.history
-.aider*
-.vercel
+.history
@@ -1,6 +1,6 @@
 [![npm version](https://img.shields.io/npm/v/bknd.svg)](https://npmjs.org/package/bknd)

-![bknd](https://raw.githubusercontent.com/bknd-io/bknd/refs/heads/main/docs/public/assets/poster.png)
+![bknd](https://raw.githubusercontent.com/bknd-io/bknd/refs/heads/main/docs/_assets/poster.png)

 <p align="center" width="100%">
 <a href="https://stackblitz.com/github/bknd-io/bknd-examples?hideExplorer=1&embed=1&view=preview&startScript=example-admin-rich&initialPath=%2Fdata%2Fschema" target="_blank">
@@ -1,2 +1 @@
-tmp/*
-!tmp/.gitkeep
+tmp/*
@@ -9,16 +9,16 @@ beforeAll(disableConsoleLog);
 afterAll(enableConsoleLog);

 describe("adapter", () => {
-   it("makes config", async () => {
-      expect(omitKeys(await adapter.makeConfig({}), ["connection"])).toEqual({});
-      expect(
-         omitKeys(await adapter.makeConfig({}, { env: { TEST: "test" } }), ["connection"]),
-      ).toEqual({});
+   it("makes config", () => {
+      expect(omitKeys(adapter.makeConfig({}), ["connection"])).toEqual({});
+      expect(omitKeys(adapter.makeConfig({}, { env: { TEST: "test" } }), ["connection"])).toEqual(
+         {},
+      );

      // merges everything returned from `app` with the config
      expect(
         omitKeys(
-            await adapter.makeConfig(
+            adapter.makeConfig(
               { app: (a) => ({ initialConfig: { server: { cors: { origin: a.env.TEST } } } }) },
               { env: { TEST: "test" } },
            ),
@@ -1,12 +1,12 @@
 import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import { Guard } from "../../src/auth/authorize/Guard";
+import { Guard } from "../../src/auth";
 import { DataApi } from "../../src/data/api/DataApi";
 import { DataController } from "../../src/data/api/DataController";
 import { dataConfigSchema } from "../../src/data/data-schema";
 import * as proto from "../../src/data/prototype";
 import { schemaToEm } from "../helper";
 import { disableConsoleLog, enableConsoleLog } from "core/utils/test";
-import { parse } from "core/utils/schema";
+import { parse } from "bknd/core";

 beforeAll(disableConsoleLog);
 afterAll(enableConsoleLog);
@@ -202,7 +202,7 @@ describe("DataApi", () => {
      {
         // create many
         const res = await api.createMany("posts", payload);
-         expect(res.data?.length).toEqual(4);
+         expect(res.data.length).toEqual(4);
         expect(res.ok).toBeTrue();
      }

@@ -20,7 +20,6 @@ describe("App", () => {
                  "guard",
                  "flags",
                  "logger",
-                  "mcp",
                  "helper",
               ]);
            },
@@ -136,21 +135,4 @@ describe("App", () => {
      // expect async listeners to be executed sync after request
      expect(called).toHaveBeenCalled();
   });
-
-   test("getMcpClient", async () => {
-      const app = createApp({
-         initialConfig: {
-            server: {
-               mcp: {
-                  enabled: true,
-               },
-            },
-         },
-      });
-      await app.build();
-      const client = app.getMcpClient();
-      const res = await client.listTools();
-      expect(res).toBeDefined();
-      expect(res?.tools.length).toBeGreaterThan(0);
-   });
 });
@@ -8,15 +8,10 @@ describe("AppServer", () => {
         expect(server).toBeDefined();
         expect(server.config).toEqual({
            cors: {
-               allow_credentials: true,
               origin: "*",
               allow_methods: ["GET", "POST", "PATCH", "PUT", "DELETE"],
               allow_headers: ["Content-Type", "Content-Length", "Authorization", "Accept"],
            },
-            mcp: {
-               enabled: false,
-               path: "/api/system/mcp",
-            },
         });
      }

@@ -30,15 +25,10 @@ describe("AppServer", () => {
         expect(server).toBeDefined();
         expect(server.config).toEqual({
            cors: {
-               allow_credentials: true,
               origin: "https",
               allow_methods: ["GET", "POST"],
               allow_headers: ["Content-Type", "Content-Length", "Authorization", "Accept"],
            },
-            mcp: {
-               enabled: false,
-               path: "/api/system/mcp",
-            },
         });
      }
   });
@@ -1,226 +0,0 @@
-import { describe, test, expect, beforeEach, beforeAll, afterAll } from "bun:test";
-import { type App, createApp, createMcpToolCaller } from "core/test/utils";
-import { disableConsoleLog, enableConsoleLog } from "core/utils";
-import type { McpServer } from "bknd/utils";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
-
-/**
- * - [x] auth_me
- * - [x] auth_strategies
- * - [x] auth_user_create
- * - [x] auth_user_token
- * - [x] auth_user_password_change
- * - [x] auth_user_password_test
- * - [x] config_auth_get
- * - [x] config_auth_update
- * - [x] config_auth_strategies_get
- * - [x] config_auth_strategies_add
- * - [x] config_auth_strategies_update
- * - [x] config_auth_strategies_remove
- * - [x] config_auth_roles_get
- * - [x] config_auth_roles_add
- * - [x] config_auth_roles_update
- * - [x] config_auth_roles_remove
- */
-describe("mcp auth", async () => {
-   let app: App;
-   let server: McpServer;
-   beforeEach(async () => {
-      app = createApp({
-         initialConfig: {
-            auth: {
-               enabled: true,
-               jwt: {
-                  secret: "secret",
-               },
-            },
-            server: {
-               mcp: {
-                  enabled: true,
-               },
-            },
-         },
-      });
-      await app.build();
-      server = app.mcp!;
-      server.setLogLevel("error");
-      server.onNotification((message) => {
-         console.dir(message, { depth: null });
-      });
-   });
-
-   const tool = createMcpToolCaller();
-
-   test("auth_*", async () => {
-      const me = await tool(server, "auth_me", {});
-      expect(me.user).toBeNull();
-
-      // strategies
-      const strategies = await tool(server, "auth_strategies", {});
-      expect(Object.keys(strategies.strategies).length).toEqual(1);
-      expect(strategies.strategies.password.enabled).toBe(true);
-
-      // create user
-      const user = await tool(
-         server,
-         "auth_user_create",
-         {
-            email: "test@test.com",
-            password: "12345678",
-         },
-         new Headers(),
-      );
-      expect(user.email).toBe("test@test.com");
-
-      // create token
-      const token = await tool(
-         server,
-         "auth_user_token",
-         {
-            email: "test@test.com",
-         },
-         new Headers(),
-      );
-      expect(token.token).toBeDefined();
-      expect(token.user.email).toBe("test@test.com");
-
-      // me
-      const me2 = await tool(
-         server,
-         "auth_me",
-         {},
-         new Request("http://localhost", {
-            headers: new Headers({
-               Authorization: `Bearer ${token.token}`,
-            }),
-         }),
-      );
-      expect(me2.user.email).toBe("test@test.com");
-
-      // change password
-      const changePassword = await tool(
-         server,
-         "auth_user_password_change",
-         {
-            email: "test@test.com",
-            password: "87654321",
-         },
-         new Headers(),
-      );
-      expect(changePassword.changed).toBe(true);
-
-      // test password
-      const testPassword = await tool(
-         server,
-         "auth_user_password_test",
-         {
-            email: "test@test.com",
-            password: "87654321",
-         },
-         new Headers(),
-      );
-      expect(testPassword.valid).toBe(true);
-   });
-
-   test("config_auth_{get,update}", async () => {
-      expect(await tool(server, "config_auth_get", {})).toEqual({
-         path: "",
-         secrets: false,
-         partial: false,
-         value: app.toJSON().auth,
-      });
-
-      // update
-      await tool(server, "config_auth_update", {
-         value: {
-            allow_register: false,
-         },
-      });
-      expect(app.toJSON().auth.allow_register).toBe(false);
-   });
-
-   test("config_auth_strategies_{get,add,update,remove}", async () => {
-      const strategies = await tool(server, "config_auth_strategies_get", {
-         key: "password",
-      });
-      expect(strategies).toEqual({
-         secrets: false,
-         module: "auth",
-         key: "password",
-         value: {
-            enabled: true,
-            type: "password",
-         },
-      });
-
-      // add google oauth
-      const addGoogleOauth = await tool(server, "config_auth_strategies_add", {
-         key: "google",
-         value: {
-            type: "oauth",
-            enabled: true,
-            config: {
-               name: "google",
-               type: "oidc",
-               client: {
-                  client_id: "client_id",
-                  client_secret: "client_secret",
-               },
-            },
-         },
-         return_config: true,
-      });
-      expect(addGoogleOauth.config.google.enabled).toBe(true);
-      expect(app.toJSON().auth.strategies.google?.enabled).toBe(true);
-
-      // update (disable) google oauth
-      await tool(server, "config_auth_strategies_update", {
-         key: "google",
-         value: {
-            enabled: false,
-         },
-      });
-      expect(app.toJSON().auth.strategies.google?.enabled).toBe(false);
-
-      // remove google oauth
-      await tool(server, "config_auth_strategies_remove", {
-         key: "google",
-      });
-      expect(app.toJSON().auth.strategies.google).toBeUndefined();
-   });
-
-   test("config_auth_roles_{get,add,update,remove}", async () => {
-      // add role
-      const addGuestRole = await tool(server, "config_auth_roles_add", {
-         key: "guest",
-         value: {
-            permissions: ["read", "write"],
-         },
-         return_config: true,
-      });
-      expect(addGuestRole.config.guest.permissions).toEqual(["read", "write"]);
-
-      // update role
-      await tool(server, "config_auth_roles_update", {
-         key: "guest",
-         value: {
-            permissions: ["read"],
-         },
-      });
-      expect(app.toJSON().auth.roles?.guest?.permissions).toEqual(["read"]);
-
-      // get role
-      const getGuestRole = await tool(server, "config_auth_roles_get", {
-         key: "guest",
-      });
-      expect(getGuestRole.value.permissions).toEqual(["read"]);
-
-      // remove role
-      await tool(server, "config_auth_roles_remove", {
-         key: "guest",
-      });
-      expect(app.toJSON().auth.roles?.guest).toBeUndefined();
-   });
-});
@@ -1,35 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { createApp } from "core/test/utils";
-import { registries } from "index";
-import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
-
-describe("mcp", () => {
-   it("should have tools", async () => {
-      registries.media.register("local", StorageLocalAdapter);
-
-      const app = createApp({
-         initialConfig: {
-            auth: {
-               enabled: true,
-            },
-            media: {
-               enabled: true,
-               adapter: {
-                  type: "local",
-                  config: {
-                     path: "./",
-                  },
-               },
-            },
-            server: {
-               mcp: {
-                  enabled: true,
-               },
-            },
-         },
-      });
-      await app.build();
-
-      expect(app.mcp?.tools.length).toBeGreaterThan(0);
-   });
-});
@@ -1,346 +0,0 @@
-import { describe, test, expect, beforeEach, beforeAll, afterAll } from "bun:test";
-import { type App, createApp, createMcpToolCaller } from "core/test/utils";
-import { getSystemMcp } from "modules/mcp/system-mcp";
-import { pickKeys, type McpServer } from "bknd/utils";
-import { entity, text } from "bknd";
-import { disableConsoleLog, enableConsoleLog } from "core/utils";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
-
-/**
- * - [ ] data_sync
- * - [x] data_entity_fn_count
- * - [x] data_entity_fn_exists
- * - [x] data_entity_read_one
- * - [x] data_entity_read_many
- * - [x] data_entity_insert
- * - [x] data_entity_update_many
- * - [x] data_entity_update_one
- * - [x] data_entity_delete_one
- * - [x] data_entity_delete_many
- * - [x] data_entity_info
- * - [ ] config_data_get
- * - [ ] config_data_update
- * - [x] config_data_entities_get
- * - [x] config_data_entities_add
- * - [x] config_data_entities_update
- * - [x] config_data_entities_remove
- * - [x] config_data_relations_add
- * - [x] config_data_relations_get
- * - [x] config_data_relations_update
- * - [x] config_data_relations_remove
- * - [x] config_data_indices_get
- * - [x] config_data_indices_add
- * - [x] config_data_indices_update
- * - [x] config_data_indices_remove
- */
-describe("mcp data", async () => {
-   let app: App;
-   let server: McpServer;
-   beforeEach(async () => {
-      const time = performance.now();
-      app = createApp({
-         initialConfig: {
-            server: {
-               mcp: {
-                  enabled: true,
-               },
-            },
-         },
-      });
-      await app.build();
-      server = app.mcp!;
-      server.setLogLevel("error");
-      server.onNotification((message) => {
-         console.dir(message, { depth: null });
-      });
-   });
-
-   const tool = createMcpToolCaller();
-
-   test("config_data_entities_{add,get,update,remove}", async () => {
-      const result = await tool(server, "config_data_entities_add", {
-         key: "test",
-         return_config: true,
-         value: {},
-      });
-      expect(result.success).toBe(true);
-      expect(result.module).toBe("data");
-      expect(result.config.test?.type).toEqual("regular");
-
-      const entities = Object.keys(app.toJSON().data.entities ?? {});
-      expect(entities).toContain("test");
-
-      {
-         // get
-         const result = await tool(server, "config_data_entities_get", {
-            key: "test",
-         });
-         expect(result.module).toBe("data");
-         expect(result.key).toBe("test");
-         expect(result.value.type).toEqual("regular");
-      }
-
-      {
-         // update
-         const result = await tool(server, "config_data_entities_update", {
-            key: "test",
-            return_config: true,
-            value: {
-               config: {
-                  name: "Test",
-               },
-            },
-         });
-         expect(result.success).toBe(true);
-         expect(result.module).toBe("data");
-         expect(result.config.test.config?.name).toEqual("Test");
-         expect(app.toJSON().data.entities?.test?.config?.name).toEqual("Test");
-      }
-
-      {
-         // remove
-         const result = await tool(server, "config_data_entities_remove", {
-            key: "test",
-         });
-         expect(result.success).toBe(true);
-         expect(result.module).toBe("data");
-         expect(app.toJSON().data.entities?.test).toBeUndefined();
-      }
-   });
-
-   test("config_data_relations_{add,get,update,remove}", async () => {
-      // create posts and comments
-      await tool(server, "config_data_entities_add", {
-         key: "posts",
-         value: {},
-      });
-      await tool(server, "config_data_entities_add", {
-         key: "comments",
-         value: {},
-      });
-
-      expect(Object.keys(app.toJSON().data.entities ?? {})).toEqual(["posts", "comments"]);
-
-      // create relation
-      await tool(server, "config_data_relations_add", {
-         key: "", // doesn't matter
-         value: {
-            type: "n:1",
-            source: "comments",
-            target: "posts",
-         },
-      });
-
-      const config = app.toJSON().data;
-      expect(
-         pickKeys((config.relations?.n1_comments_posts as any) ?? {}, ["type", "source", "target"]),
-      ).toEqual({
-         type: "n:1",
-         source: "comments",
-         target: "posts",
-      });
-
-      expect(config.entities?.comments?.fields?.posts_id?.type).toBe("relation");
-
-      {
-         // info
-         const postsInfo = await tool(server, "data_entity_info", {
-            entity: "posts",
-         });
-         expect(postsInfo.fields).toEqual(["id"]);
-         expect(postsInfo.relations.all.length).toBe(1);
-
-         const commentsInfo = await tool(server, "data_entity_info", {
-            entity: "comments",
-         });
-         expect(commentsInfo.fields).toEqual(["id", "posts_id"]);
-         expect(commentsInfo.relations.all.length).toBe(1);
-      }
-
-      // update
-      await tool(server, "config_data_relations_update", {
-         key: "n1_comments_posts",
-         value: {
-            config: {
-               with_limit: 10,
-            },
-         },
-      });
-      expect((app.toJSON().data.relations?.n1_comments_posts?.config as any)?.with_limit).toBe(10);
-
-      // delete
-      await tool(server, "config_data_relations_remove", {
-         key: "n1_comments_posts",
-      });
-      expect(app.toJSON().data.relations?.n1_comments_posts).toBeUndefined();
-   });
-
-   test("config_data_indices_update", async () => {
-      expect(server.tools.map((t) => t.name).includes("config_data_indices_update")).toBe(false);
-   });
-
-   test("config_data_indices_{add,get,remove}", async () => {
-      // create posts and comments
-      await tool(server, "config_data_entities_add", {
-         key: "posts",
-         value: entity("posts", {
-            title: text(),
-            content: text(),
-         }).toJSON(),
-      });
-
-      // add index on title
-      await tool(server, "config_data_indices_add", {
-         key: "", // auto generated
-         value: {
-            entity: "posts",
-            fields: ["title"],
-         },
-      });
-
-      expect(app.toJSON().data.indices?.idx_posts_title).toEqual({
-         entity: "posts",
-         fields: ["title"],
-         unique: false,
-      });
-
-      // delete
-      await tool(server, "config_data_indices_remove", {
-         key: "idx_posts_title",
-      });
-      expect(app.toJSON().data.indices?.idx_posts_title).toBeUndefined();
-   });
-
-   test("data_entity_*", async () => {
-      // create posts and comments
-      await tool(server, "config_data_entities_add", {
-         key: "posts",
-         value: entity("posts", {
-            title: text(),
-            content: text(),
-         }).toJSON(),
-      });
-      await tool(server, "config_data_entities_add", {
-         key: "comments",
-         value: entity("comments", {
-            content: text(),
-         }).toJSON(),
-      });
-
-      // insert a few posts
-      for (let i = 0; i < 10; i++) {
-         await tool(server, "data_entity_insert", {
-            entity: "posts",
-            json: {
-               title: `Post ${i}`,
-            },
-         });
-      }
-      // insert a few comments
-      for (let i = 0; i < 5; i++) {
-         await tool(server, "data_entity_insert", {
-            entity: "comments",
-            json: {
-               content: `Comment ${i}`,
-            },
-         });
-      }
-
-      const result = await tool(server, "data_entity_read_many", {
-         entity: "posts",
-         limit: 5,
-      });
-      expect(result.data.length).toBe(5);
-      expect(result.meta.items).toBe(5);
-      expect(result.meta.total).toBe(10);
-      expect(result.data[0].title).toBe("Post 0");
-
-      {
-         // count
-         const result = await tool(server, "data_entity_fn_count", {
-            entity: "posts",
-         });
-         expect(result.count).toBe(10);
-      }
-
-      {
-         // exists
-         const res = await tool(server, "data_entity_fn_exists", {
-            entity: "posts",
-            json: {
-               id: result.data[0].id,
-            },
-         });
-         expect(res.exists).toBe(true);
-
-         const res2 = await tool(server, "data_entity_fn_exists", {
-            entity: "posts",
-            json: {
-               id: "123",
-            },
-         });
-         expect(res2.exists).toBe(false);
-      }
-
-      // update
-      await tool(server, "data_entity_update_one", {
-         entity: "posts",
-         id: result.data[0].id,
-         json: {
-            title: "Post 0 updated",
-         },
-      });
-      const result2 = await tool(server, "data_entity_read_one", {
-         entity: "posts",
-         id: result.data[0].id,
-      });
-      expect(result2.data.title).toBe("Post 0 updated");
-
-      // delete the second post
-      await tool(server, "data_entity_delete_one", {
-         entity: "posts",
-         id: result.data[1].id,
-      });
-      const result3 = await tool(server, "data_entity_read_many", {
-         entity: "posts",
-         limit: 2,
-      });
-      expect(result3.data.map((p) => p.id)).toEqual([1, 3]);
-
-      // update many
-      await tool(server, "data_entity_update_many", {
-         entity: "posts",
-         update: {
-            title: "Post updated",
-         },
-         where: {
-            title: { $isnull: 0 },
-         },
-      });
-      const result4 = await tool(server, "data_entity_read_many", {
-         entity: "posts",
-         limit: 10,
-      });
-      expect(result4.data.length).toBe(9);
-      expect(result4.data.map((p) => p.title)).toEqual(
-         Array.from({ length: 9 }, () => "Post updated"),
-      );
-
-      // delete many
-      await tool(server, "data_entity_delete_many", {
-         entity: "posts",
-         json: {
-            title: { $isnull: 0 },
-         },
-      });
-      const result5 = await tool(server, "data_entity_read_many", {
-         entity: "posts",
-         limit: 10,
-      });
-      expect(result5.data.length).toBe(0);
-      expect(result5.meta.items).toBe(0);
-      expect(result5.meta.total).toBe(0);
-   });
-});
@@ -1,118 +0,0 @@
-import { describe, test, expect, beforeAll, beforeEach, afterAll } from "bun:test";
-import { type App, createApp, createMcpToolCaller } from "core/test/utils";
-import { getSystemMcp } from "modules/mcp/system-mcp";
-import { registries } from "index";
-import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
-import { disableConsoleLog, enableConsoleLog } from "core/utils";
-import type { McpServer } from "bknd/utils";
-
-beforeAll(disableConsoleLog);
-afterAll(enableConsoleLog);
-
-/**
- * - [x] config_media_get
- * - [x] config_media_update
- * - [x] config_media_adapter_get
- * - [x] config_media_adapter_update
- */
-describe("mcp media", async () => {
-   let app: App;
-   let server: McpServer;
-   beforeEach(async () => {
-      registries.media.register("local", StorageLocalAdapter);
-      app = createApp({
-         initialConfig: {
-            media: {
-               enabled: true,
-               adapter: {
-                  type: "local",
-                  config: {
-                     path: "./",
-                  },
-               },
-            },
-            server: {
-               mcp: {
-                  enabled: true,
-               },
-            },
-         },
-      });
-      await app.build();
-      server = app.mcp!;
-      server.setLogLevel("error");
-      server.onNotification((message) => {
-         console.dir(message, { depth: null });
-      });
-   });
-
-   const tool = createMcpToolCaller();
-
-   test("config_media_{get,update}", async () => {
-      const result = await tool(server, "config_media_get", {});
-      expect(result).toEqual({
-         path: "",
-         secrets: false,
-         partial: false,
-         value: app.toJSON().media,
-      });
-
-      // partial
-      expect((await tool(server, "config_media_get", { path: "adapter" })).value).toEqual({
-         type: "local",
-         config: {
-            path: "./",
-         },
-      });
-
-      // update
-      await tool(server, "config_media_update", {
-         value: {
-            storage: {
-               body_max_size: 1024 * 1024 * 10,
-            },
-         },
-         return_config: true,
-      });
-      expect(app.toJSON().media.storage.body_max_size).toBe(1024 * 1024 * 10);
-   });
-
-   test("config_media_adapter_{get,update}", async () => {
-      const result = await tool(server, "config_media_adapter_get", {});
-      expect(result).toEqual({
-         secrets: false,
-         value: app.toJSON().media.adapter,
-      });
-
-      // update
-      await tool(server, "config_media_adapter_update", {
-         value: {
-            type: "local",
-            config: {
-               path: "./subdir",
-            },
-         },
-      });
-      const adapter = app.toJSON().media.adapter as any;
-      expect(adapter.config.path).toBe("./subdir");
-      expect(adapter.type).toBe("local");
-
-      // set to s3
-      {
-         await tool(server, "config_media_adapter_update", {
-            value: {
-               type: "s3",
-               config: {
-                  access_key: "123",
-                  secret_access_key: "456",
-                  url: "https://example.com/what",
-               },
-            },
-         });
-
-         const adapter = app.toJSON(true).media.adapter as any;
-         expect(adapter.type).toBe("s3");
-         expect(adapter.config.url).toBe("https://example.com/what");
-      }
-   });
-});
@@ -1,72 +0,0 @@
-import { describe, test, expect, beforeAll, mock, beforeEach, afterAll } from "bun:test";
-import { type App, createApp, createMcpToolCaller } from "core/test/utils";
-import type { McpServer } from "bknd/utils";
-
-/**
- * - [x] config_server_get
- * - [x] config_server_update
- */
-describe("mcp system", async () => {
-   let app: App;
-   let server: McpServer;
-   beforeAll(async () => {
-      app = createApp({
-         initialConfig: {
-            server: {
-               mcp: {
-                  enabled: true,
-               },
-            },
-         },
-      });
-      await app.build();
-      server = app.mcp!;
-   });
-
-   const tool = createMcpToolCaller();
-
-   test("config_server_get", async () => {
-      const result = await tool(server, "config_server_get", {});
-      expect(JSON.parse(JSON.stringify(result))).toEqual({
-         path: "",
-         secrets: false,
-         partial: false,
-         value: JSON.parse(JSON.stringify(app.toJSON().server)),
-      });
-   });
-
-   test("config_server_get2", async () => {
-      const result = await tool(server, "config_server_get", {});
-      expect(JSON.parse(JSON.stringify(result))).toEqual({
-         path: "",
-         secrets: false,
-         partial: false,
-         value: JSON.parse(JSON.stringify(app.toJSON().server)),
-      });
-   });
-
-   test("config_server_update", async () => {
-      const original = JSON.parse(JSON.stringify(app.toJSON().server));
-      const result = await tool(server, "config_server_update", {
-         value: {
-            cors: {
-               origin: "http://localhost",
-            },
-         },
-         return_config: true,
-      });
-
-      expect(JSON.parse(JSON.stringify(result))).toEqual({
-         success: true,
-         module: "server",
-         config: {
-            ...original,
-            cors: {
-               ...original.cors,
-               origin: "http://localhost",
-            },
-         },
-      });
-      expect(app.toJSON().server.cors.origin).toBe("http://localhost");
-   });
-});
@@ -1,56 +0,0 @@
-import { AppEvents } from "App";
-import { describe, test, expect, beforeAll, mock } from "bun:test";
-import { type App, createApp, createMcpToolCaller } from "core/test/utils";
-import type { McpServer } from "bknd/utils";
-
-/**
- * - [x] system_config
- * - [x] system_build
- * - [x] system_ping
- * - [x] system_info
- */
-describe("mcp system", async () => {
-   let app: App;
-   let server: McpServer;
-   beforeAll(async () => {
-      app = createApp({
-         initialConfig: {
-            server: {
-               mcp: {
-                  enabled: true,
-               },
-            },
-         },
-      });
-      await app.build();
-      server = app.mcp!;
-   });
-
-   const tool = createMcpToolCaller();
-
-   test("system_ping", async () => {
-      const result = await tool(server, "system_ping", {});
-      expect(result).toEqual({ pong: true });
-   });
-
-   test("system_info", async () => {
-      const result = await tool(server, "system_info", {});
-      expect(Object.keys(result).length).toBeGreaterThan(0);
-      expect(Object.keys(result)).toContainValues(["version", "runtime", "connection"]);
-   });
-
-   test("system_build", async () => {
-      const called = mock(() => null);
-
-      app.emgr.onEvent(AppEvents.AppBuiltEvent, () => void called(), { once: true });
-
-      const result = await tool(server, "system_build", {});
-      expect(called).toHaveBeenCalledTimes(1);
-      expect(result.success).toBe(true);
-   });
-
-   test("system_config", async () => {
-      const result = await tool(server, "system_config", {});
-      expect(result).toEqual(app.toJSON());
-   });
-});
@@ -1,3 +1,45 @@
 import { describe, expect, test } from "bun:test";
+import { Authenticator, type User, type UserPool } from "../../src/auth";
+import { cookieConfig } from "../../src/auth/authenticate/Authenticator";
+import { PasswordStrategy } from "../../src/auth/authenticate/strategies/PasswordStrategy";
+import { parse } from "bknd/core";

-describe("Authenticator", async () => {});
+/*class MemoryUserPool implements UserPool {
+   constructor(private users: User[] = []) {}
+
+   async findBy(prop: "id" | "email" | "username", value: string | number) {
+      return this.users.find((user) => user[prop] === value);
+   }
+
+   async create(user: Pick<User, "email" | "password">) {
+      const id = this.users.length + 1;
+      const newUser = { ...user, id, username: user.email };
+      this.users.push(newUser);
+      return newUser;
+   }
+}*/
+
+describe("Authenticator", async () => {
+   test("cookie options", async () => {
+      console.log("parsed", parse(cookieConfig, undefined));
+      console.log(cookieConfig.template({}));
+   });
+   /*const userpool = new MemoryUserPool([
+      { id: 1, email: "d", username: "test", password: await hash.sha256("test") },
+   ]);
+
+   test("sha256 login", async () => {
+      const auth = new Authenticator(userpool, {
+         password: new PasswordStrategy({
+            hashing: "sha256",
+         }),
+      });
+
+      const { token } = await auth.login("password", { email: "d", password: "test" });
+      expect(token).toBeDefined();
+
+      const { iat, ...decoded } = decodeJwt<any>(token);
+      expect(decoded).toEqual({ id: 1, email: "d", username: "test" });
+      expect(await auth.verify(token)).toBe(true);
+   });*/
+});
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { Guard } from "../../../src/auth/authorize/Guard";
+import { Guard } from "../../../src/auth";

 describe("authorize", () => {
   test("basic", async () => {
@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { Registry } from "core/registry/Registry";
-import { s } from "core/utils/schema";
+import { Registry } from "core";
+import { s } from "bknd/core";

 type Constructor<T> = new (...args: any[]) => T;

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { s } from "core/utils/schema";
-import { SchemaObject } from "core/object/SchemaObject";
+import { SchemaObject } from "../../../src/core";
+import { s } from "bknd/core";

 describe("SchemaObject", async () => {
   test("basic", async () => {
@@ -1,16 +1,19 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";

-import { Guard } from "../../src/auth/authorize/Guard";
-import { parse } from "core/utils/schema";
-
+import { Guard } from "../../src/auth";
+import { parse } from "bknd/core";
+import {
+   Entity,
+   type EntityData,
+   EntityManager,
+   ManyToOneRelation,
+   TextField,
+} from "../../src/data";
 import { DataController } from "../../src/data/api/DataController";
 import { dataConfigSchema } from "../../src/data/data-schema";
 import { disableConsoleLog, enableConsoleLog, getDummyConnection } from "../helper";
 import type { RepositoryResultJSON } from "data/entities/query/RepositoryResult";
 import type { MutatorResultJSON } from "data/entities/mutation/MutatorResult";
-import { Entity, EntityManager, type EntityData } from "data/entities";
-import { TextField } from "data/fields";
-import { ManyToOneRelation } from "data/relations";

 const { dummyConnection, afterAllCleanup } = getDummyConnection();
 beforeAll(() => disableConsoleLog(["log", "warn"]));
@@ -1,6 +1,12 @@
 import { afterAll, describe, expect, test } from "bun:test";
-import { Entity, EntityManager } from "data/entities";
-import { TextField, PrimaryField, NumberField } from "data/fields";
+import {
+   Entity,
+   EntityManager,
+   NumberField,
+   PrimaryField,
+   Repository,
+   TextField,
+} from "../../src/data";
 import { getDummyConnection } from "./helper";

 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -2,7 +2,7 @@ import { unlink } from "node:fs/promises";
 import type { SqliteDatabase } from "kysely";
 // @ts-ignore
 import Database from "libsql";
-import { SqliteLocalConnection } from "data/connection/sqlite/SqliteLocalConnection";
+import { SqliteLocalConnection } from "../../src/data";

 export function getDummyDatabase(memory: boolean = true): {
   dummyDb: SqliteDatabase;
@@ -1,10 +1,13 @@
 // eslint-disable-next-line import/no-unresolved
 import { afterAll, describe, expect, test } from "bun:test";
-import { Entity } from "data/entities";
-import { EntityManager } from "data/entities/EntityManager";
-import { ManyToOneRelation } from "data/relations";
-import { NumberField, TextField } from "data/fields";
-import { SchemaManager } from "data/schema/SchemaManager";
+import {
+   Entity,
+   EntityManager,
+   ManyToOneRelation,
+   NumberField,
+   SchemaManager,
+   TextField,
+} from "../../src/data";
 import { getDummyConnection } from "./helper";

 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -1,8 +1,7 @@
 // eslint-disable-next-line import/no-unresolved
 import { afterAll, describe, expect, test } from "bun:test";
-import { Entity, EntityManager } from "data/entities";
-import { NumberField, TextField } from "data/fields";
-import { TransformPersistFailedException } from "data/errors";
+import { Entity, EntityManager, Mutator, NumberField, TextField } from "../../src/data";
+import { TransformPersistFailedException } from "../../src/data/errors";
 import { getDummyConnection } from "./helper";

 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -1,8 +1,6 @@
 import { afterAll, expect as bunExpect, describe, test } from "bun:test";
-import { stripMark } from "core/utils/schema";
-import { Entity, EntityManager } from "data/entities";
-import { TextField } from "data/fields";
-import { PolymorphicRelation } from "data/relations";
+import { stripMark } from "bknd/core";
+import { Entity, EntityManager, PolymorphicRelation, TextField } from "../../src/data";
 import { getDummyConnection } from "./helper";

 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -2,20 +2,19 @@ import { describe, expect, test } from "bun:test";
 import {
   BooleanField,
   DateField,
+   Entity,
+   EntityIndex,
+   EntityManager,
   EnumField,
   JsonField,
-   NumberField,
-   TextField,
-   EntityIndex,
-} from "data/fields";
-import { Entity, EntityManager } from "data/entities";
-import {
   ManyToManyRelation,
   ManyToOneRelation,
+   NumberField,
   OneToOneRelation,
   PolymorphicRelation,
-} from "data/relations";
-import { DummyConnection } from "data/connection/DummyConnection";
+   TextField,
+} from "../../src/data";
+import { DummyConnection } from "../../src/data/connection/DummyConnection";
 import {
   FieldPrototype,
   type FieldSchema,
@@ -33,8 +32,8 @@ import {
   number,
   relation,
   text,
-} from "data/prototype";
-import { MediaField } from "media/MediaField";
+} from "../../src/data/prototype";
+import { MediaField } from "../../src/media/MediaField";

 describe("prototype", () => {
   test("...", () => {
@@ -297,9 +296,9 @@ describe("prototype", () => {
         new Entity("posts", [new TextField("name"), new TextField("slug", { required: true })]),
         new Entity("comments", [new TextField("some")]),
         new Entity("users", [new TextField("email")]),
-      ] as const;
+      ];
      const _em2 = new EntityManager(
-         [...es],
+         es,
         new DummyConnection(),
         [new ManyToOneRelation(es[0], es[1]), new ManyToOneRelation(es[0], es[2])],
         [
@@ -1,14 +1,13 @@
 // eslint-disable-next-line import/no-unresolved
 import { afterAll, describe, expect, test } from "bun:test";
-import { Entity, EntityManager } from "data/entities";
-import { TextField } from "data/fields";
+import { Entity, EntityManager, TextField } from "../../src/data";
 import {
   ManyToManyRelation,
   ManyToOneRelation,
   OneToOneRelation,
   PolymorphicRelation,
   RelationField,
-} from "data/relations";
+} from "../../src/data/relations";
 import { getDummyConnection } from "./helper";

 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -78,7 +77,7 @@ describe("Relations", async () => {
      const em = new EntityManager(entities, dummyConnection, relations);

      // verify naming
-      const rel = em.relations.all[0]!;
+      const rel = em.relations.all[0];
      expect(rel.source.entity.name).toBe(posts.name);
      expect(rel.source.reference).toBe(posts.name);
      expect(rel.target.entity.name).toBe(users.name);
@@ -90,11 +89,11 @@ describe("Relations", async () => {
      // verify low level relation
      expect(em.relationsOf(users.name).length).toBe(1);
      expect(em.relationsOf(users.name).length).toBe(1);
-      expect(em.relationsOf(users.name)[0]!.source.entity).toBe(posts);
+      expect(em.relationsOf(users.name)[0].source.entity).toBe(posts);
      expect(posts.field("author_id")).toBeInstanceOf(RelationField);
      expect(em.relationsOf(users.name).length).toBe(1);
      expect(em.relationsOf(users.name).length).toBe(1);
-      expect(em.relationsOf(users.name)[0]!.source.entity).toBe(posts);
+      expect(em.relationsOf(users.name)[0].source.entity).toBe(posts);

      // verify high level relation (from users)
      const userPostsRel = em.relationOf(users.name, "posts");
@@ -192,7 +191,7 @@ describe("Relations", async () => {
      const em = new EntityManager(entities, dummyConnection, relations);

      // verify naming
-      const rel = em.relations.all[0]!;
+      const rel = em.relations.all[0];
      expect(rel.source.entity.name).toBe(users.name);
      expect(rel.source.reference).toBe(users.name);
      expect(rel.target.entity.name).toBe(settings.name);
@@ -203,8 +202,8 @@ describe("Relations", async () => {

      expect(em.relationsOf(users.name).length).toBe(1);
      expect(em.relationsOf(users.name).length).toBe(1);
-      expect(em.relationsOf(users.name)[0]!.source.entity).toBe(users);
-      expect(em.relationsOf(users.name)[0]!.target.entity).toBe(settings);
+      expect(em.relationsOf(users.name)[0].source.entity).toBe(users);
+      expect(em.relationsOf(users.name)[0].target.entity).toBe(settings);

      // verify high level relation (from users)
      const userSettingRel = em.relationOf(users.name, settings.name);
@@ -324,7 +323,7 @@ describe("Relations", async () => {
      );

      // mutation info
-      expect(relations[0]!.helper(posts.name)!.getMutationInfo()).toEqual({
+      expect(relations[0].helper(posts.name)!.getMutationInfo()).toEqual({
         reference: "categories",
         local_field: undefined,
         $set: false,
@@ -335,7 +334,7 @@ describe("Relations", async () => {
         cardinality: undefined,
         relation_type: "m:n",
      });
-      expect(relations[0]!.helper(categories.name)!.getMutationInfo()).toEqual({
+      expect(relations[0].helper(categories.name)!.getMutationInfo()).toEqual({
         reference: "posts",
         local_field: undefined,
         $set: false,
@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { Entity } from "data/entities";
-import { NumberField, TextField } from "data/fields";
+import { Entity, NumberField, TextField } from "data";
+import * as p from "data/prototype";

 describe("[data] Entity", async () => {
   const entity = new Entity("test", [
@@ -47,4 +47,8 @@ describe("[data] Entity", async () => {
      entity.addField(field);
      expect(entity.getField("new_field")).toBe(field);
   });
+
+   test.only("types", async () => {
+      console.log(entity.toTypes());
+   });
 });
@@ -1,8 +1,12 @@
 import { afterAll, describe, expect, test } from "bun:test";
-import { Entity, EntityManager } from "data/entities";
-import { ManyToManyRelation, ManyToOneRelation } from "data/relations";
-import { SchemaManager } from "data/schema/SchemaManager";
-import { UnableToConnectException } from "data/errors";
+import {
+   Entity,
+   EntityManager,
+   ManyToManyRelation,
+   ManyToOneRelation,
+   SchemaManager,
+} from "../../../src/data";
+import { UnableToConnectException } from "../../../src/data/errors";
 import { getDummyConnection } from "../helper";

 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -1,8 +1,6 @@
 import { afterAll, describe, expect, test } from "bun:test";
-import { Entity, EntityManager } from "data/entities";
-import { ManyToOneRelation } from "data/relations";
-import { TextField } from "data/fields";
-import { JoinBuilder } from "data/entities/query/JoinBuilder";
+import { Entity, EntityManager, ManyToOneRelation, TextField } from "../../../src/data";
+import { JoinBuilder } from "../../../src/data/entities/query/JoinBuilder";
 import { getDummyConnection } from "../helper";

 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -1,16 +1,18 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import type { EventManager } from "../../../src/core/events";
-import { Entity, EntityManager } from "data/entities";
 import {
+   Entity,
+   EntityManager,
   ManyToOneRelation,
+   MutatorEvents,
+   NumberField,
   OneToOneRelation,
-   RelationField,
+   type RelationField,
   RelationMutator,
-} from "data/relations";
-import { NumberField, TextField } from "data/fields";
-import * as proto from "data/prototype";
+   TextField,
+} from "../../../src/data";
+import * as proto from "../../../src/data/prototype";
 import { getDummyConnection, disableConsoleLog, enableConsoleLog } from "../../helper";
-import { MutatorEvents } from "data/events";

 const { dummyConnection, afterAllCleanup } = getDummyConnection();
 afterAll(afterAllCleanup);
@@ -1,10 +1,17 @@
 import { afterAll, describe, expect, test } from "bun:test";
 import type { Kysely, Transaction } from "kysely";
-import { TextField } from "data/fields";
-import { em as $em, entity as $entity, text as $text } from "data/prototype";
-import { Entity, EntityManager } from "data/entities";
-import { ManyToOneRelation } from "data/relations";
-import { RepositoryEvents } from "data/events";
+import { Perf } from "core/utils";
+import {
+   Entity,
+   EntityManager,
+   LibsqlConnection,
+   ManyToOneRelation,
+   RepositoryEvents,
+   TextField,
+   entity as $entity,
+   text as $text,
+   em as $em,
+} from "data";
 import { getDummyConnection } from "../helper";

 type E = Kysely<any> | Transaction<any>;
@@ -1,9 +1,7 @@
 // eslint-disable-next-line import/no-unresolved
 import { afterAll, describe, expect, test } from "bun:test";
-import { randomString } from "core/utils";
-import { Entity, EntityManager } from "data/entities";
-import { TextField, EntityIndex } from "data/fields";
-import { SchemaManager } from "data/schema/SchemaManager";
+import { randomString } from "../../../src/core/utils";
+import { Entity, EntityIndex, EntityManager, SchemaManager, TextField } from "../../../src/data";
 import { getDummyConnection } from "../helper";

 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -1,6 +1,6 @@
 import { describe, test, expect } from "bun:test";
 import { getDummyConnection } from "../helper";
-import { WhereBuilder, type WhereQuery } from "data/entities/query/WhereBuilder";
+import { type WhereQuery, WhereBuilder } from "data";

 function qb() {
   const c = getDummyConnection();
@@ -1,9 +1,14 @@
 import { describe, expect, test } from "bun:test";
-import { Entity, EntityManager } from "data/entities";
-import { ManyToManyRelation, ManyToOneRelation, PolymorphicRelation } from "data/relations";
-import { TextField } from "data/fields";
-import * as proto from "data/prototype";
-import { WithBuilder } from "data/entities/query/WithBuilder";
+import {
+   Entity,
+   EntityManager,
+   ManyToManyRelation,
+   ManyToOneRelation,
+   PolymorphicRelation,
+   TextField,
+   WithBuilder,
+} from "../../../src/data";
+import * as proto from "../../../src/data/prototype";
 import { schemaToEm } from "../../helper";
 import { getDummyConnection } from "../helper";

@@ -1,5 +1,5 @@
 import { afterAll, describe, expect, test } from "bun:test";
-import { EntityManager } from "data/entities/EntityManager";
+import { EntityManager } from "../../../../src/data";
 import { getDummyConnection } from "../../helper";

 const { dummyConnection, afterAllCleanup } = getDummyConnection();
@@ -1,10 +1,9 @@
-import { bunTestRunner } from "adapter/bun/test";
 import { describe, expect, test } from "bun:test";
-import { BooleanField } from "data/fields";
+import { BooleanField } from "../../../../src/data";
 import { fieldTestSuite, transformPersist } from "data/fields/field-test-suite";

 describe("[data] BooleanField", async () => {
-   fieldTestSuite(bunTestRunner, BooleanField, { defaultValue: true, schemaType: "boolean" });
+   fieldTestSuite({ expect, test }, BooleanField, { defaultValue: true, schemaType: "boolean" });

   test("transformRetrieve", async () => {
      const field = new BooleanField("test");
@@ -1,5 +1,5 @@
-import { describe, test } from "bun:test";
-import { DateField } from "data/fields";
+import { describe, expect, test } from "bun:test";
+import { DateField, dateFieldConfigSchema } from "../../../../src/data";
 import { fieldTestSuite } from "data/fields/field-test-suite";
 import { bunTestRunner } from "adapter/bun/test";

@@ -1,6 +1,5 @@
-import { bunTestRunner } from "adapter/bun/test";
 import { describe, expect, test } from "bun:test";
-import { EnumField } from "data/fields";
+import { EnumField } from "../../../../src/data";
 import { fieldTestSuite, transformPersist } from "data/fields/field-test-suite";

 function options(strings: string[]) {
@@ -9,7 +8,7 @@ function options(strings: string[]) {

 describe("[data] EnumField", async () => {
   fieldTestSuite(
-      bunTestRunner,
+      { expect, test },
      // @ts-ignore
      EnumField,
      { defaultValue: "a", schemaType: "text" },
@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { baseFieldConfigSchema, Field } from "../../../../src/data/fields/Field";
 import { fieldTestSuite } from "data/fields/field-test-suite";
 import { bunTestRunner } from "adapter/bun/test";
-import { stripMark } from "core/utils/schema";
+import { stripMark } from "bknd/core";

 describe("[data] Field", async () => {
   class FieldSpec extends Field {
@@ -1,7 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { Entity } from "data/entities";
-import { Field, EntityIndex } from "data/fields";
-import { s } from "core/utils/schema";
+import { Entity, EntityIndex, Field } from "../../../../src/data";
+import { s } from "bknd/core";

 class TestField extends Field {
   protected getSchema(): any {
@@ -1,11 +1,10 @@
-import { bunTestRunner } from "adapter/bun/test";
 import { describe, expect, test } from "bun:test";
-import { JsonField } from "data/fields";
+import { JsonField } from "../../../../src/data";
 import { fieldTestSuite, transformPersist } from "data/fields/field-test-suite";

 describe("[data] JsonField", async () => {
   const field = new JsonField("test");
-   fieldTestSuite(bunTestRunner, JsonField, {
+   fieldTestSuite({ expect, test }, JsonField, {
      defaultValue: { a: 1 },
      sampleValues: ["string", { test: 1 }, 1],
      schemaType: "text",
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { JsonSchemaField } from "data/fields";
+import { JsonSchemaField } from "../../../../src/data";
 import { fieldTestSuite } from "data/fields/field-test-suite";

 describe("[data] JsonSchemaField", async () => {
@@ -1,6 +1,5 @@
-import { bunTestRunner } from "adapter/bun/test";
 import { describe, expect, test } from "bun:test";
-import { NumberField } from "data/fields";
+import { NumberField } from "../../../../src/data";
 import { fieldTestSuite, transformPersist } from "data/fields/field-test-suite";

 describe("[data] NumberField", async () => {
@@ -16,5 +15,5 @@ describe("[data] NumberField", async () => {
      expect(transformPersist(field2, 10000)).resolves.toBe(10000);
   });

-   fieldTestSuite(bunTestRunner, NumberField, { defaultValue: 12, schemaType: "integer" });
+   fieldTestSuite({ expect, test }, NumberField, { defaultValue: 12, schemaType: "integer" });
 });
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { PrimaryField } from "data/fields";
+import { PrimaryField } from "../../../../src/data";

 describe("[data] PrimaryField", async () => {
   const field = new PrimaryField("primary");
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { TextField } from "data/fields";
+import { TextField, textFieldConfigSchema } from "../../../../src/data";
 import { fieldTestSuite, transformPersist } from "data/fields/field-test-suite";
 import { bunTestRunner } from "adapter/bun/test";

@@ -1,11 +1,11 @@
 import { describe, expect, it, test } from "bun:test";
-import { Entity, type EntityManager } from "data/entities";
+import { Entity, type EntityManager } from "../../../../src/data";
 import {
   type BaseRelationConfig,
   EntityRelation,
   EntityRelationAnchor,
   RelationTypes,
-} from "data/relations";
+} from "../../../../src/data/relations";

 class TestEntityRelation extends EntityRelation {
   constructor(config?: BaseRelationConfig) {
@@ -24,11 +24,11 @@ class TestEntityRelation extends EntityRelation {
      return this;
   }

-   buildWith(): any {
+   buildWith(a: any, b: any, c: any): any {
      return;
   }

-   buildJoin(): any {
+   buildJoin(a: any, b: any): any {
      return;
   }
 }
@@ -1,24 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import * as sDirect from "jsonv-ts";
-import { s as sFromBknd } from "bknd/utils";
-
-describe("jsonv-ts resolution", () => {
-   it("should resolve to a single instance", () => {
-      const sameNamespace = sDirect === (sFromBknd as unknown as typeof sDirect);
-      // If this fails, two instances are being loaded via different specifiers/paths
-      expect(sameNamespace).toBe(true);
-   });
-
-   it("should resolve specifiers to a single package path", async () => {
-      const base = await import.meta.resolve("jsonv-ts");
-      const hono = await import.meta.resolve("jsonv-ts/hono");
-      const mcp = await import.meta.resolve("jsonv-ts/mcp");
-      expect(typeof base).toBe("string");
-      expect(typeof hono).toBe("string");
-      expect(typeof mcp).toBe("string");
-      // They can be different files (subpath exports), but they should share the same package root
-      const pkgRoot = (p: string) => p.slice(0, p.lastIndexOf("jsonv-ts") + "jsonv-ts".length);
-      expect(pkgRoot(base)).toBe(pkgRoot(hono));
-      expect(pkgRoot(base)).toBe(pkgRoot(mcp));
-   });
-});
@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { Flow, LogTask, SubFlowTask, RenderTask, Task } from "../../src/flows";
-import { s } from "core/utils/schema";
+import { s } from "bknd/core";

 export class StringifyTask<Output extends string> extends Task<
   typeof StringifyTask.schema,
@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { Task } from "../../src/flows";
 import { dynamic } from "../../src/flows/tasks/Task";
-import { s } from "core/utils/schema";
+import { s } from "bknd/core";

 describe.skip("Task", async () => {
   test("resolveParams: template with parse", async () => {
@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { Hono } from "hono";
 import { Event, EventManager } from "../../src/core/events";
-import { s, parse } from "core/utils/schema";
+import { s, parse } from "bknd/core";
 import { EventTrigger, Flow, HttpTrigger, type InputsMap, Task } from "../../src/flows";
 import { dynamic } from "../../src/flows/tasks/Task";

@@ -2,7 +2,7 @@
 import { describe, expect, test } from "bun:test";
 import { isEqual } from "lodash-es";
 import { _jsonp, withDisabledConsole } from "../../src/core/utils";
-import { s } from "core/utils/schema";
+import { s } from "bknd/core";
 import { Condition, ExecutionEvent, FetchTask, Flow, LogTask, Task } from "../../src/flows";

 /*beforeAll(disableConsoleLog);
@@ -2,12 +2,11 @@ import { unlink } from "node:fs/promises";
 import type { SelectQueryBuilder, SqliteDatabase } from "kysely";
 import Database from "libsql";
 import { format as sqlFormat } from "sql-formatter";
+import { type Connection, EntityManager, SqliteLocalConnection } from "../src/data";
 import type { em as protoEm } from "../src/data/prototype";
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { slugify } from "bknd/utils";
-import { type Connection, SqliteLocalConnection } from "data/connection";
-import { EntityManager } from "data/entities/EntityManager";
+import { slugify } from "core/utils/strings";

 export function getDummyDatabase(memory: boolean = true): {
   dummyDb: SqliteDatabase;
@@ -54,6 +54,7 @@ describe("MediaController", () => {
         body: file,
      });
      const result = (await res.json()) as any;
+      console.log(result);
      expect(result.name).toBe(name);

      const destFile = Bun.file(assetsTmpPath + "/" + name);
@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { type FileBody, Storage } from "../../src/media/storage/Storage";
 import * as StorageEvents from "../../src/media/storage/events";
-import { StorageAdapter } from "media/storage/StorageAdapter";
+import { StorageAdapter } from "media";

 class TestAdapter extends StorageAdapter {
   files: Record<string, FileBody> = {};
@@ -1,9 +1,10 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import { createApp } from "core/test/utils";
 import { AuthController } from "../../src/auth/api/AuthController";
-import { em, entity, make, text } from "data/prototype";
-import { AppAuth, type ModuleBuildContext } from "modules";
+import { em, entity, make, text } from "../../src/data";
+import { AppAuth, type ModuleBuildContext } from "../../src/modules";
 import { disableConsoleLog, enableConsoleLog } from "../helper";
+// @ts-ignore
 import { makeCtx, moduleTestSuite } from "./module-test-suite";

 describe("AppAuth", () => {
@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, test } from "bun:test";
-import { parse } from "core/utils/schema";
+import { parse } from "bknd/core";
 import { fieldsSchema } from "../../src/data/data-schema";
 import { AppData, type ModuleBuildContext } from "../../src/modules";
 import { makeCtx, moduleTestSuite } from "./module-test-suite";
@@ -1,9 +1,10 @@
 import { describe, expect, test } from "bun:test";
+import { registries } from "../../src";
 import { createApp } from "core/test/utils";
-import { em, entity, text } from "data/prototype";
-import { registries } from "modules/registries";
+import { em, entity, text } from "../../src/data";
 import { StorageLocalAdapter } from "adapter/node/storage/StorageLocalAdapter";
 import { AppMedia } from "../../src/media/AppMedia";
+import { mediaConfigSchema } from "../../src/media/media-schema";
 import { moduleTestSuite } from "./module-test-suite";

 describe("AppMedia", () => {
@@ -1,7 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { s, stripMark } from "core/utils/schema";
-import { em, entity, index, text } from "data/prototype";
-import { EntityManager } from "data/entities/EntityManager";
+import { s, stripMark } from "bknd/core";
+import { EntityManager, em, entity, index, text } from "../../src/data";
 import { DummyConnection } from "../../src/data/connection/DummyConnection";
 import { Module } from "../../src/modules/Module";
 import { ModuleHelper } from "modules/ModuleHelper";
@@ -1,13 +1,11 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 import { disableConsoleLog, enableConsoleLog } from "core/utils";
-
+import { Connection, entity, text } from "data";
 import { Module } from "modules/Module";
 import { type ConfigTable, getDefaultConfig, ModuleManager } from "modules/ModuleManager";
 import { CURRENT_VERSION, TABLE_NAME } from "modules/migrations";
 import { getDummyConnection } from "../helper";
-import { s, stripMark } from "core/utils/schema";
-import { Connection } from "data/connection/Connection";
-import { entity, text } from "data/prototype";
+import { s, stripMark } from "bknd/core";

 describe("ModuleManager", async () => {
   test("s1: no config, no build", async () => {
@@ -1,13 +1,13 @@
 import { beforeEach, describe, expect, it } from "bun:test";

 import { Hono } from "hono";
-import { Guard } from "auth/authorize/Guard";
-import { EventManager } from "core/events";
-import { EntityManager } from "data/entities/EntityManager";
-import { Module, type ModuleBuildContext } from "modules/Module";
+import { Guard } from "../../src/auth";
+import { DebugLogger } from "../../src/core";
+import { EventManager } from "../../src/core/events";
+import { EntityManager } from "../../src/data";
+import { Module, type ModuleBuildContext } from "../../src/modules/Module";
 import { getDummyConnection } from "../helper";
 import { ModuleHelper } from "modules/ModuleHelper";
-import { DebugLogger, McpServer } from "bknd/utils";

 export function makeCtx(overrides?: Partial<ModuleBuildContext>): ModuleBuildContext {
   const { dummyConnection } = getDummyConnection();
@@ -19,7 +19,6 @@ export function makeCtx(overrides?: Partial<ModuleBuildContext>): ModuleBuildCon
      guard: new Guard(),
      flags: Module.ctx_flags,
      logger: new DebugLogger(false),
-      mcp: new McpServer(),
      ...overrides,
   };
   return {
@@ -102,9 +102,7 @@ describe("json form", () => {
      ] satisfies [string, Exclude<JSONSchema, boolean>, boolean][];

      for (const [pointer, schema, output] of examples) {
-         expect(utils.isRequired(new Draft2019(schema), pointer, schema), `${pointer} `).toBe(
-            output,
-         );
+         expect(utils.isRequired(new Draft2019(schema), pointer, schema)).toBe(output);
      }
   });

@@ -1,24 +1,6 @@
 import pkg from "./package.json" with { type: "json" };
 import c from "picocolors";
-import { formatNumber } from "bknd/utils";
-import * as esbuild from "esbuild";
-
-if (process.env.DEBUG) {
-   await esbuild.build({
-      entryPoints: ["./src/cli/index.ts"],
-      outdir: "./dist/cli",
-      platform: "node",
-      minify: false,
-      format: "esm",
-      bundle: true,
-      external: ["jsonv-ts", "jsonv-ts/*"],
-      define: {
-         __isDev: "0",
-         __version: JSON.stringify(pkg.version),
-      },
-   });
-   process.exit(0);
-}
+import { formatNumber } from "core/utils";

 const result = await Bun.build({
   entrypoints: ["./src/cli/index.ts"],
@@ -26,7 +8,6 @@ const result = await Bun.build({
   outdir: "./dist/cli",
   env: "PUBLIC_*",
   minify: true,
-   external: ["jsonv-ts", "jsonv-ts/*"],
   define: {
      __isDev: "0",
      __version: JSON.stringify(pkg.version),
@@ -1,7 +1,6 @@
 import { $ } from "bun";
 import * as tsup from "tsup";
 import pkg from "./package.json" with { type: "json" };
-import c from "picocolors";

 const args = process.argv.slice(2);
 const watch = args.includes("--watch");
@@ -10,14 +9,6 @@ const types = args.includes("--types");
 const sourcemap = args.includes("--sourcemap");
 const clean = args.includes("--clean");

-// silence tsup
-const oldConsole = {
-   log: console.log,
-   warn: console.warn,
-};
-console.log = () => {};
-console.warn = () => {};
-
 const define = {
   __isDev: "0",
   __version: JSON.stringify(pkg.version),
@@ -36,11 +27,11 @@ function buildTypes() {
   Bun.spawn(["bun", "build:types"], {
      stdout: "inherit",
      onExit: () => {
-         oldConsole.log(c.cyan("[Types]"), c.green("built"));
+         console.info("Types built");
         Bun.spawn(["bun", "tsc-alias"], {
            stdout: "inherit",
            onExit: () => {
-               oldConsole.log(c.cyan("[Types]"), c.green("aliased"));
+               console.info("Types aliased");
               types_running = false;
            },
         });
@@ -48,10 +39,6 @@ function buildTypes() {
   });
 }

-if (types && !watch) {
-   buildTypes();
-}
-
 let watcher_timeout: any;
 function delayTypes() {
   if (!watch || !types) return;
@@ -61,6 +48,17 @@ function delayTypes() {
   watcher_timeout = setTimeout(buildTypes, 1000);
 }

+if (types && !watch) {
+   buildTypes();
+}
+
+function banner(title: string) {
+   console.info("");
+   console.info("=".repeat(40));
+   console.info(title.toUpperCase());
+   console.info("-".repeat(40));
+}
+
 // collection of always-external packages
 const external = [
   "bun:test",
@@ -69,20 +67,26 @@ const external = [
   "@libsql/client",
   "bknd",
   /^bknd\/.*/,
-   "jsonv-ts",
-   /^jsonv-ts\/.*/,
 ] as const;

 /**
 * Building backend and general API
 */
 async function buildApi() {
+   banner("Building API");
   await tsup.build({
      minify,
      sourcemap,
      watch,
      define,
-      entry: ["src/index.ts", "src/core/utils/index.ts", "src/plugins/index.ts"],
+      entry: [
+         "src/index.ts",
+         "src/core/index.ts",
+         "src/core/utils/index.ts",
+         "src/data/index.ts",
+         "src/media/index.ts",
+         "src/plugins/index.ts",
+      ],
      outDir: "dist",
      external: [...external],
      metafile: true,
@@ -95,7 +99,6 @@ async function buildApi() {
      },
      onSuccess: async () => {
         delayTypes();
-         oldConsole.log(c.cyan("[API]"), c.green("built"));
      },
   });
 }
@@ -139,6 +142,7 @@ async function buildUi() {
      },
   } satisfies tsup.Options;

+   banner("Building UI");
   await tsup.build({
      ...base,
      entry: ["src/ui/index.ts", "src/ui/main.css", "src/ui/styles.css"],
@@ -146,10 +150,10 @@ async function buildUi() {
      onSuccess: async () => {
         await rewriteClient("./dist/ui/index.js");
         delayTypes();
-         oldConsole.log(c.cyan("[UI]"), c.green("built"));
      },
   });

+   banner("Building Client");
   await tsup.build({
      ...base,
      entry: ["src/ui/client/index.ts"],
@@ -157,7 +161,6 @@ async function buildUi() {
      onSuccess: async () => {
         await rewriteClient("./dist/ui/client/index.js");
         delayTypes();
-         oldConsole.log(c.cyan("[UI]"), "Client", c.green("built"));
      },
   });
 }
@@ -168,6 +171,7 @@ async function buildUi() {
 * - ui/client is external, and after built replaced with "bknd/client"
 */
 async function buildUiElements() {
+   banner("Building UI Elements");
   await tsup.build({
      minify,
      sourcemap,
@@ -201,7 +205,6 @@ async function buildUiElements() {
      onSuccess: async () => {
         await rewriteClient("./dist/ui/elements/index.js");
         delayTypes();
-         oldConsole.log(c.cyan("[UI]"), "Elements", c.green("built"));
      },
   });
 }
@@ -222,7 +225,6 @@ function baseConfig(adapter: string, overrides: Partial<tsup.Options> = {}): tsu
      splitting: false,
      onSuccess: async () => {
         delayTypes();
-         oldConsole.log(c.cyan("[Adapter]"), adapter || "base", c.green("built"));
      },
      ...overrides,
      define: {
@@ -241,75 +243,65 @@ function baseConfig(adapter: string, overrides: Partial<tsup.Options> = {}): tsu
 }

 async function buildAdapters() {
-   await Promise.all([
-      // base adapter handles
-      tsup.build({
-         ...baseConfig(""),
-         entry: ["src/adapter/index.ts"],
-         outDir: "dist/adapter",
-      }),
+   banner("Building Adapters");
+   // base adapter handles
+   await tsup.build({
+      ...baseConfig(""),
+      entry: ["src/adapter/index.ts"],
+      outDir: "dist/adapter",
+   });

-      // specific adatpers
-      tsup.build(baseConfig("react-router")),
-      tsup.build(
-         baseConfig("bun", {
-            external: [/^bun\:.*/],
-         }),
-      ),
-      tsup.build(baseConfig("astro")),
-      tsup.build(baseConfig("aws")),
-      tsup.build(
-         baseConfig("cloudflare", {
-            external: ["wrangler", "node:process"],
-         }),
-      ),
-      tsup.build(
-         baseConfig("cloudflare/proxy", {
-            entry: ["src/adapter/cloudflare/proxy.ts"],
-            outDir: "dist/adapter/cloudflare",
-            metafile: false,
-            external: [/bknd/, "wrangler", "node:process"],
-         }),
-      ),
-
-      tsup.build({
-         ...baseConfig("vite"),
-         platform: "node",
-      }),
-
-      tsup.build({
-         ...baseConfig("nextjs"),
-         platform: "node",
-      }),
-
-      tsup.build({
-         ...baseConfig("node"),
-         platform: "node",
-      }),
-
-      tsup.build({
-         ...baseConfig("sqlite/edge"),
-         entry: ["src/adapter/sqlite/edge.ts"],
-         outDir: "dist/adapter/sqlite",
-         metafile: false,
-      }),
-
-      tsup.build({
-         ...baseConfig("sqlite/node"),
-         entry: ["src/adapter/sqlite/node.ts"],
-         outDir: "dist/adapter/sqlite",
-         platform: "node",
-         metafile: false,
-      }),
-
-      tsup.build({
-         ...baseConfig("sqlite/bun"),
-         entry: ["src/adapter/sqlite/bun.ts"],
-         outDir: "dist/adapter/sqlite",
-         metafile: false,
+   // specific adatpers
+   await tsup.build(baseConfig("react-router"));
+   await tsup.build(
+      baseConfig("bun", {
         external: [/^bun\:.*/],
      }),
-   ]);
+   );
+   await tsup.build(baseConfig("astro"));
+   await tsup.build(baseConfig("aws"));
+   await tsup.build(baseConfig("cloudflare"));
+
+   await tsup.build({
+      ...baseConfig("vite"),
+      platform: "node",
+   });
+
+   await tsup.build({
+      ...baseConfig("nextjs"),
+      platform: "node",
+   });
+
+   await tsup.build({
+      ...baseConfig("node"),
+      platform: "node",
+   });
+
+   await tsup.build({
+      ...baseConfig("sqlite/edge"),
+      entry: ["src/adapter/sqlite/edge.ts"],
+      outDir: "dist/adapter/sqlite",
+      metafile: false,
+   });
+
+   await tsup.build({
+      ...baseConfig("sqlite/node"),
+      entry: ["src/adapter/sqlite/node.ts"],
+      outDir: "dist/adapter/sqlite",
+      platform: "node",
+      metafile: false,
+   });
+
+   await tsup.build({
+      ...baseConfig("sqlite/bun"),
+      entry: ["src/adapter/sqlite/bun.ts"],
+      outDir: "dist/adapter/sqlite",
+      metafile: false,
+      external: [/^bun\:.*/],
+   });
 }

-await Promise.all([buildApi(), buildUi(), buildUiElements(), buildAdapters()]);
+await buildApi();
+await buildUi();
+await buildUiElements();
+await buildAdapters();
@@ -2,5 +2,4 @@
 #registry = "http://localhost:4873"

 [test]
-coverageSkipTestFiles = true
-console.depth = 10
+coverageSkipTestFiles = true
@@ -1,35 +0,0 @@
-import { createApp } from "bknd/adapter/bun";
-
-async function generate() {
-   console.info("Generating MCP documentation...");
-   const app = await createApp({
-      initialConfig: {
-         server: {
-            mcp: {
-               enabled: true,
-            },
-         },
-         auth: {
-            enabled: true,
-         },
-         media: {
-            enabled: true,
-            adapter: {
-               type: "local",
-               config: {
-                  path: "./",
-               },
-            },
-         },
-      },
-   });
-   await app.build();
-
-   const res = await app.server.request("/mcp?explain=1");
-   const { tools, resources } = await res.json();
-   await Bun.write("../docs/mcp.json", JSON.stringify({ tools, resources }, null, 2));
-
-   console.info("MCP documentation generated.");
-}
-
-void generate();
@@ -3,7 +3,7 @@
  "type": "module",
  "sideEffects": false,
  "bin": "./dist/cli/index.js",
-  "version": "0.17.0",
+  "version": "0.16.0-rc.0",
  "description": "Lightweight Firebase/Supabase alternative built to run anywhere — incl. Next.js, React Router, Astro, Cloudflare, Bun, Node, AWS Lambda & more.",
  "homepage": "https://bknd.io",
  "repository": {
@@ -13,7 +13,6 @@
  "bugs": {
    "url": "https://github.com/bknd-io/bknd/issues"
  },
-  "packageManager": "bun@1.2.19",
  "engines": {
    "node": ">=22"
  },
@@ -39,12 +38,11 @@
    "test:adapters": "bun test src/adapter/**/*.adapter.spec.ts --bail",
    "test:coverage": "ALL_TESTS=1 bun test --bail --coverage",
    "test:vitest:coverage": "vitest run --coverage",
-    "test:e2e": "VITE_DB_URL=:memory: playwright test",
-    "test:e2e:adapters": "VITE_DB_URL=:memory: bun run e2e/adapters.ts",
-    "test:e2e:ui": "VITE_DB_URL=:memory: playwright test --ui",
-    "test:e2e:debug": "VITE_DB_URL=:memory: playwright test --debug",
-    "test:e2e:report": "VITE_DB_URL=:memory: playwright show-report",
-    "docs:build-assets": "bun internal/docs.build-assets.ts"
+    "test:e2e": "playwright test",
+    "test:e2e:adapters": "bun run e2e/adapters.ts",
+    "test:e2e:ui": "playwright test --ui",
+    "test:e2e:debug": "playwright test --debug",
+    "test:e2e:report": "playwright show-report"
  },
  "license": "FSL-1.1-MIT",
  "dependencies": {
@@ -62,11 +60,11 @@
    "bcryptjs": "^3.0.2",
    "dayjs": "^1.11.13",
    "fast-xml-parser": "^5.0.8",
-    "hono": "4.8.3",
+    "hono": "^4.7.11",
+    "json-schema-form-react": "^0.0.2",
    "json-schema-library": "10.0.0-rc7",
    "json-schema-to-ts": "^3.1.1",
-    "jsonv-ts": "0.8.2",
-    "kysely": "0.27.6",
+    "kysely": "^0.27.6",
    "lodash-es": "^4.17.21",
    "oauth4webapi": "^2.11.1",
    "object-path-immutable": "^4.1.2",
@@ -76,7 +74,6 @@
  "devDependencies": {
    "@aws-sdk/client-s3": "^3.758.0",
    "@bluwy/giget-core": "^0.1.2",
-    "@clack/prompts": "^0.11.0",
    "@cloudflare/vitest-pool-workers": "^0.8.38",
    "@cloudflare/workers-types": "^4.20250606.0",
    "@dagrejs/dagre": "^1.1.4",
@@ -103,6 +100,7 @@
    "dotenv": "^16.4.7",
    "jotai": "^2.12.2",
    "jsdom": "^26.0.0",
+    "jsonv-ts": "^0.2.2",
    "kysely-d1": "^0.3.0",
    "kysely-generic-sqlite": "^1.2.1",
    "libsql-stateless-easy": "^1.8.0",
@@ -163,6 +161,16 @@
      "import": "./dist/ui/client/index.js",
      "require": "./dist/ui/client/index.js"
    },
+    "./data": {
+      "types": "./dist/types/data/index.d.ts",
+      "import": "./dist/data/index.js",
+      "require": "./dist/data/index.js"
+    },
+    "./core": {
+      "types": "./dist/types/core/index.d.ts",
+      "import": "./dist/core/index.js",
+      "require": "./dist/core/index.js"
+    },
    "./utils": {
      "types": "./dist/types/core/utils/index.d.ts",
      "import": "./dist/core/utils/index.js",
@@ -173,6 +181,11 @@
      "import": "./dist/cli/index.js",
      "require": "./dist/cli/index.js"
    },
+    "./media": {
+      "types": "./dist/types/media/index.d.ts",
+      "import": "./dist/media/index.js",
+      "require": "./dist/media/index.js"
+    },
    "./plugins": {
      "types": "./dist/types/plugins/index.d.ts",
      "import": "./dist/plugins/index.js",
@@ -197,11 +210,6 @@
      "import": "./dist/adapter/cloudflare/index.js",
      "require": "./dist/adapter/cloudflare/index.js"
    },
-    "./adapter/cloudflare/proxy": {
-      "types": "./dist/types/adapter/cloudflare/proxy.d.ts",
-      "import": "./dist/adapter/cloudflare/proxy.js",
-      "require": "./dist/adapter/cloudflare/proxy.js"
-    },
    "./adapter": {
      "types": "./dist/types/adapter/index.d.ts",
      "import": "./dist/adapter/index.js"
@@ -243,13 +251,15 @@
    },
    "./dist/main.css": "./dist/ui/main.css",
    "./dist/styles.css": "./dist/ui/styles.css",
-    "./dist/manifest.json": "./dist/static/.vite/manifest.json",
-    "./static/*": "./dist/static/*"
+    "./dist/manifest.json": "./dist/static/.vite/manifest.json"
  },
  "typesVersions": {
    "*": {
+      "data": ["./dist/types/data/index.d.ts"],
+      "core": ["./dist/types/core/index.d.ts"],
      "utils": ["./dist/types/core/utils/index.d.ts"],
      "cli": ["./dist/types/cli/index.d.ts"],
+      "media": ["./dist/types/media/index.d.ts"],
      "plugins": ["./dist/types/plugins/index.d.ts"],
      "adapter": ["./dist/types/adapter/index.d.ts"],
      "adapter/cloudflare": ["./dist/types/adapter/cloudflare/index.d.ts"],
@@ -1,10 +1,10 @@
-import type { SafeUser } from "bknd";
+import type { SafeUser } from "auth";
 import { AuthApi, type AuthApiOptions } from "auth/api/AuthApi";
 import { DataApi, type DataApiOptions } from "data/api/DataApi";
 import { decode } from "hono/jwt";
 import { MediaApi, type MediaApiOptions } from "media/api/MediaApi";
 import { SystemApi } from "modules/SystemApi";
-import { omitKeys } from "bknd/utils";
+import { omitKeys } from "core/utils";
 import type { BaseModuleApiOptions } from "modules";

 export type TApiUser = SafeUser;
@@ -1,5 +1,5 @@
 import type { CreateUserPayload } from "auth/AppAuth";
-import { $console, McpClient } from "bknd/utils";
+import { $console } from "core/utils";
 import { Event } from "core/events";
 import type { em as prototypeEm } from "data/prototype";
 import { Connection } from "data/connection/Connection";
@@ -23,34 +23,13 @@ import type { IEmailDriver, ICacheDriver } from "core/drivers";
 import { Api, type ApiOptions } from "Api";

 export type AppPluginConfig = {
-   /**
-    * The name of the plugin.
-    */
   name: string;
-   /**
-    * The schema of the plugin.
-    */
   schema?: () => MaybePromise<ReturnType<typeof prototypeEm> | void>;
-   /**
-    * Called before the app is built.
-    */
   beforeBuild?: () => MaybePromise<void>;
-   /**
-    * Called after the app is built.
-    */
   onBuilt?: () => MaybePromise<void>;
-   /**
-    * Called when the server is initialized.
-    */
   onServerInit?: (server: Hono<ServerEnv>) => MaybePromise<void>;
-   /**
-    * Called when the app is booted.
-    */
-   onBoot?: () => MaybePromise<void>;
-   /**
-    * Called when the app is first booted.
-    */
   onFirstBoot?: () => MaybePromise<void>;
+   onBoot?: () => MaybePromise<void>;
 };
 export type AppPlugin = (app: App) => AppPluginConfig;

@@ -61,9 +40,6 @@ export class AppConfigUpdatedEvent extends AppEvent<{
 }> {
   static override slug = "app-config-updated";
 }
-/**
- * @type {Event<{ app: App }>}
- */
 export class AppBuiltEvent extends AppEvent {
   static override slug = "app-built";
 }
@@ -95,9 +71,6 @@ export type AppOptions = {
   };
 };
 export type CreateAppConfig = {
-   /**
-    * bla
-    */
   connection?: Connection | { url: string };
   initialConfig?: InitialModuleConfigs;
   options?: AppOptions;
@@ -117,7 +90,6 @@ export class App<C extends Connection = Connection, Options extends AppOptions =

   private trigger_first_boot = false;
   private _building: boolean = false;
-   private _systemController: SystemController | null = null;

   constructor(
      public connection: C,
@@ -190,12 +162,11 @@ export class App<C extends Connection = Connection, Options extends AppOptions =
      if (options?.sync) this.modules.ctx().flags.sync_required = true;
      await this.modules.build({ fetch: options?.fetch });

-      const { guard } = this.modules.ctx();
+      const { guard, server } = this.modules.ctx();

      // load system controller
      guard.registerPermissions(Object.values(SystemPermissions));
-      this._systemController = new SystemController(this);
-      this._systemController.register(this);
+      server.route("/api/system", new SystemController(this).getController());

      // emit built event
      $console.log("App built");
@@ -227,10 +198,6 @@ export class App<C extends Connection = Connection, Options extends AppOptions =
      return this.modules.ctx().em;
   }

-   get mcp() {
-      return this._systemController?._mcpServer;
-   }
-
   get fetch(): Hono["fetch"] {
      return this.server.fetch as any;
   }
@@ -289,18 +256,6 @@ export class App<C extends Connection = Connection, Options extends AppOptions =
      return new Api({ host: "http://localhost", ...(options ?? {}), fetcher });
   }

-   getMcpClient() {
-      if (!this.mcp) {
-         throw new Error("MCP is not enabled");
-      }
-      const mcpPath = this.modules.get("server").config.mcp.path;
-
-      return new McpClient({
-         url: "http://localhost" + mcpPath,
-         fetch: this.server.request,
-      });
-   }
-
   async onUpdated<Module extends keyof Modules>(module: Module, config: ModuleConfigs[Module]) {
      // if the EventManager was disabled, we assume we shouldn't
      // respond to events, such as "onUpdated".
@@ -3,15 +3,16 @@
 import path from "node:path";
 import { type RuntimeBkndConfig, createRuntimeApp, type RuntimeOptions } from "bknd/adapter";
 import { registerLocalMediaAdapter } from ".";
-import { config, type App } from "bknd";
+import { config } from "bknd/core";
 import type { ServeOptions } from "bun";
 import { serveStatic } from "hono/bun";
+import type { App } from "App";

 type BunEnv = Bun.Env;
 export type BunBkndConfig<Env = BunEnv> = RuntimeBkndConfig<Env> & Omit<ServeOptions, "fetch">;

 export async function createApp<Env = BunEnv>(
-   { distPath, serveStatic: _serveStatic, ...config }: BunBkndConfig<Env> = {},
+   { distPath, ...config }: BunBkndConfig<Env> = {},
   args: Env = {} as Env,
   opts?: RuntimeOptions,
 ) {
@@ -20,12 +21,8 @@ export async function createApp<Env = BunEnv>(

   return await createRuntimeApp(
      {
-         serveStatic:
-            _serveStatic ??
-            serveStatic({
-               root,
-            }),
         ...config,
+         serveStatic: serveStatic({ root }),
      },
      args ?? (process.env as Env),
      opts,
@@ -56,7 +53,6 @@ export function serve<Env = BunEnv>(
      onBuilt,
      buildConfig,
      adminOptions,
-      serveStatic,
      ...serveOptions
   }: BunBkndConfig<Env> = {},
   args: Env = {} as Env,
@@ -74,7 +70,6 @@ export function serve<Env = BunEnv>(
            buildConfig,
            adminOptions,
            distPath,
-            serveStatic,
         },
         args,
         opts,
@@ -1,5 +1,5 @@
 import { Database } from "bun:sqlite";
-import { genericSqlite, type GenericSqliteConnection } from "bknd";
+import { genericSqlite, type GenericSqliteConnection } from "bknd/data";

 export type BunSqliteConnection = GenericSqliteConnection<Database>;
 export type BunSqliteConnectionConfig = {
@@ -1,5 +1,3 @@
-import { inspect } from "node:util";
-
 export type BindingTypeMap = {
   D1Database: D1Database;
   KVNamespace: KVNamespace;
@@ -15,9 +13,8 @@ export function getBindings<T extends GetBindingType>(env: any, type: T): Bindin
   for (const key in env) {
      try {
         if (
-            (env[key] as any).constructor.name === type ||
-            String(env[key]) === `[object ${type}]` ||
-            inspect(env[key]).includes(type)
+            env[key] &&
+            ((env[key] as any).constructor.name === type || String(env[key]) === `[object ${type}]`)
         ) {
            bindings.push({
               key,
@@ -18,7 +18,7 @@ describe("cf adapter", () => {
   });

   it("makes config", async () => {
-      const staticConfig = await makeConfig(
+      const staticConfig = makeConfig(
         {
            connection: { url: DB_URL },
            initialConfig: { data: { basepath: DB_URL } },
@@ -28,7 +28,7 @@ describe("cf adapter", () => {
      expect(staticConfig.initialConfig).toEqual({ data: { basepath: DB_URL } });
      expect(staticConfig.connection).toBeDefined();

-      const dynamicConfig = await makeConfig(
+      const dynamicConfig = makeConfig(
         {
            app: (env) => ({
               initialConfig: { data: { basepath: env.DB_URL } },
@@ -5,8 +5,9 @@ import { Hono } from "hono";
 import { serveStatic } from "hono/cloudflare-workers";
 import { getFresh } from "./modes/fresh";
 import { getCached } from "./modes/cached";
-import type { App, MaybePromise } from "bknd";
-import { $console } from "bknd/utils";
+import { getDurable } from "./modes/durable";
+import type { App } from "bknd";
+import { $console } from "core/utils";

 declare global {
   namespace Cloudflare {
@@ -16,11 +17,12 @@ declare global {

 export type CloudflareEnv = Cloudflare.Env;
 export type CloudflareBkndConfig<Env = CloudflareEnv> = RuntimeBkndConfig<Env> & {
-   mode?: "warm" | "fresh" | "cache";
-   bindings?: (args: Env) => MaybePromise<{
+   mode?: "warm" | "fresh" | "cache" | "durable";
+   bindings?: (args: Env) => {
      kv?: KVNamespace;
+      dobj?: DurableObjectNamespace;
      db?: D1Database;
-   }>;
+   };
   d1?: {
      session?: boolean;
      transport?: "header" | "cookie";
@@ -91,6 +93,8 @@ export function serve<Env extends CloudflareEnv = CloudflareEnv>(
            case "cache":
               app = await getCached(config, context);
               break;
+            case "durable":
+               return await getDurable(config, context);
            default:
               throw new Error(`Unknown mode ${mode}`);
         }
@@ -1,16 +1,16 @@
 /// <reference types="@cloudflare/workers-types" />

-import { Connection } from "bknd";
-import { sqlite } from "bknd/adapter/sqlite";
-import { makeConfig as makeAdapterConfig } from "bknd/adapter";
 import { registerMedia } from "./storage/StorageR2Adapter";
 import { getBinding } from "./bindings";
 import { d1Sqlite } from "./connection/D1Connection";
+import { Connection } from "bknd/data";
 import type { CloudflareBkndConfig, CloudflareEnv } from ".";
 import { App } from "bknd";
+import { makeConfig as makeAdapterConfig } from "bknd/adapter";
 import type { Context, ExecutionContext } from "hono";
-import { $console } from "bknd/utils";
+import { $console } from "core/utils";
 import { setCookie } from "hono/cookie";
+import { sqlite } from "bknd/adapter/sqlite";

 export const constants = {
   exec_async_event_id: "cf_register_waituntil",
@@ -89,7 +89,7 @@ export function d1SessionHelper(config: CloudflareBkndConfig<any>) {
 }

 let media_registered: boolean = false;
-export async function makeConfig<Env extends CloudflareEnv = CloudflareEnv>(
+export function makeConfig<Env extends CloudflareEnv = CloudflareEnv>(
   config: CloudflareBkndConfig<Env>,
   args?: CfMakeConfigArgs<Env>,
 ) {
@@ -102,7 +102,7 @@ export async function makeConfig<Env extends CloudflareEnv = CloudflareEnv>(
      media_registered = true;
   }

-   const appConfig = await makeAdapterConfig(config, args?.env);
+   const appConfig = makeAdapterConfig(config, args?.env);

   // if connection instance is given, don't do anything
   // other than checking if D1 session is defined
@@ -115,12 +115,12 @@ export async function makeConfig<Env extends CloudflareEnv = CloudflareEnv>(
      }
      // if connection is given, try to open with unified sqlite adapter
   } else if (appConfig.connection) {
-      appConfig.connection = sqlite(appConfig.connection) as any;
+      appConfig.connection = sqlite(appConfig.connection);

      // if connection is not given, but env is set
      // try to make D1 from bindings
   } else if (args?.env) {
-      const bindings = await config.bindings?.(args?.env);
+      const bindings = config.bindings?.(args?.env);
      const sessionHelper = d1SessionHelper(config);
      const sessionId = sessionHelper.get(args.request);
      let session: D1DatabaseSession | undefined;
@@ -1,6 +1,6 @@
 /// <reference types="@cloudflare/workers-types" />

-import { genericSqlite, type GenericSqliteConnection } from "bknd";
+import { genericSqlite, type GenericSqliteConnection } from "bknd/data";
 import type { QueryResult } from "kysely";

 export type D1SqliteConnection = GenericSqliteConnection<D1Database>;
@@ -1,18 +1,18 @@
 /// <reference types="@cloudflare/workers-types" />

-import { genericSqlite, type GenericSqliteConnection } from "bknd";
+import { genericSqlite, type GenericSqliteConnection } from "bknd/data";
 import type { QueryResult } from "kysely";

-export type DoSqliteConnection = GenericSqliteConnection<DurableObjectState["storage"]["sql"]>;
+export type D1SqliteConnection = GenericSqliteConnection<D1Database>;
 export type DurableObjecSql = DurableObjectState["storage"]["sql"];

-export type DoConnectionConfig<DB extends DurableObjecSql> =
+export type D1ConnectionConfig<DB extends DurableObjecSql> =
   | DurableObjectState
   | {
        sql: DB;
     };

-export function doSqlite<DB extends DurableObjecSql>(config: DoConnectionConfig<DB>) {
+export function doSqlite<DB extends DurableObjecSql>(config: D1ConnectionConfig<DB>) {
   const db = "sql" in config ? config.sql : config.storage.sql;

   return genericSqlite(
@@ -21,7 +21,7 @@ export function doSqlite<DB extends DurableObjecSql>(config: DoConnectionConfig<
      (utils) => {
         // must be async to work with the miniflare mock
         const getStmt = async (sql: string, parameters?: any[] | readonly any[]) =>
-            db.exec(sql, ...(parameters || []));
+            await db.exec(sql, ...(parameters || []));

         const mapResult = (
            cursor: SqlStorageCursor<Record<string, SqlStorageValue>>,
@@ -3,8 +3,8 @@ import { d1Sqlite, type D1ConnectionConfig } from "./connection/D1Connection";
 export * from "./cloudflare-workers.adapter";
 export { makeApp, getFresh } from "./modes/fresh";
 export { getCached } from "./modes/cached";
+export { DurableBkndApp, getDurable } from "./modes/durable";
 export { d1Sqlite, type D1ConnectionConfig };
-export { doSqlite, type DoConnectionConfig } from "./connection/DoConnection";
 export {
   getBinding,
   getBindings,
@@ -15,7 +15,6 @@ export {
 export { constants } from "./config";
 export { StorageR2Adapter, registerMedia } from "./storage/StorageR2Adapter";
 export { registries } from "bknd";
-export { devFsVitePlugin, devFsWrite } from "./vite";

 // for compatibility with old code
 export function d1<DB extends D1Database | D1DatabaseSession = D1Database>(
@@ -8,7 +8,7 @@ export async function getCached<Env extends CloudflareEnv = CloudflareEnv>(
   args: Context<Env>,
 ) {
   const { env, ctx } = args;
-   const { kv } = await config.bindings?.(env)!;
+   const { kv } = config.bindings?.(env)!;
   if (!kv) throw new Error("kv namespace is not defined in cloudflare.bindings");
   const key = config.key ?? "app";

@@ -0,0 +1,134 @@
+import { DurableObject } from "cloudflare:workers";
+import type { App, CreateAppConfig } from "bknd";
+import { createRuntimeApp, makeConfig } from "bknd/adapter";
+import type { CloudflareBkndConfig, Context, CloudflareEnv } from "../index";
+import { constants, registerAsyncsExecutionContext } from "../config";
+import { $console } from "core/utils";
+
+export async function getDurable<Env extends CloudflareEnv = CloudflareEnv>(
+   config: CloudflareBkndConfig<Env>,
+   ctx: Context<Env>,
+) {
+   const { dobj } = config.bindings?.(ctx.env)!;
+   if (!dobj) throw new Error("durable object is not defined in cloudflare.bindings");
+   const key = config.key ?? "app";
+
+   if ([config.onBuilt, config.beforeBuild].some((x) => x)) {
+      $console.warn("onBuilt and beforeBuild are not supported with DurableObject mode");
+   }
+
+   const start = performance.now();
+
+   const id = dobj.idFromName(key);
+   const stub = dobj.get(id) as unknown as DurableBkndApp;
+
+   const create_config = makeConfig(config, ctx.env);
+
+   const res = await stub.fire(ctx.request, {
+      config: create_config,
+      keepAliveSeconds: config.keepAliveSeconds,
+   });
+
+   const headers = new Headers(res.headers);
+   headers.set("X-TTDO", String(performance.now() - start));
+
+   return new Response(res.body, {
+      status: res.status,
+      statusText: res.statusText,
+      headers,
+   });
+}
+
+export class DurableBkndApp extends DurableObject {
+   protected id = Math.random().toString(36).slice(2);
+   protected app?: App;
+   protected interval?: any;
+
+   async fire(
+      request: Request,
+      options: {
+         config: CreateAppConfig;
+         html?: string;
+         keepAliveSeconds?: number;
+         setAdminHtml?: boolean;
+      },
+   ) {
+      let buildtime = 0;
+      if (!this.app) {
+         const start = performance.now();
+         const config = options.config;
+
+         // change protocol to websocket if libsql
+         if (
+            config?.connection &&
+            "type" in config.connection &&
+            config.connection.type === "libsql"
+         ) {
+            //config.connection.config.protocol = "wss";
+         }
+
+         this.app = await createRuntimeApp({
+            ...config,
+            onBuilt: async (app) => {
+               registerAsyncsExecutionContext(app, this.ctx);
+               app.modules.server.get(constants.do_endpoint, async (c) => {
+                  // @ts-ignore
+                  const context: any = c.req.raw.cf ? c.req.raw.cf : c.env.cf;
+                  return c.json({
+                     id: this.id,
+                     keepAliveSeconds: options?.keepAliveSeconds ?? 0,
+                     colo: context.colo,
+                  });
+               });
+
+               await this.onBuilt(app);
+            },
+            adminOptions: { html: options.html },
+            beforeBuild: async (app) => {
+               await this.beforeBuild(app);
+            },
+         });
+
+         buildtime = performance.now() - start;
+      }
+
+      if (options?.keepAliveSeconds) {
+         this.keepAlive(options.keepAliveSeconds);
+      }
+
+      const res = await this.app!.fetch(request);
+      const headers = new Headers(res.headers);
+      headers.set("X-BuildTime", buildtime.toString());
+      headers.set("X-DO-ID", this.id);
+
+      return new Response(res.body, {
+         status: res.status,
+         statusText: res.statusText,
+         headers,
+      });
+   }
+
+   async onBuilt(app: App) {}
+
+   async beforeBuild(app: App) {}
+
+   protected keepAlive(seconds: number) {
+      if (this.interval) {
+         clearInterval(this.interval);
+      }
+
+      let i = 0;
+      this.interval = setInterval(() => {
+         i += 1;
+         if (i === seconds) {
+            console.log("cleared");
+            clearInterval(this.interval);
+
+            // ping every 30 seconds
+         } else if (i % 30 === 0) {
+            console.log("ping");
+            this.app?.modules.ctx().connection.ping();
+         }
+      }, 1000);
+   }
+}
@@ -7,7 +7,7 @@ export async function makeApp<Env extends CloudflareEnv = CloudflareEnv>(
   args?: CfMakeConfigArgs<Env>,
   opts?: RuntimeOptions,
 ) {
-   return await createRuntimeApp<Env>(await makeConfig(config, args), args?.env, opts);
+   return await createRuntimeApp<Env>(makeConfig(config, args), args?.env, opts);
 }

 export async function getFresh<Env extends CloudflareEnv = CloudflareEnv>(
@@ -1,67 +0,0 @@
-import {
-   d1Sqlite,
-   getBinding,
-   registerMedia,
-   type CloudflareBkndConfig,
-   type CloudflareEnv,
-} from "bknd/adapter/cloudflare";
-import type { PlatformProxy } from "wrangler";
-import process from "node:process";
-
-export type WithPlatformProxyOptions = {
-   /**
-    * By default, proxy is used if the PROXY environment variable is set to 1.
-    * You can override/force this by setting this option.
-    */
-   useProxy?: boolean;
-};
-
-export function withPlatformProxy<Env extends CloudflareEnv>(
-   config?: CloudflareBkndConfig<Env>,
-   opts?: WithPlatformProxyOptions,
-) {
-   const use_proxy =
-      typeof opts?.useProxy === "boolean" ? opts.useProxy : process.env.PROXY === "1";
-   let proxy: PlatformProxy | undefined;
-
-   async function getEnv(env?: Env): Promise<Env> {
-      if (use_proxy) {
-         if (!proxy) {
-            const getPlatformProxy = await import("wrangler").then((mod) => mod.getPlatformProxy);
-            proxy = await getPlatformProxy();
-            setTimeout(proxy?.dispose, 1000);
-         }
-         return proxy.env as unknown as Env;
-      }
-      return env || ({} as Env);
-   }
-
-   return {
-      ...config,
-      beforeBuild: async (app, registries) => {
-         if (!use_proxy) return;
-         const env = await getEnv();
-         registerMedia(env, registries as any);
-         await config?.beforeBuild?.(app, registries);
-      },
-      bindings: async (env) => {
-         return (await config?.bindings?.(await getEnv(env))) || {};
-      },
-      // @ts-ignore
-      app: async (_env) => {
-         const env = await getEnv(_env);
-
-         if (config?.app === undefined && use_proxy) {
-            const binding = getBinding(env, "D1Database");
-            return {
-               connection: d1Sqlite({
-                  binding: binding.value,
-               }),
-            };
-         } else if (typeof config?.app === "function") {
-            return config?.app(env);
-         }
-         return config?.app || {};
-      },
-   } satisfies CloudflareBkndConfig<Env>;
-}
@@ -1,7 +1,8 @@
-import { registries as $registries, isDebug, guessMimeType } from "bknd";
+import { registries } from "bknd";
+import { isDebug } from "bknd/core";
+import { guessMimeType as guess, StorageAdapter, type FileBody } from "bknd/media";
 import { getBindings } from "../bindings";
-import { s } from "bknd/utils";
-import { StorageAdapter, type FileBody } from "bknd";
+import { s } from "bknd/core";

 export function makeSchema(bindings: string[] = []) {
   return s.object(
@@ -12,10 +13,7 @@ export function makeSchema(bindings: string[] = []) {
   );
 }

-export function registerMedia(
-   env: Record<string, any>,
-   registries: typeof $registries = $registries,
-) {
+export function registerMedia(env: Record<string, any>) {
   const r2_bindings = getBindings(env, "R2Bucket");

   registries.media.register(
@@ -92,7 +90,7 @@ export class StorageR2Adapter extends StorageAdapter {

      const responseHeaders = new Headers({
         "Accept-Ranges": "bytes",
-         "Content-Type": guessMimeType(key),
+         "Content-Type": guess(key),
      });

      const range = headers.has("range");
@@ -144,7 +142,7 @@ export class StorageR2Adapter extends StorageAdapter {
      if (!metadata || Object.keys(metadata).length === 0) {
         // guessing is especially required for dev environment (miniflare)
         metadata = {
-            contentType: guessMimeType(object.key),
+            contentType: guess(object.key),
         };
      }

@@ -161,7 +159,7 @@ export class StorageR2Adapter extends StorageAdapter {
      }

      return {
-         type: String(head.httpMetadata?.contentType ?? guessMimeType(key)),
+         type: String(head.httpMetadata?.contentType ?? guess(key)),
         size: head.size,
      };
   }
@@ -1,135 +0,0 @@
-import type { Plugin } from "vite";
-import { writeFile as nodeWriteFile } from "node:fs/promises";
-import { resolve } from "node:path";
-
-/**
- * Vite plugin that provides Node.js filesystem access during development
- * by injecting a polyfill into the SSR environment
- */
-export function devFsVitePlugin({
-   verbose = false,
-   configFile = "bknd.config.ts",
-}: {
-   verbose?: boolean;
-   configFile?: string;
-}): Plugin {
-   let isDev = false;
-   let projectRoot = "";
-
-   return {
-      name: "dev-fs-plugin",
-      enforce: "pre",
-      configResolved(config) {
-         isDev = config.command === "serve";
-         projectRoot = config.root;
-      },
-      configureServer(server) {
-         if (!isDev) return;
-
-         // Intercept stdout to watch for our write requests
-         const originalStdoutWrite = process.stdout.write;
-         process.stdout.write = function (chunk: any, encoding?: any, callback?: any) {
-            const output = chunk.toString();
-
-            // Check if this output contains our special write request
-            if (output.includes("{{DEV_FS_WRITE_REQUEST}}")) {
-               try {
-                  // Extract the JSON from the log line
-                  const match = output.match(/{{DEV_FS_WRITE_REQUEST}} ({.*})/);
-                  if (match) {
-                     const writeRequest = JSON.parse(match[1]);
-                     if (writeRequest.type === "DEV_FS_WRITE_REQUEST") {
-                        if (verbose) {
-                           console.debug("[dev-fs-plugin] Intercepted write request via stdout");
-                        }
-
-                        // Process the write request immediately
-                        (async () => {
-                           try {
-                              const fullPath = resolve(projectRoot, writeRequest.filename);
-                              await nodeWriteFile(fullPath, writeRequest.data);
-                              if (verbose) {
-                                 console.debug("[dev-fs-plugin] File written successfully!");
-                              }
-                           } catch (error) {
-                              console.error("[dev-fs-plugin] Error writing file:", error);
-                           }
-                        })();
-
-                        // Don't output the raw write request to console
-                        return true;
-                     }
-                  }
-               } catch (error) {
-                  // Not a valid write request, continue with normal output
-               }
-            }
-
-            // @ts-ignore
-            // biome-ignore lint:
-            return originalStdoutWrite.apply(process.stdout, arguments);
-         };
-
-         // Restore stdout when server closes
-         server.httpServer?.on("close", () => {
-            process.stdout.write = originalStdoutWrite;
-         });
-      },
-      // @ts-ignore
-      transform(code, id, options) {
-         // Only transform in SSR mode during development
-         if (!isDev || !options?.ssr) return;
-
-         // Check if this is the bknd config file
-         if (id.includes(configFile)) {
-            if (verbose) {
-               console.debug("[dev-fs-plugin] Transforming", configFile);
-            }
-
-            // Inject our filesystem polyfill at the top of the file
-            const polyfill = `
-// Dev-fs polyfill injected by vite-plugin-dev-fs
-if (typeof globalThis !== 'undefined') {
-  globalThis.__devFsPolyfill = {
-    writeFile: async (filename, data) => {
-      ${verbose ? "console.debug('dev-fs polyfill: Intercepting write request for', filename);" : ""}
-      
-      // Use console logging as a communication channel
-      // The main process will watch for this specific log pattern
-      const writeRequest = {
-        type: 'DEV_FS_WRITE_REQUEST',
-        filename: filename,
-        data: data,
-        timestamp: Date.now()
-      };
-      
-      // Output as a specially formatted console message
-      console.log('{{DEV_FS_WRITE_REQUEST}}', JSON.stringify(writeRequest));
-      ${verbose ? "console.debug('dev-fs polyfill: Write request sent via console');" : ""}
-      
-      return Promise.resolve();
-    }
-  };
-}
-`;
-            return polyfill + code;
-         }
-      },
-   };
-}
-
-// Write function that uses the dev-fs polyfill injected by our Vite plugin
-export async function devFsWrite(filename: string, data: string): Promise<void> {
-   try {
-      // Check if the dev-fs polyfill is available (injected by our Vite plugin)
-      if (typeof globalThis !== "undefined" && (globalThis as any).__devFsPolyfill) {
-         return (globalThis as any).__devFsPolyfill.writeFile(filename, data);
-      }
-
-      // Fallback to Node.js fs for other environments (Node.js, Bun)
-      const { writeFile } = await import("node:fs/promises");
-      return writeFile(filename, data);
-   } catch (error) {
-      console.error("[dev-fs-write] Error writing file:", error);
-   }
-}
@@ -1,21 +1,16 @@
-import {
-   config as $config,
-   App,
-   type CreateAppConfig,
-   Connection,
-   guessMimeType,
-   type MaybePromise,
-   registries as $registries,
-} from "bknd";
+import { App, type CreateAppConfig } from "bknd";
+import { config as $config } from "bknd/core";
 import { $console } from "bknd/utils";
-import type { Context, MiddlewareHandler, Next } from "hono";
+import type { MiddlewareHandler } from "hono";
 import type { AdminControllerOptions } from "modules/server/AdminController";
-import type { Manifest } from "vite";
+import { Connection } from "bknd/data";
+
+export { Connection } from "bknd/data";

 export type BkndConfig<Args = any> = CreateAppConfig & {
-   app?: CreateAppConfig | ((args: Args) => MaybePromise<CreateAppConfig>);
+   app?: CreateAppConfig | ((args: Args) => CreateAppConfig);
   onBuilt?: (app: App) => Promise<void>;
-   beforeBuild?: (app: App, registries?: typeof $registries) => Promise<void>;
+   beforeBuild?: (app: App) => Promise<void>;
   buildConfig?: Parameters<App["build"]>[0];
 };

@@ -38,10 +33,10 @@ export type DefaultArgs = {
   [key: string]: any;
 };

-export async function makeConfig<Args = DefaultArgs>(
+export function makeConfig<Args = DefaultArgs>(
   config: BkndConfig<Args>,
   args?: Args,
-): Promise<CreateAppConfig> {
+): CreateAppConfig {
   let additionalConfig: CreateAppConfig = {};
   const { app, ...rest } = config;
   if (app) {
@@ -49,7 +44,7 @@ export async function makeConfig<Args = DefaultArgs>(
         if (!args) {
            throw new Error("args is required when config.app is a function");
         }
-         additionalConfig = await app(args);
+         additionalConfig = app(args);
      } else {
         additionalConfig = app;
      }
@@ -68,16 +63,16 @@ export async function createAdapterApp<Config extends BkndConfig = BkndConfig, A
   const id = opts?.id ?? "app";
   let app = apps.get(id);
   if (!app || opts?.force) {
-      const appConfig = await makeConfig(config, args);
+      const appConfig = makeConfig(config, args);
      if (!appConfig.connection || !Connection.isConnection(appConfig.connection)) {
         let connection: Connection | undefined;
         if (Connection.isConnection(config.connection)) {
            connection = config.connection;
         } else {
            const sqlite = (await import("bknd/adapter/sqlite")).sqlite;
-            const conf = appConfig.connection ?? { url: ":memory:" };
-            connection = sqlite(conf) as any;
-            $console.info(`Using ${connection!.name} connection`, conf.url);
+            const conf = config.connection ?? { url: ":memory:" };
+            connection = sqlite(conf);
+            $console.info(`Using ${connection.name} connection`, conf.url);
         }
         appConfig.connection = connection;
      }
@@ -106,7 +101,7 @@ export async function createFrameworkApp<Args = DefaultArgs>(
         );
      }

-      await config.beforeBuild?.(app, $registries);
+      await config.beforeBuild?.(app);
      await app.build(config.buildConfig);
   }

@@ -139,60 +134,9 @@ export async function createRuntimeApp<Args = DefaultArgs>(
         "sync",
      );

-      await config.beforeBuild?.(app, $registries);
+      await config.beforeBuild?.(app);
      await app.build(config.buildConfig);
   }

   return app;
 }
-
-/**
- * Creates a middleware handler to serve static assets via dynamic imports.
- * This is useful for environments where filesystem access is limited but bundled assets can be imported.
- *
- * @param manifest - Vite manifest object containing asset information
- * @returns Hono middleware handler for serving static assets
- *
- * @example
- * ```typescript
- * import { serveStaticViaImport } from "bknd/adapter";
- *
- * serve({
- *   serveStatic: serveStaticViaImport(),
- * });
- * ```
- */
-export function serveStaticViaImport(opts?: { manifest?: Manifest }) {
-   let files: string[] | undefined;
-
-   // @ts-ignore
-   return async (c: Context, next: Next) => {
-      if (!files) {
-         const manifest =
-            opts?.manifest || ((await import("bknd/dist/manifest.json")).default as Manifest);
-         files = Object.values(manifest).flatMap((asset) => [asset.file, ...(asset.css || [])]);
-      }
-
-      const path = c.req.path.substring(1);
-      if (files.includes(path)) {
-         try {
-            const content = await import(/* @vite-ignore */ `bknd/static/${path}?raw`, {
-               assert: { type: "text" },
-            }).then((m) => m.default);
-
-            if (content) {
-               return c.body(content, {
-                  headers: {
-                     "Content-Type": guessMimeType(path),
-                     "Cache-Control": "public, max-age=31536000, immutable",
-                  },
-               });
-            }
-         } catch (e) {
-            console.error("Error serving static file:", e);
-            return c.text("File not found", 404);
-         }
-      }
-      await next();
-   };
-}
@@ -1,4 +1,4 @@
-import { genericSqlite } from "bknd";
+import { genericSqlite } from "bknd/data";
 import { DatabaseSync } from "node:sqlite";

 export type NodeSqliteConnectionConfig = {
@@ -3,8 +3,9 @@ import { serve as honoServe } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { registerLocalMediaAdapter } from "adapter/node/storage";
 import { type RuntimeBkndConfig, createRuntimeApp, type RuntimeOptions } from "bknd/adapter";
-import { config as $config, type App } from "bknd";
-import { $console } from "bknd/utils";
+import { config as $config } from "bknd/core";
+import { $console } from "core/utils";
+import type { App } from "App";

 type NodeEnv = NodeJS.ProcessEnv;
 export type NodeBkndConfig<Env = NodeEnv> = RuntimeBkndConfig<Env> & {
@@ -31,8 +32,8 @@ export async function createApp<Env = NodeEnv>(
   registerLocalMediaAdapter();
   return await createRuntimeApp(
      {
-         serveStatic: serveStatic({ root }),
         ...config,
+         serveStatic: serveStatic({ root }),
      },
      // @ts-ignore
      args ?? { env: process.env },
@@ -1,7 +1,8 @@
 import { readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
-import type { FileBody, FileListObject, FileMeta, FileUploadPayload } from "bknd";
-import { StorageAdapter, guessMimeType } from "bknd";
-import { parse, s, isFile } from "bknd/utils";
+import { isFile } from "bknd/utils";
+import type { FileBody, FileListObject, FileMeta, FileUploadPayload } from "bknd/media";
+import { StorageAdapter, guessMimeType as guess } from "bknd/media";
+import { parse, s } from "bknd/core";

 export const localAdapterConfig = s.object(
   {
@@ -83,7 +84,7 @@ export class StorageLocalAdapter extends StorageAdapter {
   async getObject(key: string, headers: Headers): Promise<Response> {
      try {
         const content = await readFile(`${this.config.path}/${key}`);
-         const mimeType = guessMimeType(key);
+         const mimeType = guess(key);

         return new Response(content, {
            status: 200,
@@ -105,7 +106,7 @@ export class StorageLocalAdapter extends StorageAdapter {
   async getObjectMeta(key: string): Promise<FileMeta> {
      const stats = await stat(`${this.config.path}/${key}`);
      return {
-         type: guessMimeType(key) || "application/octet-stream",
+         type: guess(key) || "application/octet-stream",
         size: stats.size,
      };
   }
@@ -1,4 +1,4 @@
-import type { Connection } from "bknd";
+import type { Connection } from "bknd/data";
 import { bunSqlite } from "../bun/connection/BunSqliteConnection";

 export function sqlite(config?: { url: string }): Connection {
@@ -1,4 +1,4 @@
-import { type Connection, libsql } from "bknd";
+import { type Connection, libsql } from "bknd/data";

 export function sqlite(config: { url: string }): Connection {
   return libsql(config);
@@ -1,4 +1,4 @@
-import type { Connection } from "bknd";
+import type { Connection } from "bknd/data";
 import { nodeSqlite } from "../node/connection/NodeSqliteConnection";

 export function sqlite(config?: { url: string }): Connection {
@@ -1,9 +1,8 @@
-import type { DB, PrimaryFieldType } from "bknd";
-import * as AuthPermissions from "auth/auth-permissions";
-import type { AuthStrategy } from "auth/authenticate/strategies/Strategy";
-import type { PasswordStrategy } from "auth/authenticate/strategies/PasswordStrategy";
-import { $console, secureRandomString, transformObject } from "bknd/utils";
-import type { Entity, EntityManager } from "data/entities";
+import { Authenticator, AuthPermissions, Role, type Strategy } from "auth";
+import type { PasswordStrategy } from "auth/authenticate/strategies";
+import type { DB } from "core";
+import { $console, secureRandomString, transformObject } from "core/utils";
+import type { Entity, EntityManager } from "data";
 import { em, entity, enumm, type FieldSchema } from "data/prototype";
 import { Module } from "modules/Module";
 import { AuthController } from "./api/AuthController";
@@ -11,12 +10,9 @@ import { type AppAuthSchema, authConfigSchema, STRATEGIES } from "./auth-schema"
 import { AppUserPool } from "auth/AppUserPool";
 import type { AppEntity } from "core/config";
 import { usersFields } from "./auth-entities";
-import { Authenticator } from "./authenticate/Authenticator";
-import { Role } from "./authorize/Role";

-export type UsersFields = typeof AppAuth.usersFields;
 export type UserFieldSchema = FieldSchema<typeof AppAuth.usersFields>;
-declare module "bknd" {
+declare module "core" {
   interface Users extends AppEntity, UserFieldSchema {}
   interface DB {
      users: Users;
@@ -88,12 +84,11 @@ export class AppAuth extends Module<AppAuthSchema> {
      super.setBuilt();

      this._controller = new AuthController(this);
-      this._controller.registerMcp();
      this.ctx.server.route(this.config.basepath, this._controller.getController());
      this.ctx.guard.registerPermissions(AuthPermissions);
   }

-   isStrategyEnabled(strategy: AuthStrategy | string) {
+   isStrategyEnabled(strategy: Strategy | string) {
      const name = typeof strategy === "string" ? strategy : strategy.getName();
      // for now, password is always active
      if (name === "password") return true;
@@ -178,32 +173,6 @@ export class AppAuth extends Module<AppAuthSchema> {
      return created;
   }

-   async changePassword(userId: PrimaryFieldType, newPassword: string) {
-      const users_entity = this.config.entity_name as "users";
-      const { data: user } = await this.em.repository(users_entity).findId(userId);
-      if (!user) {
-         throw new Error("User not found");
-      } else if (user.strategy !== "password") {
-         throw new Error("User is not using password strategy");
-      }
-
-      const togglePw = (visible: boolean) => {
-         const field = this.em.entity(users_entity).field("strategy_value")!;
-
-         field.config.hidden = !visible;
-         field.config.fillable = visible;
-      };
-
-      const pw = this.authenticator.strategy("password" as const) as PasswordStrategy;
-      togglePw(true);
-      await this.em.mutator(users_entity).updateOne(user.id, {
-         strategy_value: await pw.hash(newPassword),
-      });
-      togglePw(false);
-
-      return true;
-   }
-
   override toJSON(secrets?: boolean): AppAuthSchema {
      if (!this.config.enabled) {
         return this.configDefault;
@@ -1,6 +1,6 @@
 import { AppAuth } from "auth/AppAuth";
 import type { CreateUser, SafeUser, User, UserPool } from "auth/authenticate/Authenticator";
-import { $console } from "bknd/utils";
+import { $console } from "core/utils";
 import { pick } from "lodash-es";
 import {
   InvalidConditionsException,
@@ -1,6 +1,6 @@
 import type { AuthActionResponse } from "auth/api/AuthController";
 import type { AppAuthSchema } from "auth/auth-schema";
-import type { AuthResponse, SafeUser, AuthStrategy } from "bknd";
+import type { AuthResponse, SafeUser, Strategy } from "auth/authenticate/Authenticator";
 import { type BaseModuleApiOptions, ModuleApi } from "modules/ModuleApi";

 export type AuthApiOptions = BaseModuleApiOptions & {
@@ -39,7 +39,7 @@ export class AuthApi extends ModuleApi<AuthApiOptions> {
   }

   async actionSchema(strategy: string, action: string) {
-      return this.get<AuthStrategy>([strategy, "actions", action, "schema.json"]);
+      return this.get<Strategy>([strategy, "actions", action, "schema.json"]);
   }

   async action(strategy: string, action: string, input: any) {
@@ -1,20 +1,9 @@
-import type { DB, SafeUser } from "bknd";
-import type { AuthStrategy } from "auth/authenticate/strategies/Strategy";
-import type { AppAuth } from "auth/AppAuth";
-import * as AuthPermissions from "auth/auth-permissions";
-import * as DataPermissions from "data/permissions";
+import { type AppAuth, AuthPermissions, type SafeUser, type Strategy } from "auth";
+import { transformObject } from "core/utils";
+import { DataPermissions } from "data";
 import type { Hono } from "hono";
 import { Controller, type ServerEnv } from "modules/Controller";
-import {
-   describeRoute,
-   jsc,
-   s,
-   parse,
-   InvalidSchemaError,
-   transformObject,
-   mcpTool,
-} from "bknd/utils";
-import type { PasswordStrategy } from "auth/authenticate/strategies";
+import { describeRoute, jsc, s, parse, InvalidSchemaError } from "bknd/core";

 export type AuthActionResponse = {
   success: boolean;
@@ -41,7 +30,7 @@ export class AuthController extends Controller {
      return this.em.repo(entity_name as "users");
   }

-   private registerStrategyActions(strategy: AuthStrategy, mainHono: Hono<ServerEnv>) {
+   private registerStrategyActions(strategy: Strategy, mainHono: Hono<ServerEnv>) {
      if (!this.auth.isStrategyEnabled(strategy)) {
         return;
      }
@@ -127,9 +116,6 @@ export class AuthController extends Controller {
            summary: "Get the current user",
            tags: ["auth"],
         }),
-         mcpTool("auth_me", {
-            noErrorCodes: [403],
-         }),
         auth(),
         async (c) => {
            const claims = c.get("auth")?.user;
@@ -171,7 +157,6 @@ export class AuthController extends Controller {
            summary: "Get the available authentication strategies",
            tags: ["auth"],
         }),
-         mcpTool("auth_strategies"),
         jsc("query", s.object({ include_disabled: s.boolean().optional() })),
         async (c) => {
            const { include_disabled } = c.req.valid("query");
@@ -201,119 +186,4 @@ export class AuthController extends Controller {

      return hono;
   }
-
-   override registerMcp(): void {
-      const { mcp } = this.auth.ctx;
-      const idType = s.anyOf([s.number({ title: "Integer" }), s.string({ title: "UUID" })]);
-
-      const getUser = async (params: { id?: string | number; email?: string }) => {
-         let user: DB["users"] | undefined = undefined;
-         if (params.id) {
-            const { data } = await this.userRepo.findId(params.id);
-            user = data;
-         } else if (params.email) {
-            const { data } = await this.userRepo.findOne({ email: params.email });
-            user = data;
-         }
-         if (!user) {
-            throw new Error("User not found");
-         }
-         return user;
-      };
-
-      mcp.tool(
-         // @todo: needs permission
-         "auth_user_create",
-         {
-            description: "Create a new user",
-            inputSchema: s.object({
-               email: s.string({ format: "email" }),
-               password: s.string({ minLength: 8 }),
-               role: s
-                  .string({
-                     enum: Object.keys(this.auth.config.roles ?? {}),
-                  })
-                  .optional(),
-            }),
-         },
-         async (params, c) => {
-            await c.context.ctx().helper.throwUnlessGranted(AuthPermissions.createUser, c);
-
-            return c.json(await this.auth.createUser(params));
-         },
-      );
-
-      mcp.tool(
-         // @todo: needs permission
-         "auth_user_token",
-         {
-            description: "Get a user token",
-            inputSchema: s.object({
-               id: idType.optional(),
-               email: s.string({ format: "email" }).optional(),
-            }),
-         },
-         async (params, c) => {
-            await c.context.ctx().helper.throwUnlessGranted(AuthPermissions.createToken, c);
-
-            const user = await getUser(params);
-            return c.json({ user, token: await this.auth.authenticator.jwt(user) });
-         },
-      );
-
-      mcp.tool(
-         // @todo: needs permission
-         "auth_user_password_change",
-         {
-            description: "Change a user's password",
-            inputSchema: s.object({
-               id: idType.optional(),
-               email: s.string({ format: "email" }).optional(),
-               password: s.string({ minLength: 8 }),
-            }),
-         },
-         async (params, c) => {
-            await c.context.ctx().helper.throwUnlessGranted(AuthPermissions.changePassword, c);
-
-            const user = await getUser(params);
-            if (!(await this.auth.changePassword(user.id, params.password))) {
-               throw new Error("Failed to change password");
-            }
-            return c.json({ changed: true });
-         },
-      );
-
-      mcp.tool(
-         // @todo: needs permission
-         "auth_user_password_test",
-         {
-            description: "Test a user's password",
-            inputSchema: s.object({
-               email: s.string({ format: "email" }),
-               password: s.string({ minLength: 8 }),
-            }),
-         },
-         async (params, c) => {
-            await c.context.ctx().helper.throwUnlessGranted(AuthPermissions.testPassword, c);
-
-            const pw = this.auth.authenticator.strategy("password") as PasswordStrategy;
-            const controller = pw.getController(this.auth.authenticator);
-
-            const res = await controller.request(
-               new Request("https://localhost/login", {
-                  method: "POST",
-                  headers: {
-                     "Content-Type": "application/json",
-                  },
-                  body: JSON.stringify({
-                     email: params.email,
-                     password: params.password,
-                  }),
-               }),
-            );
-
-            return c.json({ valid: res.ok });
-         },
-      );
-   }
 }
@@ -1,7 +1,4 @@
-import { Permission } from "core/security/Permission";
+import { Permission } from "core";

 export const createUser = new Permission("auth.user.create");
 //export const updateUser = new Permission("auth.user.update");
-export const testPassword = new Permission("auth.user.password.test");
-export const changePassword = new Permission("auth.user.password.change");
-export const createToken = new Permission("auth.user.token.create");
@@ -1,7 +1,7 @@
 import { cookieConfig, jwtConfig } from "auth/authenticate/Authenticator";
 import { CustomOAuthStrategy, OAuthStrategy, PasswordStrategy } from "auth/authenticate/strategies";
-import { objectTransform, s } from "bknd/utils";
-import { $object, $record } from "modules/mcp";
+import { objectTransform } from "core/utils";
+import { s } from "bknd/core";

 export const Strategies = {
   password: {
@@ -46,8 +46,7 @@ export const guardRoleSchema = s.strictObject({
   implicit_allow: s.boolean().optional(),
 });

-export const authConfigSchema = $object(
-   "config_auth",
+export const authConfigSchema = s.strictObject(
   {
      enabled: s.boolean({ default: false }),
      basepath: s.string({ default: "/api/auth" }),
@@ -55,29 +54,20 @@ export const authConfigSchema = $object(
      allow_register: s.boolean({ default: true }).optional(),
      jwt: jwtConfig,
      cookie: cookieConfig,
-      strategies: $record(
-         "config_auth_strategies",
-         strategiesSchema,
-         {
-            title: "Strategies",
-            default: {
-               password: {
-                  type: "password",
-                  enabled: true,
-                  config: {
-                     hashing: "sha256",
-                  },
+      strategies: s.record(strategiesSchema, {
+         title: "Strategies",
+         default: {
+            password: {
+               type: "password",
+               enabled: true,
+               config: {
+                  hashing: "sha256",
               },
            },
         },
-         s.strictObject({
-            type: s.string(),
-            enabled: s.boolean({ default: true }).optional(),
-            config: s.object({}),
-         }),
-      ),
+      }),
      guard: guardConfigSchema.optional(),
-      roles: $record("config_auth_roles", guardRoleSchema, { default: {} }).optional(),
+      roles: s.record(guardRoleSchema, { default: {} }).optional(),
   },
   { title: "Authentication" },
 );
@@ -1,16 +1,14 @@
-import type { DB } from "bknd";
-import { Exception } from "core/errors";
+import { type DB, Exception } from "core";
 import { addFlashMessage } from "core/server/flash";
-import type { Context } from "hono";
+import { runtimeSupports, truncate, $console } from "core/utils";
+import type { Context, Hono } from "hono";
 import { deleteCookie, getSignedCookie, setSignedCookie } from "hono/cookie";
 import { sign, verify } from "hono/jwt";
-import { type CookieOptions, serializeSigned } from "hono/utils/cookie";
+import type { CookieOptions } from "hono/utils/cookie";
 import type { ServerEnv } from "modules/Controller";
 import { pick } from "lodash-es";
 import { InvalidConditionsException } from "auth/errors";
-import { s, parse, secret, runtimeSupports, truncate, $console } from "bknd/utils";
-import { $object } from "modules/mcp";
-import type { AuthStrategy } from "./strategies/Strategy";
+import { s, parse, secret } from "bknd/core";

 type Input = any; // workaround
 export type JWTPayload = Parameters<typeof sign>[0];
@@ -23,6 +21,17 @@ export type StrategyAction<S extends s.ObjectSchema = s.ObjectSchema> = {
 };
 export type StrategyActions = Partial<Record<StrategyActionName, StrategyAction>>;

+// @todo: add schema to interface to ensure proper inference
+// @todo: add tests (e.g. invalid strategy_value)
+export interface Strategy {
+   getController: (auth: Authenticator) => Hono<any>;
+   getType: () => string;
+   getMode: () => "form" | "external";
+   getName: () => string;
+   toJSON: (secrets?: boolean) => any;
+   getActions?: () => StrategyActions;
+}
+
 export type User = DB["users"];

 export type ProfileExchange = {
@@ -43,35 +52,37 @@ export interface UserPool {

 const defaultCookieExpires = 60 * 60 * 24 * 7; // 1 week in seconds
 export const cookieConfig = s
-   .strictObject({
+   .object({
      path: s.string({ default: "/" }),
      sameSite: s.string({ enum: ["strict", "lax", "none"], default: "lax" }),
      secure: s.boolean({ default: true }),
      httpOnly: s.boolean({ default: true }),
      expires: s.number({ default: defaultCookieExpires }), // seconds
-      partitioned: s.boolean({ default: false }),
      renew: s.boolean({ default: true }),
      pathSuccess: s.string({ default: "/" }),
      pathLoggedOut: s.string({ default: "/" }),
   })
-   .partial();
+   .partial()
+   .strict();

 // @todo: maybe add a config to not allow cookie/api tokens to be used interchangably?
 // see auth.integration test for further details

-export const jwtConfig = s.strictObject(
-   {
-      secret: secret({ default: "" }),
-      alg: s.string({ enum: ["HS256", "HS384", "HS512"], default: "HS256" }).optional(),
-      expires: s.number().optional(), // seconds
-      issuer: s.string().optional(),
-      fields: s.array(s.string(), { default: ["id", "email", "role"] }),
-   },
-   {
-      default: {},
-   },
-);
-
+export const jwtConfig = s
+   .object(
+      {
+         // @todo: autogenerate a secret if not present. But it must be persisted from AppAuth
+         secret: secret({ default: "" }),
+         alg: s.string({ enum: ["HS256", "HS384", "HS512"], default: "HS256" }).optional(),
+         expires: s.number().optional(), // seconds
+         issuer: s.string().optional(),
+         fields: s.array(s.string(), { default: ["id", "email", "role"] }),
+      },
+      {
+         default: {},
+      },
+   )
+   .strict();
 export const authenticatorConfig = s.object({
   jwt: jwtConfig,
   cookie: cookieConfig,
@@ -86,7 +97,7 @@ export type AuthResolveOptions = {
 };
 export type AuthUserResolver = (
   action: AuthAction,
-   strategy: AuthStrategy,
+   strategy: Strategy,
   profile: ProfileExchange,
   opts?: AuthResolveOptions,
 ) => Promise<ProfileExchange | undefined>;
@@ -96,9 +107,7 @@ type AuthClaims = SafeUser & {
   exp?: number;
 };

-export class Authenticator<
-   Strategies extends Record<string, AuthStrategy> = Record<string, AuthStrategy>,
-> {
+export class Authenticator<Strategies extends Record<string, Strategy> = Record<string, Strategy>> {
   private readonly config: AuthConfig;

   constructor(
@@ -111,7 +120,7 @@ export class Authenticator<

   async resolveLogin(
      c: Context,
-      strategy: AuthStrategy,
+      strategy: Strategy,
      profile: Partial<SafeUser>,
      verify: (user: User) => Promise<void>,
      opts?: AuthResolveOptions,
@@ -149,7 +158,7 @@ export class Authenticator<

   async resolveRegister(
      c: Context,
-      strategy: AuthStrategy,
+      strategy: Strategy,
      profile: CreateUser,
      verify: (user: User) => Promise<void>,
      opts?: AuthResolveOptions,
@@ -208,7 +217,7 @@ export class Authenticator<

      await addFlashMessage(c, String(error), "error");

-      const referer = this.getSafeUrl(c, c.req.header("Referer") ?? "/");
+      const referer = this.getSafeUrl(c, opts?.redirect ?? c.req.header("Referer") ?? "/");
      return c.redirect(referer);
   }

@@ -218,7 +227,7 @@ export class Authenticator<

   strategy<
      StrategyName extends keyof Strategies,
-      Strat extends AuthStrategy = Strategies[StrategyName],
+      Strat extends Strategy = Strategies[StrategyName],
   >(strategy: StrategyName): Strat {
      try {
         return this.strategies[strategy] as unknown as Strat;
@@ -325,11 +334,6 @@ export class Authenticator<
      await setSignedCookie(c, "auth", token, secret, this.cookieOptions);
   }

-   async unsafeGetAuthCookie(token: string): Promise<string | undefined> {
-      // this works for as long as cookieOptions.prefix is not set
-      return serializeSigned("auth", token, this.config.jwt.secret, this.cookieOptions);
-   }
-
   private deleteAuthCookie(c: Context) {
      $console.debug("deleting auth cookie");
      deleteCookie(c, "auth", this.cookieOptions);
@@ -376,28 +380,13 @@ export class Authenticator<
   }

   // @todo: don't extract user from token, but from the database or cache
-   async resolveAuthFromRequest(c: Context | Request | Headers): Promise<SafeUser | undefined> {
-      let headers: Headers;
-      let is_context = false;
-      if (c instanceof Headers) {
-         headers = c;
-      } else if (c instanceof Request) {
-         headers = c.headers;
-      } else {
-         is_context = true;
-         try {
-            headers = c.req.raw.headers;
-         } catch (e) {
-            throw new Exception("Request/Headers/Context is required to resolve auth", 400);
-         }
-      }
-
+   async resolveAuthFromRequest(c: Context): Promise<SafeUser | undefined> {
      let token: string | undefined;
-      if (headers.has("Authorization")) {
-         const bearerHeader = String(headers.get("Authorization"));
+      if (c.req.raw.headers.has("Authorization")) {
+         const bearerHeader = String(c.req.header("Authorization"));
         token = bearerHeader.replace("Bearer ", "");
-      } else if (is_context) {
-         token = await this.getAuthCookie(c as Context);
+      } else {
+         token = await this.getAuthCookie(c);
      }

      if (token) {
@@ -1,10 +1,9 @@
-import type { User } from "bknd";
-import type { Authenticator } from "auth/authenticate/Authenticator";
-import { InvalidCredentialsException } from "auth/errors";
-import { hash, $console, s, parse, jsc } from "bknd/utils";
+import { type Authenticator, InvalidCredentialsException, type User } from "auth";
+import { hash, $console } from "core/utils";
 import { Hono } from "hono";
 import { compare as bcryptCompare, genSalt as bcryptGenSalt, hash as bcryptHash } from "bcryptjs";
-import { AuthStrategy } from "./Strategy";
+import { Strategy } from "./Strategy";
+import { s, parse, jsc } from "bknd/core";

 const schema = s
   .object({
@@ -15,7 +14,7 @@ const schema = s

 export type PasswordStrategyOptions = s.Static<typeof schema>;

-export class PasswordStrategy extends AuthStrategy<typeof schema> {
+export class PasswordStrategy extends Strategy<typeof schema> {
   constructor(config: Partial<PasswordStrategyOptions> = {}) {
      super(config as any, "password", "password", "form");

@@ -5,11 +5,11 @@ import type {
   StrategyActions,
 } from "../Authenticator";
 import type { Hono } from "hono";
-import { type s, parse } from "bknd/utils";
+import { type s, parse } from "bknd/core";

 export type StrategyMode = "form" | "external";

-export abstract class AuthStrategy<Schema extends s.Schema = s.Schema> {
+export abstract class Strategy<Schema extends s.Schema = s.Schema> {
   protected actions: StrategyActions = {};

   constructor(
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
dswbx	7e25d54847	mm: added diff event + plugin to write down diffs	2025-07-08 09:54:56 +02:00
dswbx	9d5bc61f33	fix schema modals	2025-07-07 16:45:38 +02:00
dswbx	ea46dc8df0	fix schema modals	2025-07-07 16:38:39 +02:00
dswbx	88ec3432a0	fix schema import path	2025-07-07 16:09:29 +02:00
dswbx	43c8f14470	fix jsonv literal on Field.tsx	2025-07-07 08:41:06 +02:00
dswbx	c384bf4dd4	remove unneeded vite dep	2025-07-05 14:17:26 +02:00
dswbx	db2a994a01	Merge pull request #192 from bknd-io/feat/jsonv-refactor feat/jsonv-refactor	2025-07-05 14:02:22 +02:00
dswbx	166ea4a71b	removed @sinclair/typebox	2025-07-05 13:57:36 +02:00
dswbx	0d3bb3b7d6	added validator for rjsf, hook form via standard schema	2025-07-05 13:29:30 +02:00
dswbx	cfbec5b6ea	Merge remote-tracking branch 'origin/main' into feat/jsonv-refactor # Conflicts: # bun.lock	2025-07-05 11:11:06 +02:00
dswbx	5143ee5726	updated schemas, fixed tests, skipping flow tests for now	2025-07-03 14:00:29 +02:00
dswbx	fe1716ed01	fix secret schema	2025-07-02 17:59:38 +02:00
dswbx	0c31dcdb95	updated lock	2025-07-02 17:58:47 +02:00
dswbx	4cc0f8e172	Merge branch 'release/0.15' into feat/jsonv-refactor # Conflicts: # app/build.ts # app/package.json # app/src/App.ts # app/src/adapter/cloudflare/storage/StorageR2Adapter.ts # app/src/auth/authenticate/Authenticator.ts # app/src/auth/authenticate/strategies/PasswordStrategy.ts # app/src/data/entities/Entity.ts # app/src/data/fields/DateField.ts # app/src/data/server/query.ts # app/src/flows/flows/triggers/EventTrigger.ts # app/src/flows/tasks/presets/LogTask.ts # app/src/media/AppMedia.ts # app/src/modules/server/AppServer.ts # app/src/modules/server/SystemController.ts # app/vite.dev.ts # bun.lock	2025-07-02 17:18:12 +02:00
dswbx	c161a26ec0	test secrets extraction	2025-06-25 07:49:39 +02:00
dswbx	6e78a4c238	fixes	2025-06-21 17:05:27 +02:00
dswbx	42edce904f	initial refactor	2025-06-21 13:35:58 +02:00