@asterflow/fs 1.0.8 → 2.0.0

package/README.md

@@ -2,120 +2,70 @@
 
 # @asterflow/fs
 
-![license-info](https://img.shields.io/github/license/AsterFlow/plugins?style=for-the-badge&colorA=302D41&colorB=f9e2af&logoColor=f9e2af)
-![stars-info](https://img.shields.io/github/stars/AsterFlow/plugins?colorA=302D41&colorB=f9e2af&style=for-the-badge)
+![license-info](https://img.shields.io/github/license/AsterFlow/AsterFlow?style=for-the-badge&colorA=302D41&colorB=f9e2af&logoColor=f9e2af)
+![stars-info](https://img.shields.io/github/stars/AsterFlow/AsterFlow?colorA=302D41&colorB=f9e2af&style=for-the-badge)
+![last-commit](https://img.shields.io/github/last-commit/AsterFlow/AsterFlow?path=plugins%2Ffs&style=for-the-badge&colorA=302D41&colorB=b4befe)
+
 ![bundle-size](https://img.shields.io/bundlejs/size/@asterflow/fs?style=for-the-badge&colorA=302D41&colorB=3ac97b)
 
 </div>
 
-> Roteamento baseado em convenções de sistema de arquivos para o AsterFlow.
+> Generates a static route manifest from a file-based `routes/` directory and registers it on an AsterFlow app as a plugin.
 
 ## 📦 Installation
 
 ```bash
-# You can use any package manager
-npm install @asterflow/fs
-```
-
-## 💡 About
-
-`@asterflow/fs` brings the convenience of file system-based routing to your AsterFlow projects. Inspired by modern web frameworks, this plugin automatically discovers and registers your routes based on the file and directory structure, allowing you to focus on writing your API logic instead of manual route configuration.
-
-## ✨ Features
-
-  - **Convention over Configuration:** Automatically generates API routes from your file structure.
-  - **Dynamic Parameters:** Support for dynamic segments in filenames (e.g., `$id.ts`).
-  - **Index Routes:** `index.ts` files are treated as the base route of a directory.
-  - **Type-Safe:** Fully integrated with AsterFlow's type system.
-  - **Seamless Integration:** Automatically registers all discovered routes before the server starts.
-
-## 🚀 Usage
-
-### 1\. Project Structure
-
-Create a directory to store your route files. By convention, this directory is usually `routes/` or `src/routes/`.
-
+bun install @asterflow/fs
 ```
-.
-├── routes/
-│   ├── index.ts          # Handles GET /
-│   ├── users/
-│   │   ├── index.ts      # Handles GET /users
-│   │   └── $id.ts        # Handles GET /users/:id
-├── src
-│   └── index.ts          # Your main application file
-└── package.json
-```
-
-### 2\. Define Your Routes
 
-Each route file must have a `default export` of an AsterFlow `Method` or `Router`.
+Register the plugin with a generated route manifest:
 
-**`src/routes/users/$id.ts`**
+```ts
+import { AsterFlow } from 'asterflow'
+import { fsRoutingPlugin } from '@asterflow/fs'
+import routes from './routes.gen'
 
-```typescript
-import { Method } from '@asterflow/router';
-
-export default new Method({
-  // The 'path' property will be overwritten by the plugin,
-  // but can be useful for isolated testing.
-  path: '/',
-  method: 'get',
-  handler({ response, url }) {
-    // 'id' will be available at runtime
-    const params = url.getParams();
-    return response.success({ user: { id: params.id } });
-  }
-});
+const app = new AsterFlow()
+  .use(fsRoutingPlugin, { routes })
 ```
 
-### 3\. Register the Plugin
+### ✨ Features
 
-In your main application file, import and register the `fsRouting` plugin.
+- **Static manifest, not runtime scanning**: `generateRouteManifest` walks a routes directory once and writes a file with one literal `import` per route plus a default-exported array - a bundler can follow these imports, unlike the old `await import(dynamicPath)` approach.
+- **File-to-URL conventions**: `index.ts` becomes `/`, `users/index.ts` becomes `/users`, and a `$`-prefixed segment like `$id.ts` becomes a `:id` param.
+- **Auto path assignment**: in the generated manifest, any route whose `default export` has no explicit `path` gets one assigned from its file location.
+- **Safe registration**: `fsRoutingPlugin` registers every entry in `routes` with `instance.controller(route)` on `beforeInitialize`, and skips (with a warning) any entry that isn't a `Method`/`Router` instance instead of throwing.
 
-**`src/index.ts`**
+## ❓ How to Use
 
-```typescript
-import { AsterFlow } from 'asterflow';
-import { fsRouting } from '@asterflow/fs';
-import { join } from 'path';
+Generate the manifest ahead of time, usually via the `asterflow generate` CLI command, or by calling the generator directly from a build script:
 
-// Register the plugin and point it to your routes directory
-export const app = new AsterFlow();
-  .use(fsRouting, {
-    path: join(process.cwd(), 'src', 'routes')
-  });
+```ts
+import { generateRouteManifest } from '@asterflow/fs'
 
-// Start the server
-app.listen({ port: 3333 }, () => {
-  console.log('Server running with file system routing!');
-});
+await generateRouteManifest({
+  routesDir: './src/routes',
+  outFile: './src/routes.gen.ts'
+})
 ```
 
-That's it\! The plugin will scan the `src/routes` directory and register all valid route files when the application starts.
-
-## 🗺️ Routing Conventions
+Route files just export a `Method` or `Router` - the `path` is filled in by the generator from the file's location, so `src/routes/users/$id.ts` becomes `/users/:id`:
 
-The plugin transforms file paths into URL routes based on the following rules:
+```ts
+// src/routes/users/$id.ts
+import { Method } from '@asterflow/router'
 
-| File Path | Generated Route |
-| ----------------- | ------------------ |
-| `index.ts` | `/` |
-| `users.ts` | `/users` |
-| `users/index.ts` | `/users` |
-| `$id.ts` | `/:id` |
-| `products/$id.ts` | `/products/:id` |
-| `categories/$categoryId/products/$productId.ts` | `/categories/:categoryId/products/:productId` |
-
-  - Files named `index` become the root of their directory.
-  - Filenames prefixed with `$` (e.g., `$id.ts`) are converted to dynamic URL parameters (e.g., `/:id`).
+export default new Method(Method.GET, {
+  handler: ({ url, response }) => response.success({ id: url.getParams().id })
+})
+```
 
 ## 🔗 Related Packages
 
-  - [asterflow](https://www.npmjs.com/package/asterflow) - The core of the AsterFlow framework.
-  - [@asterflow/plugin](https://www.npmjs.com/package/@asterflow/plugin) - The main plugin system.
-  - [@asterflow/router](https://www.npmjs.com/package/@asterflow/router) - The type-safe routing system used by this plugin.
+- [@asterflow/plugin](https://www.npmjs.com/package/@asterflow/plugin) - builds `fsRoutingPlugin` via `Plugin.create()`.
+- [@asterflow/router](https://www.npmjs.com/package/@asterflow/router) - provides the `Method`/`Router` classes that route files export and that the plugin registers.
+- Depended on by `@asterflow/cli` - its `generate` command calls this package's `generateRouteManifest` to produce the route manifest.
 
 ## 📄 License
 
-MIT - See the main project [LICENSE](https://github.com/AsterFlow/AsterFlow/blob/main/LICENSE) for more details.
+This project is licensed under the [MIT License](../../LICENSE).

package/dist/cjs/index.cjs

@@ -1,52 +1,31 @@
 "use strict";
-var p = Object.defineProperty;
-var h = Object.getOwnPropertyDescriptor;
-var w = Object.getOwnPropertyNames;
-var R = Object.prototype.hasOwnProperty;
-var v = (t, o) => {
-  for (var r in o)
-    p(t, r, { get: o[r], enumerable: !0 });
-}, F = (t, o, r, e) => {
-  if (o && typeof o == "object" || typeof o == "function")
-    for (let s of w(o))
-      !R.call(t, s) && s !== r && p(t, s, { get: () => o[s], enumerable: !(e = h(o, s)) || e.enumerable });
-  return t;
+var f = Object.defineProperty;
+var T = Object.getOwnPropertyDescriptor;
+var P = Object.getOwnPropertyNames;
+var S = Object.prototype.hasOwnProperty;
+var O = (e, r) => {
+  for (var s in r)
+    f(e, s, { get: r[s], enumerable: !0 });
+}, I = (e, r, s, t) => {
+  if (r && typeof r == "object" || typeof r == "function")
+    for (let o of P(r))
+      !S.call(e, o) && o !== s && f(e, o, { get: () => r[o], enumerable: !(t = T(r, o)) || t.enumerable });
+  return e;
 };
-var j = (t) => F(p({}, "__esModule", { value: !0 }), t);
-
+var M = (e) => I(f({}, "__esModule", { value: !0 }), e);
 // plugins/fs/src/index.ts
-var P = {};
-v(P, {
-  default: () => T,
-  fsRoutingPlugin: () => y,
-  getFilesRecursively: () => n,
-  transformPathToUrl: () => u
+var _ = {};
+O(_, {
+  default: () => D,
+  fsRoutingPlugin: () => F,
+  generateRouteManifest: () => U,
+  getFilesRecursively: () => c,
+  transformPathToUrl: () => m
 });
-module.exports = j(P);
-var x = require("@asterflow/plugin"), a = require("@asterflow/router");
-
+module.exports = M(_);
+var $ = require("@asterflow/plugin"), u = require("@asterflow/router");
 // plugins/fs/package.json
-var f = "1.0.8";
-
-// plugins/fs/src/utils/format.ts
-var d = require("path");
-function u(t, o) {
-  let e = (0, d.relative)(o, t).replace(/\.(ts|js)$/, "");
-  return e.endsWith("/index") ? e = e.slice(0, -6) : e === "index" && (e = ""), e = e.replace(/\$/g, ":"), `/${e}`;
-}
-
-// plugins/fs/src/utils/glob.ts
-var g = require("fs/promises"), m = require("path");
-async function n(t) {
-  let o = await (0, g.readdir)(t, { withFileTypes: !0 });
-  return (await Promise.all(
-    o.map(async (e) => {
-      let s = (0, m.join)(t, e.name);
-      return e.isDirectory() ? n(s) : s;
-    })
-  )).flat();
-}
-
+var y = "2.0.0";
 // plugins/fs/src/utils/log.ts
 var l = {
   reset: "\x1B[0m",
@@ -54,42 +33,75 @@ var l = {
   yellow: "\x1B[33m",
   cyan: "\x1B[36m"
 };
-function c(t, o) {
-  console.warn(`${l.yellow}%s %s${l.reset}`, "[AsterFlow]", t), console.group();
-  for (let [r, e] of Object.entries(o))
-    console.log(`${l.cyan}%s:${l.reset} %s`, r, e);
+function w(e, r) {
+  console.warn(`${l.yellow}%s %s${l.reset}`, "[AsterFlow]", e), console.group();
+  for (let [s, t] of Object.entries(r))
+    console.log(`${l.cyan}%s:${l.reset} %s`, s, t);
   console.groupEnd(), console.log();
 }
-
+// plugins/fs/src/utils/codegen.ts
+var p = require("fs/promises"), i = require("path");
+// plugins/fs/src/utils/format.ts
+var h = require("path");
+function m(e, r) {
+  let t = (0, h.relative)(r, e).replace(/\.(ts|js)$/, "");
+  return t.endsWith("/index") ? t = t.slice(0, -6) : t === "index" && (t = ""), t = t.replace(/\$/g, ":"), `/${t}`;
+}
+// plugins/fs/src/utils/glob.ts
+var R = require("fs/promises"), j = require("path");
+async function c(e) {
+  let r = await (0, R.readdir)(e, { withFileTypes: !0 });
+  return (await Promise.all(
+    r.map(async (t) => {
+      let o = (0, j.join)(e, t.name);
+      return t.isDirectory() ? c(o) : o;
+    })
+  )).flat();
+}
+// plugins/fs/src/utils/codegen.ts
+var N =  new Set([".ts", ".tsx", ".js", ".jsx"]);
+async function U({ routesDir: e, outFile: r }) {
+  let t = (await c(e)).filter((n) => N.has((0, i.extname)(n)) && !n.endsWith(".d.ts")).sort(), o = (0, i.dirname)(r), g = [], d = [], x = [];
+  t.forEach((n, v) => {
+    let a = `Route${v}`, E = A((0, i.relative)(o, n)), k = m(n, e);
+    g.push(`import ${a} from '${E}'`), d.push(`if (!${a}.path) ${a}.path = ${JSON.stringify(k)}`), x.push(a);
+  });
+  let b = [
+    "
+    `
+    ...g,
+    "",
+    ...d,
+    "",
+    `export default [${x.join(", ")}]`,
+    ""
+  ].join(`
+`);
+  await (0, p.mkdir)(o, { recursive: !0 }), await (0, p.writeFile)(r, b);
+}
+function A(e) {
+  let s = e.replace(/\.(ts|tsx|js|jsx)$/, "").split(i.sep).join("/");
+  return s.startsWith(".") ? s : `./${s}`;
+}
 // plugins/fs/src/index.ts
-var y = x.Plugin.create({ name: "fs-routing" }).decorate("creator", "Ashu11-A").decorate("version", f).config({ path: "" }).derive("files", async (t) => await n(t.path)).extends((t, o) => ({
-  async registerRoutes(r) {
-    if (r.files.length !== 0)
-      for (let e of r.files) {
-        let i = (await import(e)).default;
-        if (!i) {
-          c("File Skipped: No Default Export", {
-            File: e,
-            Reason: "The file does not contain any default exported routes (export default).",
-            Solution: 'Ensure the file has a "export default new Router()" or similar.'
-          });
-          continue;
-        }
-        if (!(i instanceof a.Method || i instanceof a.Router)) {
-          c("File Skipped: Invalid Export Type", {
-            File: e,
-            "Exported Type": typeof i,
-            Reason: "The file does not export a known class instance (e.g., Router, Method)."
-          });
-          continue;
-        }
-        i.path || (i.path = u(e, r.path)), t.controller(i);
+var F = $.Plugin.create({ name: "fs-routing" }).decorate("creator", "Ashu11-A").decorate("version", y).config({ routes: [] }).extends((e, r) => ({
+  registerRoutes(s) {
+    for (let t of s.routes) {
+      if (!(t instanceof u.Method || t instanceof u.Router)) {
+        w("Route Skipped: Invalid Entry", {
+          "Exported Type": typeof t,
+          Reason: "An entry in the generated route manifest is not a Router/Method instance.",
+          Solution: "Re-run `asterflow generate` - if the problem persists, check the route file's default export."
+        });
+        continue;
       }
+      e.controller(t);
+    }
   }
-})).on("beforeInitialize", async (t, o) => await t.registerRoutes(o)), T = y;
-// Annotate the CommonJS export names for ESM import in node:
+})).on("beforeInitialize", (e, r) => e.registerRoutes(r)), D = F;
 0 && (module.exports = {
   fsRoutingPlugin,
+  generateRouteManifest,
   getFilesRecursively,
   transformPathToUrl
 });

package/dist/mjs/index.js

@@ -1,73 +1,87 @@
 // plugins/fs/src/index.ts
-import { Plugin as x } from "@asterflow/plugin";
-import { Method as y, Router as h } from "@asterflow/router";
-
+import { Plugin as O } from "@asterflow/plugin";
+import { Method as I, Router as M } from "@asterflow/router";
 // plugins/fs/package.json
-var p = "1.0.8";
-
+var f = "2.0.0";
+// plugins/fs/src/utils/log.ts
+var a = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m"
+};
+function m(t, r) {
+  console.warn(`${a.yellow}%s %s${a.reset}`, "[AsterFlow]", t), console.group();
+  for (let [s, e] of Object.entries(r))
+    console.log(`${a.cyan}%s:${a.reset} %s`, s, e);
+  console.groupEnd(), console.log();
+}
+// plugins/fs/src/utils/codegen.ts
+import { mkdir as v, writeFile as E } from "fs/promises";
+import { dirname as k, extname as T, relative as d, sep as P } from "path";
 // plugins/fs/src/utils/format.ts
-import { relative as d } from "path";
-function u(t, o) {
-  let e = d(o, t).replace(/\.(ts|js)$/, "");
+import { relative as $ } from "path";
+function g(t, r) {
+  let e = $(r, t).replace(/\.(ts|js)$/, "");
   return e.endsWith("/index") ? e = e.slice(0, -6) : e === "index" && (e = ""), e = e.replace(/\$/g, ":"), `/${e}`;
 }
-
 // plugins/fs/src/utils/glob.ts
-import { readdir as g } from "fs/promises";
-import { join as m } from "path";
+import { readdir as F } from "fs/promises";
+import { join as b } from "path";
 async function l(t) {
-  let o = await g(t, { withFileTypes: !0 });
+  let r = await F(t, { withFileTypes: !0 });
   return (await Promise.all(
-    o.map(async (e) => {
-      let n = m(t, e.name);
-      return e.isDirectory() ? l(n) : n;
+    r.map(async (e) => {
+      let o = b(t, e.name);
+      return e.isDirectory() ? l(o) : o;
     })
   )).flat();
 }
-
-// plugins/fs/src/utils/log.ts
-var i = {
-  reset: "\x1B[0m",
-  red: "\x1B[31m",
-  yellow: "\x1B[33m",
-  cyan: "\x1B[36m"
-};
-function a(t, o) {
-  console.warn(`${i.yellow}%s %s${i.reset}`, "[AsterFlow]", t), console.group();
-  for (let [r, e] of Object.entries(o))
-    console.log(`${i.cyan}%s:${i.reset} %s`, r, e);
-  console.groupEnd(), console.log();
+// plugins/fs/src/utils/codegen.ts
+var S =  new Set([".ts", ".tsx", ".js", ".jsx"]);
+async function B({ routesDir: t, outFile: r }) {
+  let e = (await l(t)).filter((i) => S.has(T(i)) && !i.endsWith(".d.ts")).sort(), o = k(r), c = [], p = [], u = [];
+  e.forEach((i, w) => {
+    let n = `Route${w}`, h = x(d(o, i)), R = g(i, t);
+    c.push(`import ${n} from '${h}'`), p.push(`if (!${n}.path) ${n}.path = ${JSON.stringify(R)}`), u.push(n);
+  });
+  let y = [
+    "
+    `
+    ...c,
+    "",
+    ...p,
+    "",
+    `export default [${u.join(", ")}]`,
+    ""
+  ].join(`
+`);
+  await v(o, { recursive: !0 }), await E(r, y);
+}
+function x(t) {
+  let s = t.replace(/\.(ts|tsx|js|jsx)$/, "").split(P).join("/");
+  return s.startsWith(".") ? s : `./${s}`;
 }
-
 // plugins/fs/src/index.ts
-var w = x.create({ name: "fs-routing" }).decorate("creator", "Ashu11-A").decorate("version", p).config({ path: "" }).derive("files", async (t) => await l(t.path)).extends((t, o) => ({
-  async registerRoutes(r) {
-    if (r.files.length !== 0)
-      for (let e of r.files) {
-        let s = (await import(e)).default;
-        if (!s) {
-          a("File Skipped: No Default Export", {
-            File: e,
-            Reason: "The file does not contain any default exported routes (export default).",
-            Solution: 'Ensure the file has a "export default new Router()" or similar.'
-          });
-          continue;
-        }
-        if (!(s instanceof y || s instanceof h)) {
-          a("File Skipped: Invalid Export Type", {
-            File: e,
-            "Exported Type": typeof s,
-            Reason: "The file does not export a known class instance (e.g., Router, Method)."
-          });
-          continue;
-        }
-        s.path || (s.path = u(e, r.path)), t.controller(s);
+var W = O.create({ name: "fs-routing" }).decorate("creator", "Ashu11-A").decorate("version", f).config({ routes: [] }).extends((t, r) => ({
+  registerRoutes(s) {
+    for (let e of s.routes) {
+      if (!(e instanceof I || e instanceof M)) {
+        m("Route Skipped: Invalid Entry", {
+          "Exported Type": typeof e,
+          Reason: "An entry in the generated route manifest is not a Router/Method instance.",
+          Solution: "Re-run `asterflow generate` - if the problem persists, check the route file's default export."
+        });
+        continue;
       }
+      t.controller(e);
+    }
   }
-})).on("beforeInitialize", async (t, o) => await t.registerRoutes(o)), M = w;
+})).on("beforeInitialize", (t, r) => t.registerRoutes(r)), V = W;
 export {
-  M as default,
-  w as fsRoutingPlugin,
+  V as default,
+  W as fsRoutingPlugin,
+  B as generateRouteManifest,
   l as getFilesRecursively,
-  u as transformPathToUrl
+  g as transformPathToUrl
 };

package/dist/types/index.d.ts

@@ -1,74 +1,32 @@
-// Generated by dts-bundle-generator v9.5.1
-
 import { Plugin } from '@asterflow/plugin';
-import { AnySchema, MethodHandler, MethodKeys, MethodOptions, Middleware, MiddlewareOutput, RouteHandler, RouterOptions, SchemaDynamic } from '@asterflow/router';
-import { AnyAsterflow } from 'asterflow';
-
-declare module "@asterflow/router" {
-	type MethodOptionsFS<Responder extends Responders, Path extends string = string, Drive extends Runtime = Runtime, Method extends MethodKeys = MethodKeys, Schema extends AnySchema = AnySchema, Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[] = [
-	], Context extends MiddlewareOutput<Middlewares> = MiddlewareOutput<Middlewares>, Instance extends AnyAsterflow = AnyAsterflow, Handler extends MethodHandler<Path, Drive, Responder, Schema, Middlewares, Context, Instance> = MethodHandler<Path, Drive, Responder, Schema, Middlewares, Context, Instance>> = Omit<MethodOptions<Responder, Path, Drive, Method, Schema, Middlewares, Context, Instance, Handler>, "path"> & {
-		path?: Path;
-		param?: Path;
-	};
-	type RouterOptionsFS<Path extends string, Schema extends SchemaDynamic<MethodKeys>, Responder extends Responders, Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[], Context extends MiddlewareOutput<Middlewares>, Routers extends {
-		[Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>;
-	}> = Omit<RouterOptions<Path, Schema, Responder, Middlewares, Context, Routers>, "path"> & {
-		path?: Path;
-		param?: Path;
-	};
-	export class Method<Responder extends Responders, const Path extends string = string, const Drive extends Runtime = Runtime, const Method extends MethodKeys = MethodKeys, const Schema extends AnySchema = AnySchema, const Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[] = [
-	], const Context extends MiddlewareOutput<Middlewares> = MiddlewareOutput<Middlewares>, const Instance extends AnyAsterflow = AnyAsterflow, const Handler extends MethodHandler<Path, Drive, Responder, Schema, Middlewares, Context, Instance> = MethodHandler<Path, Drive, Responder, Schema, Middlewares, Context, Instance>> extends OriginalMethod<Responder, Path, Drive, Method, Schema, Middlewares, Context, Instance, Handler> {
-		constructor(options: MethodOptionsFS<Responder, Path, Drive, Method, Schema, Middlewares, Context, Instance, Handler>);
-	}
-	export class Router<Responder extends Responders, const Path extends string = string, const Schema extends SchemaDynamic<MethodKeys> = SchemaDynamic<MethodKeys>, const Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[] = [
-	], const Context extends MiddlewareOutput<Middlewares> = MiddlewareOutput<Middlewares>, const Routers extends {
-		[Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>;
-	} = {
-		[Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>;
-	}> extends OriginalRouter<Responder, Path, Schema, Middlewares, Context, Routers> {
-		constructor(options: RouterOptionsFS<Path, Schema, Responder, Middlewares, Context, Routers>);
-	}
-}
-export declare const fsRoutingPlugin: Plugin<"fs-routing", import("asterflow").AnyAsterflow, {
-	path: string;
-	defaultConfig: {
-		path: string;
-	};
-}, {
-	creator: string;
-	version: string;
-}, {
-	files: string[];
-}, {
-	registerRoutes: (context: {
-		creator: string;
-		version: string;
-		path: string;
-		defaultConfig: {
-			path: string;
-		};
-		files: string[];
-	}) => Promise<void>;
+import { type AnyRouter } from '@asterflow/router';
+export * from './utils/codegen';
+export * from './utils/format';
+export * from './utils/glob';
+export * from './types/asterflow.d';
+export declare const fsRoutingPlugin: Plugin<{
+    decorate: {
+        creator: string;
+        version: string;
+    };
+    config: {
+        routes: AnyRouter[];
+        defaultConfig: {
+            routes: AnyRouter[];
+        };
+    };
+    path: "fs-routing";
+    instance: import("asterflow").AnyAsterflow;
+    derive: {};
+    extension: {
+        registerRoutes: (context: {
+            routes: AnyRouter[];
+            defaultConfig: {
+                routes: AnyRouter[];
+            };
+            creator: string;
+            version: string;
+        }) => void;
+    };
 }>;
-/**
- * Recursively lists files from a starting directory.
- * @param dirPath The path to the starting directory.
- * @returns A promise that resolves to an array of file paths.
- */
-export declare function getFilesRecursively(dirPath: string): Promise<string[]>;
-/**
- * Transforms a file path into a robustly formatted URL route.
- */
-export declare function transformPathToUrl(filePath: string, rootDir: string): string;
-export type FSRoutingContext = {
-	path: string;
-	files: string[];
-	creator: string;
-	version: string;
-};
-
-export {
-	fsRoutingPlugin as default,
-};
-
-export {};
+export default fsRoutingPlugin;

package/dist/types/types/asterflow.d.ts

@@ -0,0 +1,48 @@
+import type { Runtime } from '@asterflow/adapter'
+import type { AnyAsterflow } from 'asterflow'
+import type { Responders } from '@asterflow/response'
+import type {
+  AnySchema,
+  MethodHandler, MethodKeys,
+  Middleware,
+  MiddlewareOutput,
+  MethodOptions,
+  RouterOptions,
+  RouteHandler,
+  SchemaDynamic
+} from '@asterflow/router'
+
+// FS plugin augmentation: core router now supports optional path/param directly,
+// this module augmentation is kept for backward compatibility and type helpers.
+declare module '@asterflow/router' {
+  type MethodOptionsFS<
+   Responder extends Responders,
+   Path extends string = string,
+   Drive extends Runtime = Runtime,
+   Method extends MethodKeys = MethodKeys,
+   Schema extends AnySchema = AnySchema,
+   Middlewares extends readonly Middleware<Responder, Schema, string, Record<string, unknown>>[] = [],
+   Context extends MiddlewareOutput<Middlewares> = MiddlewareOutput<Middlewares>,
+   Instance extends AnyAsterflow = AnyAsterflow,
+   Handler extends MethodHandler<Path, Drive, Responder, Schema, Middlewares, Context, Instance> = MethodHandler<Path, Drive, Responder, Schema, Middlewares, Context, Instance>,
+  > = Omit<MethodOptions<Responder, Path, Drive, Method, Schema, Middlewares, Context, Instance, Handler>, 'path'> 
+    & {
+      path?: Path
+      param?: Path
+    }
+
+  type RouterOptionsFS<
+    Path extends string,
+    Schema extends SchemaDynamic<MethodKeys>,
+    Responder extends Responders,
+    Middlewares extends readonly Middleware<Responder, AnySchema, string, Record<string, unknown>>[],
+    Context extends MiddlewareOutput<Middlewares>,
+    Routers extends {
+      [Method in MethodKeys]?: RouteHandler<Path, Responder, Method, Schema, Middlewares, Context>;
+    }
+  > = Omit<RouterOptions<Path, Schema, Responder, Middlewares, Context, Routers>, 'path'> 
+    & {
+      path?: Path
+      param?: Path
+    }
+}

package/dist/types/utils/codegen.d.ts

@@ -0,0 +1,15 @@
+export interface GenerateRouteManifestOptions {
+    /** Directory scanned for route files (e.g. `src/routes`). */
+    routesDir: string;
+    /** Path of the manifest file to write (e.g. `src/routes.gen.ts`). */
+    outFile: string;
+}
+/**
+ * Scans `routesDir` once and writes a manifest file at `outFile` containing a
+ * static `import` per route file plus a default-exported `AnyRouter[]`. Meant
+ * to run at build/dev time (the `asterflow generate` CLI command), not at
+ * request time - the resulting imports are literal specifiers a bundler can
+ * follow, unlike `fsRoutingPlugin`'s old `await import(file)` with a
+ * fully-dynamic path, which bundlers can't statically resolve at all.
+ */
+export declare function generateRouteManifest({ routesDir, outFile }: GenerateRouteManifestOptions): Promise<void>;

package/dist/types/utils/format.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Transforms a file path into a robustly formatted URL route.
+ */
+export declare function transformPathToUrl(filePath: string, rootDir: string): string;

package/dist/types/utils/glob.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Recursively lists files from a starting directory.
+ * @param dirPath The path to the starting directory.
+ * @returns A promise that resolves to an array of file paths.
+ */
+export declare function getFilesRecursively(dirPath: string): Promise<string[]>;

package/dist/types/utils/log.d.ts

@@ -0,0 +1 @@
+export declare function logWarning(title: string, details: Record<string, string>): void;

package/package.json

@@ -1,6 +1,13 @@
 {
   "name": "@asterflow/fs",
-  "version": "1.0.8",
+  "version": "2.0.0",
+  "description": "Generates a static route manifest from a file-based routes/ directory and registers it on an AsterFlow app as a plugin.",
+  "keywords": [
+    "asterflow",
+    "plugin",
+    "file-based-routing",
+    "fs-routing"
+  ],
   "main": "dist/cjs/index.cjs",
   "module": "dist/mjs/index.js",
   "types": "dist/types/index.d.ts",
@@ -10,12 +17,12 @@
   "author": "Ashu11-A",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/AsterFlow/plugins.git"
+    "url": "git+https://github.com/AsterFlow/AsterFlow.git"
   },
   "bugs": {
-    "url": "https://github.com/AsterFlow/plugins/issues"
+    "url": "https://github.com/AsterFlow/AsterFlow/issues"
   },
-  "homepage": "https://github.com/AsterFlow/plugins",
+  "homepage": "https://github.com/AsterFlow/AsterFlow",
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
@@ -27,11 +34,11 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@asterflow/plugin": "^1.0.9",
-    "@asterflow/router": "^1.0.13",
-    "@asterflow/url-parser": "^2.0.3"
+    "@asterflow/router": "^2.0.0",
+    "@asterflow/url-parser": "^4.1.1"
   },
   "devDependencies": {
-    "asterflow": "^0.0.2"
+    "@asterflow/plugin": "^1.0.9",
+    "asterflow": "^1.0.0"
   }
-}
+}

package/tsconfig.json

@@ -18,23 +18,9 @@
     "noUncheckedIndexedAccess": true,
     "noUnusedLocals": false,
     "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false,
-    "paths": {
-      "@asterflow/fs": [
-        "./types"
-      ],
-      "@asterflow/fs/*": [
-        "./types/*"
-      ]
-    },
-    "declaration": true,
-    "declarationMap": true
+    "noPropertyAccessFromIndexSignature": false
   },
   "include": [
-    "types"
-  ],
-  "exclude": [
-    "node_modules",
-    "**/*.spec.ts"
+    "dist"
   ]
 }