@asterflow/fs 2.0.2 → 2.2.0

package/README.md

@@ -10,7 +10,7 @@
 
 </div>
 
-> Generates a static route manifest from a file-based `routes/` directory and registers it on an AsterFlow app as a plugin.
+> File-based routing for AsterFlow - dynamic (scan a directory at startup) or static (a pre-generated manifest, bundler-safe) - registered as a plugin.
 
 ## 📦 Installation
 
@@ -18,7 +18,19 @@
 bun install @asterflow/fs
 ```
 
-Register the plugin with a generated route manifest:
+`fsRoutingPlugin` supports two mutually exclusive modes, picked automatically from which config key you pass:
+
+**Dynamic** - point it at a directory, no codegen step required. Simplest for dev/unbundled runs (`bun run src/index.ts`), but the `import()` path is fully computed at runtime, so a bundler can't trace it - don't use this for a bundled/production build.
+
+```ts
+import { AsterFlow } from 'asterflow'
+import { fsRoutingPlugin } from '@asterflow/fs'
+
+const app = new AsterFlow()
+  .use(fsRoutingPlugin, { path: './src/routes' })
+```
+
+**Static** - a pre-generated manifest of literal imports, safe for bundling. Generate it once (via `asterflow generate`, `--watch`, or `generateRouteManifest` in a build script) and pass the result in:
 
 ```ts
 import { AsterFlow } from 'asterflow'
@@ -29,16 +41,19 @@ const app = new AsterFlow()
   .use(fsRoutingPlugin, { routes })
 ```
 
+Passing both `routes` and `path` is ambiguous - the plugin logs a warning and uses `path`.
+
 ### ✨ Features
 
-- **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.
+- **Two loading modes, one plugin**: `path` scans and `import()`s the directory at `beforeInitialize` (via `loadRoutesFromDir`) - no manifest file needed. `routes` takes a pre-generated array instead, for when the app gets bundled.
+- **Static manifest generation**: `generateRouteManifest` walks a routes directory once and writes a file with one literal `import` per route plus a default-exported array, so a bundler can follow it - unlike a fully-dynamic `import(path)`, which bundlers can't resolve at all.
+- **File-to-URL conventions** (both modes): `index.ts` becomes `/`, `users/index.ts` becomes `/users`, and a `$`-prefixed segment like `$id.ts` becomes a `:id` param.
+- **Auto path assignment**: any route whose `default export` has no explicit `path` gets one assigned from its file location.
+- **Safe registration**: `fsRoutingPlugin` registers every resolved route with `instance.controller(route)` on `beforeInitialize`, and skips (with a warning) any entry that isn't a `Method`/`Router` instance instead of throwing.
 
 ## ❓ How to Use
 
-Generate the manifest ahead of time, usually via the `asterflow generate` CLI command, or by calling the generator directly from a build script:
+For a static manifest, generate it ahead of time, usually via the `asterflow generate` CLI command, or by calling the generator directly from a build script:
 
 ```ts
 import { generateRouteManifest } from '@asterflow/fs'
@@ -49,7 +64,7 @@ await generateRouteManifest({
 })
 ```
 
-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`:
+Route files just export a `Method` or `Router` - the `path` is filled in from the file's location (whichever mode you use), so `src/routes/users/$id.ts` becomes `/users/:id`:
 
 ```ts
 // src/routes/users/$id.ts

package/dist/cjs/index.cjs

@@ -1,107 +1,130 @@
 "use strict";
-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 h = Object.defineProperty;
+var I = Object.getOwnPropertyDescriptor;
+var N = Object.getOwnPropertyNames;
+var U = Object.prototype.hasOwnProperty;
+var M = (t, e) => {
+  for (var r in e)
+    h(t, r, { get: e[r], enumerable: !0 });
+}, W = (t, e, r, o) => {
+  if (e && typeof e == "object" || typeof e == "function")
+    for (let s of N(e))
+      !U.call(t, s) && s !== r && h(t, s, { get: () => e[s], enumerable: !(o = I(e, s)) || o.enumerable });
+  return t;
 };
-var M = (e) => I(f({}, "__esModule", { value: !0 }), e);
+var _ = (t) => W(h({}, "__esModule", { value: !0 }), t);
 // plugins/fs/src/index.ts
-var _ = {};
-O(_, {
-  default: () => D,
-  fsRoutingPlugin: () => F,
-  generateRouteManifest: () => U,
-  getFilesRecursively: () => c,
-  transformPathToUrl: () => m
+var C = {};
+M(C, {
+  default: () => X,
+  fsRoutingPlugin: () => T,
+  generateRouteManifest: () => L,
+  getFilesRecursively: () => a,
+  loadRoutesFromDir: () => y,
+  transformPathToUrl: () => p
 });
-module.exports = M(_);
-var $ = require("@asterflow/plugin"), u = require("@asterflow/router");
+module.exports = _(C);
+var b = require("@asterflow/plugin"), d = require("@asterflow/router");
 // plugins/fs/package.json
-var y = "2.0.2";
+var R = "2.2.0";
+// plugins/fs/src/utils/loader.ts
+var j = require("path"), v = require("url");
+// plugins/fs/src/utils/constants.ts
+var f =  new Set([".ts", ".tsx", ".js", ".jsx"]);
+// plugins/fs/src/utils/format.ts
+var F = require("path");
+function p(t, e) {
+  let o = (0, F.relative)(e, t).replace(/\.(ts|js)$/, "");
+  return o.endsWith("/index") ? o = o.slice(0, -6) : o === "index" && (o = ""), o = o.replace(/\$/g, ":"), `/${o}`;
+}
+// plugins/fs/src/utils/glob.ts
+var A = require("fs/promises"), E = require("path");
+async function a(t) {
+  let e = await (0, A.readdir)(t, { withFileTypes: !0 });
+  return (await Promise.all(
+    e.map(async (o) => {
+      let s = (0, E.join)(t, o.name);
+      return o.isDirectory() ? a(s) : s;
+    })
+  )).flat();
+}
+// plugins/fs/src/utils/loader.ts
+async function y(t) {
+  let r = (await a(t)).filter((s) => f.has((0, j.extname)(s)) && !s.endsWith(".d.ts")).sort(), o = [];
+  for (let s of r) {
+    let n = (await import((0, v.pathToFileURL)(s).href)).default;
+    n != null && (n.path || (n.path = p(s, t)), o.push(n));
+  }
+  return o;
+}
 // plugins/fs/src/utils/log.ts
-var l = {
+var c = {
   reset: "\x1B[0m",
   red: "\x1B[31m",
   yellow: "\x1B[33m",
   cyan: "\x1B[36m"
 };
-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);
+function w(t, e) {
+  console.warn(`${c.yellow}%s %s${c.reset}`, "[AsterFlow]", t), console.group();
+  for (let [r, o] of Object.entries(e))
+    console.log(`${c.cyan}%s:${c.reset} %s`, r, o);
   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);
+var m = require("fs/promises"), i = require("path");
+async function L({ routesDir: t, outFile: e }) {
+  let o = (await a(t)).filter((l) => f.has((0, i.extname)(l)) && !l.endsWith(".d.ts")).sort(), s = (0, i.dirname)(e), g = [], n = [], x = [];
+  o.forEach((l, k) => {
+    let u = `Route${k}`, O = $((0, i.relative)(s, l)), P = p(l, t);
+    g.push(`import ${u} from '${O}'`), n.push(`if (!${u}.path) ${u}.path = ${JSON.stringify(P)}`), x.push(u);
   });
-  let b = [
+  let S = [
     "// AUTO-GENERATED by `asterflow generate` - do not edit directly.",
-    `// Source directory: ${A((0, i.relative)(o, e))}`,
+    `// Source directory: ${$((0, i.relative)(s, t))}`,
     ...g,
     "",
-    ...d,
+    ...n,
     "",
     `export default [${x.join(", ")}]`,
     ""
   ].join(`
 `);
-  await (0, p.mkdir)(o, { recursive: !0 }), await (0, p.writeFile)(r, b);
+  await (0, m.mkdir)(s, { recursive: !0 }), await (0, m.writeFile)(e, S);
 }
-function A(e) {
-  let s = e.replace(/\.(ts|tsx|js|jsx)$/, "").split(i.sep).join("/");
-  return s.startsWith(".") ? s : `./${s}`;
+function $(t) {
+  let r = t.replace(/\.(ts|tsx|js|jsx)$/, "").split(i.sep).join("/");
+  return r.startsWith(".") ? r : `./${r}`;
 }
 // plugins/fs/src/index.ts
-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)) {
+var T = b.Plugin.create({ name: "fs-routing" }).decorate("creator", "Ashu11-A").decorate("version", R).config({
+  routes: void 0,
+  path: void 0
+}).extends((t, e) => ({
+  registerRoutes(r) {
+    for (let o of r) {
+      if (!(o instanceof d.Method || o instanceof d.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."
+          "Exported Type": typeof o,
+          Reason: "An entry in the route list is not a Router/Method instance.",
+          Solution: "Check the route file's default export - if using a static manifest, re-run `asterflow generate`."
         });
         continue;
       }
-      e.controller(t);
+      t.controller(o);
     }
   }
-})).on("beforeInitialize", (e, r) => e.registerRoutes(r)), D = F;
+})).on("beforeInitialize", async (t, e) => {
+  e.path && e.routes && w("Ambiguous fs-routing Config", {
+    Reason: "Both `routes` and `path` were provided.",
+    Solution: "Pass only one: `path` for dynamic (dev) loading, or `routes` for a pre-generated static manifest. `path` will be used."
+  });
+  let r = e.path ? await y(e.path) : e.routes ?? [];
+  t.registerRoutes(r);
+}), X = T;
 0 && (module.exports = {
   fsRoutingPlugin,
   generateRouteManifest,
   getFilesRecursively,
+  loadRoutesFromDir,
   transformPathToUrl
 });

package/dist/mjs/index.js

@@ -1,87 +1,110 @@
 // plugins/fs/src/index.ts
-import { Plugin as O } from "@asterflow/plugin";
-import { Method as I, Router as M } from "@asterflow/router";
+import { Plugin as U } from "@asterflow/plugin";
+import { Method as M, Router as W } from "@asterflow/router";
 // plugins/fs/package.json
-var f = "2.0.2";
-// 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";
+var g = "2.2.0";
+// plugins/fs/src/utils/loader.ts
+import { extname as T } from "path";
+import { pathToFileURL as S } from "url";
+// plugins/fs/src/utils/constants.ts
+var p =  new Set([".ts", ".tsx", ".js", ".jsx"]);
 // plugins/fs/src/utils/format.ts
-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}`;
+import { relative as v } from "path";
+function u(e, o) {
+  let t = v(o, 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
-import { readdir as F } from "fs/promises";
+import { readdir as $ } from "fs/promises";
 import { join as b } from "path";
-async function l(t) {
-  let r = await F(t, { withFileTypes: !0 });
+async function a(e) {
+  let o = await $(e, { withFileTypes: !0 });
   return (await Promise.all(
-    r.map(async (e) => {
-      let o = b(t, e.name);
-      return e.isDirectory() ? l(o) : o;
+    o.map(async (t) => {
+      let s = b(e, t.name);
+      return t.isDirectory() ? a(s) : s;
     })
   )).flat();
 }
+// plugins/fs/src/utils/loader.ts
+async function h(e) {
+  let r = (await a(e)).filter((s) => p.has(T(s)) && !s.endsWith(".d.ts")).sort(), t = [];
+  for (let s of r) {
+    let i = (await import(S(s).href)).default;
+    i != null && (i.path || (i.path = u(s, e)), t.push(i));
+  }
+  return t;
+}
+// plugins/fs/src/utils/log.ts
+var f = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m"
+};
+function m(e, o) {
+  console.warn(`${f.yellow}%s %s${f.reset}`, "[AsterFlow]", e), console.group();
+  for (let [r, t] of Object.entries(o))
+    console.log(`${f.cyan}%s:${f.reset} %s`, r, t);
+  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);
+import { mkdir as k, writeFile as O } from "fs/promises";
+import { dirname as P, extname as I, relative as y, sep as N } from "path";
+async function rt({ routesDir: e, outFile: o }) {
+  let t = (await a(e)).filter((n) => p.has(I(n)) && !n.endsWith(".d.ts")).sort(), s = P(o), c = [], i = [], d = [];
+  t.forEach((n, R) => {
+    let l = `Route${R}`, F = w(y(s, n)), A = u(n, e);
+    c.push(`import ${l} from '${F}'`), i.push(`if (!${l}.path) ${l}.path = ${JSON.stringify(A)}`), d.push(l);
   });
-  let y = [
+  let x = [
     "// AUTO-GENERATED by `asterflow generate` - do not edit directly.",
-    `// Source directory: ${x(d(o, t))}`,
+    `// Source directory: ${w(y(s, e))}`,
     ...c,
     "",
-    ...p,
+    ...i,
     "",
-    `export default [${u.join(", ")}]`,
+    `export default [${d.join(", ")}]`,
     ""
   ].join(`
 `);
-  await v(o, { recursive: !0 }), await E(r, y);
+  await k(s, { recursive: !0 }), await O(o, x);
 }
-function x(t) {
-  let s = t.replace(/\.(ts|tsx|js|jsx)$/, "").split(P).join("/");
-  return s.startsWith(".") ? s : `./${s}`;
+function w(e) {
+  let r = e.replace(/\.(ts|tsx|js|jsx)$/, "").split(N).join("/");
+  return r.startsWith(".") ? r : `./${r}`;
 }
 // plugins/fs/src/index.ts
-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)) {
+var _ = U.create({ name: "fs-routing" }).decorate("creator", "Ashu11-A").decorate("version", g).config({
+  routes: void 0,
+  path: void 0
+}).extends((e, o) => ({
+  registerRoutes(r) {
+    for (let t of r) {
+      if (!(t instanceof M || t instanceof W)) {
         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."
+          "Exported Type": typeof t,
+          Reason: "An entry in the route list is not a Router/Method instance.",
+          Solution: "Check the route file's default export - if using a static manifest, re-run `asterflow generate`."
         });
         continue;
       }
-      t.controller(e);
+      e.controller(t);
     }
   }
-})).on("beforeInitialize", (t, r) => t.registerRoutes(r)), V = W;
+})).on("beforeInitialize", async (e, o) => {
+  o.path && o.routes && m("Ambiguous fs-routing Config", {
+    Reason: "Both `routes` and `path` were provided.",
+    Solution: "Pass only one: `path` for dynamic (dev) loading, or `routes` for a pre-generated static manifest. `path` will be used."
+  });
+  let r = o.path ? await h(o.path) : o.routes ?? [];
+  e.registerRoutes(r);
+}), pt = _;
 export {
-  V as default,
-  W as fsRoutingPlugin,
-  B as generateRouteManifest,
-  l as getFilesRecursively,
-  g as transformPathToUrl
+  pt as default,
+  _ as fsRoutingPlugin,
+  rt as generateRouteManifest,
+  a as getFilesRecursively,
+  h as loadRoutesFromDir,
+  u as transformPathToUrl
 };

package/dist/types/index.d.ts

@@ -3,6 +3,7 @@ import { type AnyRouter } from '@asterflow/router';
 export * from './utils/codegen';
 export * from './utils/format';
 export * from './utils/glob';
+export * from './utils/loader';
 export * from './types/asterflow.d';
 export declare const fsRoutingPlugin: Plugin<{
     decorate: {
@@ -10,23 +11,18 @@ export declare const fsRoutingPlugin: Plugin<{
         version: string;
     };
     config: {
-        routes: AnyRouter[];
+        routes: AnyRouter[] | undefined;
+        path: string | undefined;
         defaultConfig: {
-            routes: AnyRouter[];
+            routes: AnyRouter[] | undefined;
+            path: string | undefined;
         };
     };
     path: "fs-routing";
     instance: import("asterflow").AnyAsterflow;
     derive: {};
     extension: {
-        registerRoutes: (context: {
-            routes: AnyRouter[];
-            defaultConfig: {
-                routes: AnyRouter[];
-            };
-            creator: string;
-            version: string;
-        }) => void;
+        registerRoutes: (routes: AnyRouter[]) => void;
     };
 }>;
 export default fsRoutingPlugin;

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

@@ -7,9 +7,11 @@ export interface GenerateRouteManifestOptions {
 /**
  * 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.
+ * to run at build time (the `asterflow generate` CLI command, or a bundler
+ * plugin) - the resulting imports are literal specifiers a bundler can
+ * follow, unlike `loadRoutesFromDir`'s fully-dynamic `import(file)`, which
+ * bundlers can't statically resolve at all. Use this for bundled/production
+ * builds; `loadRoutesFromDir` (passed to `fsRoutingPlugin` as `routesDir`)
+ * covers unbundled dev runs where no codegen step is wanted.
  */
 export declare function generateRouteManifest({ routesDir, outFile }: GenerateRouteManifestOptions): Promise<void>;

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

@@ -0,0 +1 @@
+export declare const ROUTE_FILE_EXTENSIONS: Set<string>;

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

@@ -0,0 +1,10 @@
+import type { AnyRouter } from '@asterflow/router';
+/**
+ * Scans `routesDir` and `import()`s every route file at call time, assigning
+ * `path` from the file location when a route doesn't set one explicitly.
+ * Meant for unbundled dev/runtime use (no codegen step required) - the
+ * `import()` path is fully dynamic, so a bundler can't trace it. Bundled
+ * builds should use `generateRouteManifest` + a static `routes` array
+ * instead.
+ */
+export declare function loadRoutesFromDir(routesDir: string): Promise<AnyRouter[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asterflow/fs",
-  "version": "2.0.2",
+  "version": "2.2.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",
@@ -34,11 +34,11 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@asterflow/plugin": "^2.0.2",
-    "@asterflow/router": "^2.0.2",
+    "@asterflow/plugin": "^2.2.0",
+    "@asterflow/router": "^2.2.0",
     "@asterflow/url-parser": "^4.1.1"
   },
   "devDependencies": {
-    "asterflow": "^2.0.2"
+    "asterflow": "^2.2.0"
   }
 }