@layerzerolabs/dfs 0.0.19 → 0.0.21

package/.turbo/turbo-build.log

@@ -1,18 +1,18 @@
 
-> @layerzerolabs/dfs@0.0.2 build /home/runner/work/monorepo-internal/monorepo-internal/packages/dfs
+> @layerzerolabs/dfs@0.0.2 build /home/runner/work/monorepo-internal/monorepo-internal/packages/framework/dfs
 > tsup
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.4.0
-CLI Using tsup config: /home/runner/work/monorepo-internal/monorepo-internal/packages/dfs/tsup.config.ts
+CLI Using tsup config: /home/runner/work/monorepo-internal/monorepo-internal/packages/framework/dfs/tsup.config.ts
 CLI Target: es2022
 CLI Cleaning output folder
 CJS Build start
 ESM Build start
-CJS dist/index.cjs     1.38 KB
-CJS dist/index.cjs.map 5.33 KB
-CJS ⚡️ Build success in 120ms
-ESM dist/index.js     1.36 KB
-ESM dist/index.js.map 5.32 KB
-ESM ⚡️ Build success in 120ms
+CJS dist/index.cjs     2.78 KB
+CJS dist/index.cjs.map 8.97 KB
+CJS ⚡️ Build success in 86ms
+ESM dist/index.js     2.76 KB
+ESM dist/index.js.map 8.96 KB
+ESM ⚡️ Build success in 86ms

package/.turbo/turbo-lint.log

@@ -1,4 +1,4 @@
 
-> @layerzerolabs/dfs@0.0.2 lint /home/runner/work/monorepo-internal/monorepo-internal/packages/dfs
+> @layerzerolabs/dfs@0.0.2 lint /home/runner/work/monorepo-internal/monorepo-internal/packages/framework/dfs
 > eslint . --max-warnings 0
 

package/.turbo/turbo-test.log

@@ -1,15 +1,15 @@
 
-> @layerzerolabs/dfs@0.0.2 test /home/runner/work/monorepo-internal/monorepo-internal/packages/dfs
+> @layerzerolabs/dfs@0.0.2 test /home/runner/work/monorepo-internal/monorepo-internal/packages/framework/dfs
 > vitest --run --pass-with-no-tests
 
 
- RUN  v3.2.3 /home/runner/work/monorepo-internal/monorepo-internal/packages/dfs
+ RUN  v3.2.3 /home/runner/work/monorepo-internal/monorepo-internal/packages/framework/dfs
 
- ✓ test/dfs.test.ts (3 tests) 310ms
-   ✓ DI Depth-first-search > The handlers for each of a node's dependencies should be completed before that node  304ms
+ ✓ test/dfs.test.ts (3 tests) 306ms
+   ✓ DI Depth-first-search > The handlers for each of a node's dependencies should be completed before that node  302ms
 
  Test Files  1 passed (1)
       Tests  3 passed (3)
-   Start at  23:51:51
-   Duration  1.19s (transform 136ms, setup 0ms, collect 81ms, tests 310ms, environment 0ms, prepare 358ms)
+   Start at  01:58:06
+   Duration  650ms (transform 66ms, setup 0ms, collect 55ms, tests 306ms, environment 0ms, prepare 102ms)
 

package/dist/index.cjs

@@ -4,42 +4,66 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/index.ts
-var dfs = /* @__PURE__ */ __name((node, handler, prehandler = (node2) => node2, _visited = /* @__PURE__ */ new Map(), _returns = {}, _backtrack = []) => {
-  const _node = prehandler(node);
-  if (_visited.has(_node.name)) {
-    return async () => {
-      await _visited.get(_node.name);
-      return _returns;
-    };
-  }
-  let resolver;
-  _visited.set(_node.name, new Promise((res) => {
-    resolver = res;
-  }));
-  const resolverFunctions = [];
-  if (_node.dependencies) {
-    const nextBacktrack = [
-      ..._backtrack,
-      _node
-    ];
-    for (const [_, dependencyValue] of Object.entries(_node.dependencies)) {
-      resolverFunctions.push(dfs(dependencyValue, handler, prehandler, _visited, _returns, nextBacktrack));
+var buildAncestorsByNodeName = /* @__PURE__ */ __name((node, prehandler) => {
+  const ancestorsByNodeName = /* @__PURE__ */ new Map();
+  const dependentCountByNodeName = /* @__PURE__ */ new Map();
+  const initializeMaps = /* @__PURE__ */ __name((node2) => {
+    ancestorsByNodeName.set(node2.name, /* @__PURE__ */ new Set([]));
+    for (const dependencyValue of Object.values(node2.dependencies)) {
+      const inDegree = dependentCountByNodeName.get(dependencyValue.name) || 0;
+      dependentCountByNodeName.set(dependencyValue.name, inDegree + 1);
+      if (!ancestorsByNodeName.has(dependencyValue.name)) {
+        initializeMaps(dependencyValue);
+      }
+    }
+  }, "initializeMaps");
+  initializeMaps(node);
+  let queue = [
+    prehandler(node)
+  ];
+  while (queue.length > 0) {
+    const curNode = queue.shift();
+    for (const dependencyValue of Object.values(curNode.dependencies)) {
+      const inDegree = dependentCountByNodeName.get(dependencyValue.name);
+      if (inDegree === 1) {
+        const preHandledDependency = prehandler(dependencyValue);
+        queue.push(preHandledDependency);
+      }
+      dependentCountByNodeName.set(dependencyValue.name, inDegree - 1);
+      const childAncestry = ancestorsByNodeName.get(dependencyValue.name);
+      const nodeAncestry = ancestorsByNodeName.get(curNode.name);
+      childAncestry.add(curNode);
+      for (const ancestor of nodeAncestry) {
+        childAncestry.add(ancestor);
+      }
     }
   }
-  return async () => {
-    try {
-      await Promise.all(resolverFunctions.map((f) => f()));
-      const regRes = await handler(_node);
-      if (regRes) {
-        (_returns[regRes.key] ??= {})[_node.name] = regRes.value;
+  return ancestorsByNodeName;
+}, "buildAncestorsByNodeName");
+var dfs = /* @__PURE__ */ __name((node, handler, prehandler = (node2) => node2, _returns = {}) => {
+  const ancestorsByNodeName = buildAncestorsByNodeName(node, prehandler);
+  const nodeResolverPromises = /* @__PURE__ */ new Map();
+  const resolveNode = /* @__PURE__ */ __name(async (node2) => {
+    const prehandledNode = prehandler(node2);
+    const childrenPromises = [];
+    for (const dependencyValue of Object.values(prehandledNode.dependencies)) {
+      if (!nodeResolverPromises.has(dependencyValue.name)) {
+        nodeResolverPromises.set(dependencyValue.name, resolveNode(dependencyValue));
       }
-      resolver();
-      return _returns;
-    } catch (error) {
-      console.error(`Failed at ${_backtrack.map((n) => n.name).join("/")}
-${error?.message}`);
-      throw error;
+      childrenPromises.push(nodeResolverPromises.get(dependencyValue.name));
     }
+    await Promise.all(childrenPromises);
+    const ancestry = ancestorsByNodeName.get(prehandledNode.name);
+    const regRes = await handler(node2, [
+      ...ancestry
+    ]);
+    if (regRes) {
+      (_returns[regRes.key] ??= {})[prehandledNode.name] = regRes.value;
+    }
+  }, "resolveNode");
+  return async () => {
+    await resolveNode(node);
+    return _returns;
   };
 }, "dfs");
 

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":["dfs","node","handler","prehandler","_visited","Map","_returns","_backtrack","_node","has","name","get","resolver","set","Promise","res","resolverFunctions","dependencies","nextBacktrack","_","dependencyValue","Object","entries","push","all","map","f","regRes","key","value","error","console","n","join","message"],"mappings":";;;;;;AA8BO,IAAMA,sBAAM,MAAA,CAAA,CACfC,IAAAA,EACAC,OAAAA,EACAC,UAAAA,GAAqC,CAACF,KAAAA,KAASA,KAAAA,EAC/CG,QAAAA,mBAAuC,IAAIC,KAAAA,EAC3CC,QAAAA,GAAwB,EAAC,EACzBC,UAAAA,GAA6D,EAAA,KAAE;AAE/D,EAAA,MAAMC,KAAAA,GAAQL,WAAWF,IAAAA,CAAAA;AACzB,EAAA,IAAIG,QAAAA,CAASK,GAAAA,CAAID,KAAAA,CAAME,IAAI,CAAA,EAAG;AAC1B,IAAA,OAAO,YAAA;AACH,MAAA,MAAMN,QAAAA,CAASO,GAAAA,CAAIH,KAAAA,CAAME,IAAI,CAAA;AAC7B,MAAA,OAAOJ,QAAAA;AACX,IAAA,CAAA;AACJ,EAAA;AACA,EAAA,IAAIM,QAAAA;AAEJR,EAAAA,QAAAA,CAASS,IACLL,KAAAA,CAAME,IAAAA,EACN,IAAII,OAAAA,CAAc,CAACC,GAAAA,KAAAA;AACfH,IAAAA,QAAAA,GAAWG,GAAAA;AACf,EAAA,CAAA,CAAA,CAAA;AAIJ,EAAA,MAAMC,oBAA4C,EAAA;AAClD,EAAA,IAAIR,MAAMS,YAAAA,EAAc;AACpB,IAAA,MAAMC,aAAAA,GAAgB;AAAIX,MAAAA,GAAAA,UAAAA;AAAYC,MAAAA;;AACtC,IAAA,KAAA,MAAW,CAACW,GAAGC,eAAAA,CAAAA,IAAoBC,OAAOC,OAAAA,CAAQd,KAAAA,CAAMS,YAAY,CAAA,EAAG;AACnED,MAAAA,iBAAAA,CAAkBO,IAAAA,CACdvB,IAAIoB,eAAAA,EAAiBlB,OAAAA,EAASC,YAAYC,QAAAA,EAAUE,QAAAA,EAAUY,aAAAA,CAAAA,CAAAA;AAEtE,IAAA;AACJ,EAAA;AAEA,EAAA,OAAO,YAAA;AACH,IAAA,IAAI;AACA,MAAA,MAAMJ,OAAAA,CAAQU,IAAIR,iBAAAA,CAAkBS,GAAAA,CAAI,CAACC,CAAAA,KAAMA,CAAAA,EAAAA,CAAAA,CAAAA;AAC/C,MAAA,MAAMC,MAAAA,GAAS,MAAMzB,OAAAA,CAAQM,KAAAA,CAAAA;AAC7B,MAAA,IAAImB,MAAAA,EAAQ;AACP,QAAA,CAACrB,QAAAA,CAAiBqB,OAAOC,GAAG,CAAA,KAAM,EAAC,EAAGpB,KAAAA,CAAME,IAAI,CAAA,GAAIiB,MAAAA,CAAOE,KAAAA;AAChE,MAAA;AACAjB,MAAAA,QAAAA,EAAAA;AACA,MAAA,OAAON,QAAAA;AACX,IAAA,CAAA,CAAA,OAASwB,KAAAA,EAAY;AACjBC,MAAAA,OAAAA,CAAQD,KAAAA,CACJ,CAAA,UAAA,EAAavB,UAAAA,CAAWkB,GAAAA,CAAI,CAACO,CAAAA,KAAMA,CAAAA,CAAEtB,IAAI,CAAA,CAAEuB,IAAAA,CAAK,GAAA,CAAA;AAASH,EAAAA,KAAAA,EAAOI,OAAAA,CAAAA,CAAS,CAAA;AAE7E,MAAA,MAAMJ,KAAAA;AACV,IAAA;AACJ,EAAA,CAAA;AACJ,CAAA,EAnDmB,KAAA","file":"index.cjs","sourcesContent":["import type { Dependencies, DependencyNode } from '@layerzerolabs/dependency-graph';\n\n/**\n * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.\n * It is implicit in this definition that the registrar should also *register* values adhering to the schemata\n * of the graph.\n */\nexport interface Registrar<ReturnType> {\n    traverseDependencies: (rootNode: DependencyNode<any, any>) => Promise<ReturnType>;\n}\nexport type NodeHandlerFunction = (\n    node: DependencyNode<any, Dependencies>,\n) => Promise<{ key: string; value: any }>;\nexport type NodePreHandlerFunction = (\n    node: DependencyNode<any, Dependencies>,\n) => DependencyNode<any, Dependencies>;\n\n/**\n * Performs a depth-first-search on a tree of dependency nodes, and returns a function\n * that will call the handler for each node in the tree, ordered s.t. the handler of N\n * will be called only after the handlers of dependencies(N) have been called.\n * The resolver function will only call the handler once for each unique definition node.\n * The resolver function returns an object whose keys are the keys defined\n * by each of the handlers, and whose values are objects whose keys are the names\n * of the nodes resolved and whose values are the values defined by the handlers.\n * @param node the root node of the tree\n * @param handler a function that accepts a node and registers it\n * @param prehandler a function that accepts a node and returns a node. will be use to pre-process the graph\n * @returns a resolver function\n */\nexport const dfs = <DependencyName extends string, ReturnTypes>(\n    node: DependencyNode<DependencyName, Dependencies>,\n    handler: NodeHandlerFunction,\n    prehandler: NodePreHandlerFunction = (node) => node,\n    _visited: Map<string, Promise<void>> = new Map(),\n    _returns: ReturnTypes = {} as any,\n    _backtrack: DependencyNode<DependencyName, Dependencies>[] = [],\n): (() => Promise<ReturnTypes>) => {\n    const _node = prehandler(node);\n    if (_visited.has(_node.name)) {\n        return async () => {\n            await _visited.get(_node.name);\n            return _returns;\n        };\n    }\n    let resolver: (value: void | PromiseLike<void>) => void;\n\n    _visited.set(\n        _node.name,\n        new Promise<void>((res) => {\n            resolver = res;\n        }),\n    );\n\n    // Resolve dependencies first\n    const resolverFunctions: (() => Promise<any>)[] = [];\n    if (_node.dependencies) {\n        const nextBacktrack = [..._backtrack, _node];\n        for (const [_, dependencyValue] of Object.entries(_node.dependencies)) {\n            resolverFunctions.push(\n                dfs(dependencyValue, handler, prehandler, _visited, _returns, nextBacktrack),\n            );\n        }\n    }\n\n    return async () => {\n        try {\n            await Promise.all(resolverFunctions.map((f) => f()));\n            const regRes = await handler(_node);\n            if (regRes) {\n                ((_returns as any)[regRes.key] ??= {})[_node.name] = regRes.value;\n            }\n            resolver();\n            return _returns;\n        } catch (error: any) {\n            console.error(\n                `Failed at ${_backtrack.map((n) => n.name).join('/')}\\n${error?.message}`,\n            );\n            throw error;\n        }\n    };\n};\n"]}
+{"version":3,"sources":["../src/index.ts"],"names":["buildAncestorsByNodeName","node","prehandler","ancestorsByNodeName","Map","dependentCountByNodeName","initializeMaps","set","name","Set","dependencyValue","Object","values","dependencies","inDegree","get","has","queue","length","curNode","shift","preHandledDependency","push","childAncestry","nodeAncestry","add","ancestor","dfs","handler","_returns","nodeResolverPromises","resolveNode","prehandledNode","childrenPromises","Promise","all","ancestry","regRes","key","value"],"mappings":"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","file":"index.cjs","sourcesContent":["import type { DependencyNode } from '@layerzerolabs/dependency-graph';\n\n/**\n * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.\n * It is implicit in this definition that the registrar should also *register* values adhering to the schemata\n * of the graph.\n */\nexport interface Registrar<ReturnType> {\n    traverseDependencies: (rootNode: DependencyNode) => Promise<ReturnType>;\n}\nexport type NodeHandlerFunction = (\n    node: DependencyNode,\n    ancestry: DependencyNode[],\n) => Promise<{ key: string; value: any }>;\nexport type NodePreHandlerFunction = (node: DependencyNode) => DependencyNode;\n\nconst buildAncestorsByNodeName = (node: DependencyNode, prehandler: NodePreHandlerFunction) => {\n    const ancestorsByNodeName = new Map<string, Set<DependencyNode>>();\n    const dependentCountByNodeName = new Map<string, number>();\n\n    // If A depends on B and C, B depends on C, we initialize with:\n    // ancestorsByNodeName: { A: Set([]), B: Set([]), C: Set([]) }\n    // dependentsCountByNodeName: { B: 1, C: 2 }\n    const initializeMaps = (node: DependencyNode) => {\n        ancestorsByNodeName.set(node.name, new Set([]));\n        for (const dependencyValue of Object.values(node.dependencies)) {\n            const inDegree = dependentCountByNodeName.get(dependencyValue.name) || 0;\n            dependentCountByNodeName.set(dependencyValue.name, inDegree + 1);\n            if (!ancestorsByNodeName.has(dependencyValue.name)) {\n                initializeMaps(dependencyValue);\n            }\n        }\n    };\n    initializeMaps(node);\n\n    // topological sorted bfs exploration\n    // induction by level, initial level has correct initial state, build level + 1\n    // bfs is used to build ancestry correctly\n    // this should actually be a queue, but its probably fine for now\n    let queue = [prehandler(node)];\n    while (queue.length > 0) {\n        const curNode = queue.shift()!;\n\n        // add the new processable dependencies to the queue, update their state.\n        for (const dependencyValue of Object.values(curNode.dependencies)) {\n            const inDegree = dependentCountByNodeName.get(dependencyValue.name)!;\n            // We are the last edge missing in the graph for this dependency -> we can process it after us.\n            if (inDegree === 1) {\n                const preHandledDependency = prehandler(dependencyValue);\n                queue.push(preHandledDependency);\n            }\n            // Reduce the in-degree of the dependency -> it basically means that this edge got removed from the graph.\n            dependentCountByNodeName.set(dependencyValue.name, inDegree - 1);\n\n            // add our ancestry to them, js sets maintain order of insertion, this means their ancestors are in distance order due to BFS properties.\n            const childAncestry = ancestorsByNodeName.get(dependencyValue.name)!;\n            const nodeAncestry = ancestorsByNodeName.get(curNode.name)!;\n            childAncestry.add(curNode);\n            for (const ancestor of nodeAncestry) {\n                childAncestry.add(ancestor);\n            }\n        }\n    }\n\n    return ancestorsByNodeName;\n};\n\n/**\n * Performs a depth-first-search on a tree of dependency nodes, and returns a function\n * that will call the handler for each node in the tree, ordered s.t. the handler of N\n * will be called only after the handlers of dependencies(N) have been called.\n * The resolver function will only call the handler once for each unique definition node.\n * The resolver function returns an object whose keys are the keys defined\n * by each of the handlers, and whose values are objects whose keys are the names\n * of the nodes resolved and whose values are the values defined by the handlers.\n * @param node the root node of the tree\n * @param handler a function that accepts a node and registers it\n * @param prehandler a function that accepts a node and returns a node. will be use to pre-process the graph\n * @returns a resolver function\n */\nexport const dfs = <ReturnTypes>(\n    node: DependencyNode,\n    handler: NodeHandlerFunction,\n    prehandler: NodePreHandlerFunction = (node) => node,\n    _returns: ReturnTypes = {} as any,\n): (() => Promise<ReturnTypes>) => {\n    const ancestorsByNodeName = buildAncestorsByNodeName(node, prehandler);\n\n    // Maintains Map<node.name, Promise<void>> -> the promise to resolve the node, for all nodes.\n    const nodeResolverPromises = new Map<string, Promise<void>>();\n    const resolveNode = async (node: DependencyNode) => {\n        const prehandledNode = prehandler(node);\n        // first wait for all its children\n        const childrenPromises = [];\n        for (const dependencyValue of Object.values(prehandledNode.dependencies)) {\n            // Grab the cached promise or create it, we want to have only 1 handler promise for each node.\n            if (!nodeResolverPromises.has(dependencyValue.name)) {\n                nodeResolverPromises.set(dependencyValue.name, resolveNode(dependencyValue));\n            }\n            childrenPromises.push(nodeResolverPromises.get(dependencyValue.name)!);\n        }\n        await Promise.all(childrenPromises);\n\n        // Then, you can process yourself\n        const ancestry = ancestorsByNodeName.get(prehandledNode.name)!;\n        const regRes = await handler(node, [...ancestry]);\n        if (regRes) {\n            ((_returns as any)[regRes.key] ??= {})[prehandledNode.name] = regRes.value;\n        }\n    };\n\n    return async () => {\n        await resolveNode(node);\n        return _returns;\n    };\n};\n"]}

package/dist/index.d.ts

@@ -1,17 +1,17 @@
-import type { Dependencies, DependencyNode } from '@layerzerolabs/dependency-graph';
+import type { DependencyNode } from '@layerzerolabs/dependency-graph';
 /**
  * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.
  * It is implicit in this definition that the registrar should also *register* values adhering to the schemata
  * of the graph.
  */
 export interface Registrar<ReturnType> {
-    traverseDependencies: (rootNode: DependencyNode<any, any>) => Promise<ReturnType>;
+    traverseDependencies: (rootNode: DependencyNode) => Promise<ReturnType>;
 }
-export type NodeHandlerFunction = (node: DependencyNode<any, Dependencies>) => Promise<{
+export type NodeHandlerFunction = (node: DependencyNode, ancestry: DependencyNode[]) => Promise<{
     key: string;
     value: any;
 }>;
-export type NodePreHandlerFunction = (node: DependencyNode<any, Dependencies>) => DependencyNode<any, Dependencies>;
+export type NodePreHandlerFunction = (node: DependencyNode) => DependencyNode;
 /**
  * Performs a depth-first-search on a tree of dependency nodes, and returns a function
  * that will call the handler for each node in the tree, ordered s.t. the handler of N
@@ -25,5 +25,5 @@ export type NodePreHandlerFunction = (node: DependencyNode<any, Dependencies>) =
  * @param prehandler a function that accepts a node and returns a node. will be use to pre-process the graph
  * @returns a resolver function
  */
-export declare const dfs: <DependencyName extends string, ReturnTypes>(node: DependencyNode<DependencyName, Dependencies>, handler: NodeHandlerFunction, prehandler?: NodePreHandlerFunction, _visited?: Map<string, Promise<void>>, _returns?: ReturnTypes, _backtrack?: DependencyNode<DependencyName, Dependencies>[]) => (() => Promise<ReturnTypes>);
+export declare const dfs: <ReturnTypes>(node: DependencyNode, handler: NodeHandlerFunction, prehandler?: NodePreHandlerFunction, _returns?: ReturnTypes) => (() => Promise<ReturnTypes>);
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEpF;;;;GAIG;AACH,MAAM,WAAW,SAAS,CAAC,UAAU;IACjC,oBAAoB,EAAE,CAAC,QAAQ,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CACrF;AACD,MAAM,MAAM,mBAAmB,GAAG,CAC9B,IAAI,EAAE,cAAc,CAAC,GAAG,EAAE,YAAY,CAAC,KACtC,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,GAAG,CAAA;CAAE,CAAC,CAAC;AAC1C,MAAM,MAAM,sBAAsB,GAAG,CACjC,IAAI,EAAE,cAAc,CAAC,GAAG,EAAE,YAAY,CAAC,KACtC,cAAc,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC;AAEvC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG,GAAI,cAAc,SAAS,MAAM,EAAE,WAAW,EAC1D,MAAM,cAAc,CAAC,cAAc,EAAE,YAAY,CAAC,EAClD,SAAS,mBAAmB,EAC5B,aAAY,sBAAuC,EACnD,WAAU,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAa,EAChD,WAAU,WAAuB,EACjC,aAAY,cAAc,CAAC,cAAc,EAAE,YAAY,CAAC,EAAO,KAChE,CAAC,MAAM,OAAO,CAAC,WAAW,CAAC,CA4C7B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE;;;;GAIG;AACH,MAAM,WAAW,SAAS,CAAC,UAAU;IACjC,oBAAoB,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CAC3E;AACD,MAAM,MAAM,mBAAmB,GAAG,CAC9B,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,cAAc,EAAE,KACzB,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,GAAG,CAAA;CAAE,CAAC,CAAC;AAC1C,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE,cAAc,KAAK,cAAc,CAAC;AAqD9E;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG,GAAI,WAAW,EAC3B,MAAM,cAAc,EACpB,SAAS,mBAAmB,EAC5B,aAAY,sBAAuC,EACnD,WAAU,WAAuB,KAClC,CAAC,MAAM,OAAO,CAAC,WAAW,CAAC,CA8B7B,CAAC"}

package/dist/index.js

@@ -2,42 +2,66 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/index.ts
-var dfs = /* @__PURE__ */ __name((node, handler, prehandler = (node2) => node2, _visited = /* @__PURE__ */ new Map(), _returns = {}, _backtrack = []) => {
-  const _node = prehandler(node);
-  if (_visited.has(_node.name)) {
-    return async () => {
-      await _visited.get(_node.name);
-      return _returns;
-    };
-  }
-  let resolver;
-  _visited.set(_node.name, new Promise((res) => {
-    resolver = res;
-  }));
-  const resolverFunctions = [];
-  if (_node.dependencies) {
-    const nextBacktrack = [
-      ..._backtrack,
-      _node
-    ];
-    for (const [_, dependencyValue] of Object.entries(_node.dependencies)) {
-      resolverFunctions.push(dfs(dependencyValue, handler, prehandler, _visited, _returns, nextBacktrack));
+var buildAncestorsByNodeName = /* @__PURE__ */ __name((node, prehandler) => {
+  const ancestorsByNodeName = /* @__PURE__ */ new Map();
+  const dependentCountByNodeName = /* @__PURE__ */ new Map();
+  const initializeMaps = /* @__PURE__ */ __name((node2) => {
+    ancestorsByNodeName.set(node2.name, /* @__PURE__ */ new Set([]));
+    for (const dependencyValue of Object.values(node2.dependencies)) {
+      const inDegree = dependentCountByNodeName.get(dependencyValue.name) || 0;
+      dependentCountByNodeName.set(dependencyValue.name, inDegree + 1);
+      if (!ancestorsByNodeName.has(dependencyValue.name)) {
+        initializeMaps(dependencyValue);
+      }
+    }
+  }, "initializeMaps");
+  initializeMaps(node);
+  let queue = [
+    prehandler(node)
+  ];
+  while (queue.length > 0) {
+    const curNode = queue.shift();
+    for (const dependencyValue of Object.values(curNode.dependencies)) {
+      const inDegree = dependentCountByNodeName.get(dependencyValue.name);
+      if (inDegree === 1) {
+        const preHandledDependency = prehandler(dependencyValue);
+        queue.push(preHandledDependency);
+      }
+      dependentCountByNodeName.set(dependencyValue.name, inDegree - 1);
+      const childAncestry = ancestorsByNodeName.get(dependencyValue.name);
+      const nodeAncestry = ancestorsByNodeName.get(curNode.name);
+      childAncestry.add(curNode);
+      for (const ancestor of nodeAncestry) {
+        childAncestry.add(ancestor);
+      }
     }
   }
-  return async () => {
-    try {
-      await Promise.all(resolverFunctions.map((f) => f()));
-      const regRes = await handler(_node);
-      if (regRes) {
-        (_returns[regRes.key] ??= {})[_node.name] = regRes.value;
+  return ancestorsByNodeName;
+}, "buildAncestorsByNodeName");
+var dfs = /* @__PURE__ */ __name((node, handler, prehandler = (node2) => node2, _returns = {}) => {
+  const ancestorsByNodeName = buildAncestorsByNodeName(node, prehandler);
+  const nodeResolverPromises = /* @__PURE__ */ new Map();
+  const resolveNode = /* @__PURE__ */ __name(async (node2) => {
+    const prehandledNode = prehandler(node2);
+    const childrenPromises = [];
+    for (const dependencyValue of Object.values(prehandledNode.dependencies)) {
+      if (!nodeResolverPromises.has(dependencyValue.name)) {
+        nodeResolverPromises.set(dependencyValue.name, resolveNode(dependencyValue));
       }
-      resolver();
-      return _returns;
-    } catch (error) {
-      console.error(`Failed at ${_backtrack.map((n) => n.name).join("/")}
-${error?.message}`);
-      throw error;
+      childrenPromises.push(nodeResolverPromises.get(dependencyValue.name));
     }
+    await Promise.all(childrenPromises);
+    const ancestry = ancestorsByNodeName.get(prehandledNode.name);
+    const regRes = await handler(node2, [
+      ...ancestry
+    ]);
+    if (regRes) {
+      (_returns[regRes.key] ??= {})[prehandledNode.name] = regRes.value;
+    }
+  }, "resolveNode");
+  return async () => {
+    await resolveNode(node);
+    return _returns;
   };
 }, "dfs");
 

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":["dfs","node","handler","prehandler","_visited","Map","_returns","_backtrack","_node","has","name","get","resolver","set","Promise","res","resolverFunctions","dependencies","nextBacktrack","_","dependencyValue","Object","entries","push","all","map","f","regRes","key","value","error","console","n","join","message"],"mappings":";;;;AA8BO,IAAMA,sBAAM,MAAA,CAAA,CACfC,IAAAA,EACAC,OAAAA,EACAC,UAAAA,GAAqC,CAACF,KAAAA,KAASA,KAAAA,EAC/CG,QAAAA,mBAAuC,IAAIC,KAAAA,EAC3CC,QAAAA,GAAwB,EAAC,EACzBC,UAAAA,GAA6D,EAAA,KAAE;AAE/D,EAAA,MAAMC,KAAAA,GAAQL,WAAWF,IAAAA,CAAAA;AACzB,EAAA,IAAIG,QAAAA,CAASK,GAAAA,CAAID,KAAAA,CAAME,IAAI,CAAA,EAAG;AAC1B,IAAA,OAAO,YAAA;AACH,MAAA,MAAMN,QAAAA,CAASO,GAAAA,CAAIH,KAAAA,CAAME,IAAI,CAAA;AAC7B,MAAA,OAAOJ,QAAAA;AACX,IAAA,CAAA;AACJ,EAAA;AACA,EAAA,IAAIM,QAAAA;AAEJR,EAAAA,QAAAA,CAASS,IACLL,KAAAA,CAAME,IAAAA,EACN,IAAII,OAAAA,CAAc,CAACC,GAAAA,KAAAA;AACfH,IAAAA,QAAAA,GAAWG,GAAAA;AACf,EAAA,CAAA,CAAA,CAAA;AAIJ,EAAA,MAAMC,oBAA4C,EAAA;AAClD,EAAA,IAAIR,MAAMS,YAAAA,EAAc;AACpB,IAAA,MAAMC,aAAAA,GAAgB;AAAIX,MAAAA,GAAAA,UAAAA;AAAYC,MAAAA;;AACtC,IAAA,KAAA,MAAW,CAACW,GAAGC,eAAAA,CAAAA,IAAoBC,OAAOC,OAAAA,CAAQd,KAAAA,CAAMS,YAAY,CAAA,EAAG;AACnED,MAAAA,iBAAAA,CAAkBO,IAAAA,CACdvB,IAAIoB,eAAAA,EAAiBlB,OAAAA,EAASC,YAAYC,QAAAA,EAAUE,QAAAA,EAAUY,aAAAA,CAAAA,CAAAA;AAEtE,IAAA;AACJ,EAAA;AAEA,EAAA,OAAO,YAAA;AACH,IAAA,IAAI;AACA,MAAA,MAAMJ,OAAAA,CAAQU,IAAIR,iBAAAA,CAAkBS,GAAAA,CAAI,CAACC,CAAAA,KAAMA,CAAAA,EAAAA,CAAAA,CAAAA;AAC/C,MAAA,MAAMC,MAAAA,GAAS,MAAMzB,OAAAA,CAAQM,KAAAA,CAAAA;AAC7B,MAAA,IAAImB,MAAAA,EAAQ;AACP,QAAA,CAACrB,QAAAA,CAAiBqB,OAAOC,GAAG,CAAA,KAAM,EAAC,EAAGpB,KAAAA,CAAME,IAAI,CAAA,GAAIiB,MAAAA,CAAOE,KAAAA;AAChE,MAAA;AACAjB,MAAAA,QAAAA,EAAAA;AACA,MAAA,OAAON,QAAAA;AACX,IAAA,CAAA,CAAA,OAASwB,KAAAA,EAAY;AACjBC,MAAAA,OAAAA,CAAQD,KAAAA,CACJ,CAAA,UAAA,EAAavB,UAAAA,CAAWkB,GAAAA,CAAI,CAACO,CAAAA,KAAMA,CAAAA,CAAEtB,IAAI,CAAA,CAAEuB,IAAAA,CAAK,GAAA,CAAA;AAASH,EAAAA,KAAAA,EAAOI,OAAAA,CAAAA,CAAS,CAAA;AAE7E,MAAA,MAAMJ,KAAAA;AACV,IAAA;AACJ,EAAA,CAAA;AACJ,CAAA,EAnDmB,KAAA","file":"index.js","sourcesContent":["import type { Dependencies, DependencyNode } from '@layerzerolabs/dependency-graph';\n\n/**\n * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.\n * It is implicit in this definition that the registrar should also *register* values adhering to the schemata\n * of the graph.\n */\nexport interface Registrar<ReturnType> {\n    traverseDependencies: (rootNode: DependencyNode<any, any>) => Promise<ReturnType>;\n}\nexport type NodeHandlerFunction = (\n    node: DependencyNode<any, Dependencies>,\n) => Promise<{ key: string; value: any }>;\nexport type NodePreHandlerFunction = (\n    node: DependencyNode<any, Dependencies>,\n) => DependencyNode<any, Dependencies>;\n\n/**\n * Performs a depth-first-search on a tree of dependency nodes, and returns a function\n * that will call the handler for each node in the tree, ordered s.t. the handler of N\n * will be called only after the handlers of dependencies(N) have been called.\n * The resolver function will only call the handler once for each unique definition node.\n * The resolver function returns an object whose keys are the keys defined\n * by each of the handlers, and whose values are objects whose keys are the names\n * of the nodes resolved and whose values are the values defined by the handlers.\n * @param node the root node of the tree\n * @param handler a function that accepts a node and registers it\n * @param prehandler a function that accepts a node and returns a node. will be use to pre-process the graph\n * @returns a resolver function\n */\nexport const dfs = <DependencyName extends string, ReturnTypes>(\n    node: DependencyNode<DependencyName, Dependencies>,\n    handler: NodeHandlerFunction,\n    prehandler: NodePreHandlerFunction = (node) => node,\n    _visited: Map<string, Promise<void>> = new Map(),\n    _returns: ReturnTypes = {} as any,\n    _backtrack: DependencyNode<DependencyName, Dependencies>[] = [],\n): (() => Promise<ReturnTypes>) => {\n    const _node = prehandler(node);\n    if (_visited.has(_node.name)) {\n        return async () => {\n            await _visited.get(_node.name);\n            return _returns;\n        };\n    }\n    let resolver: (value: void | PromiseLike<void>) => void;\n\n    _visited.set(\n        _node.name,\n        new Promise<void>((res) => {\n            resolver = res;\n        }),\n    );\n\n    // Resolve dependencies first\n    const resolverFunctions: (() => Promise<any>)[] = [];\n    if (_node.dependencies) {\n        const nextBacktrack = [..._backtrack, _node];\n        for (const [_, dependencyValue] of Object.entries(_node.dependencies)) {\n            resolverFunctions.push(\n                dfs(dependencyValue, handler, prehandler, _visited, _returns, nextBacktrack),\n            );\n        }\n    }\n\n    return async () => {\n        try {\n            await Promise.all(resolverFunctions.map((f) => f()));\n            const regRes = await handler(_node);\n            if (regRes) {\n                ((_returns as any)[regRes.key] ??= {})[_node.name] = regRes.value;\n            }\n            resolver();\n            return _returns;\n        } catch (error: any) {\n            console.error(\n                `Failed at ${_backtrack.map((n) => n.name).join('/')}\\n${error?.message}`,\n            );\n            throw error;\n        }\n    };\n};\n"]}
+{"version":3,"sources":["../src/index.ts"],"names":["buildAncestorsByNodeName","node","prehandler","ancestorsByNodeName","Map","dependentCountByNodeName","initializeMaps","set","name","Set","dependencyValue","Object","values","dependencies","inDegree","get","has","queue","length","curNode","shift","preHandledDependency","push","childAncestry","nodeAncestry","add","ancestor","dfs","handler","_returns","nodeResolverPromises","resolveNode","prehandledNode","childrenPromises","Promise","all","ancestry","regRes","key","value"],"mappings":"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","file":"index.js","sourcesContent":["import type { DependencyNode } from '@layerzerolabs/dependency-graph';\n\n/**\n * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.\n * It is implicit in this definition that the registrar should also *register* values adhering to the schemata\n * of the graph.\n */\nexport interface Registrar<ReturnType> {\n    traverseDependencies: (rootNode: DependencyNode) => Promise<ReturnType>;\n}\nexport type NodeHandlerFunction = (\n    node: DependencyNode,\n    ancestry: DependencyNode[],\n) => Promise<{ key: string; value: any }>;\nexport type NodePreHandlerFunction = (node: DependencyNode) => DependencyNode;\n\nconst buildAncestorsByNodeName = (node: DependencyNode, prehandler: NodePreHandlerFunction) => {\n    const ancestorsByNodeName = new Map<string, Set<DependencyNode>>();\n    const dependentCountByNodeName = new Map<string, number>();\n\n    // If A depends on B and C, B depends on C, we initialize with:\n    // ancestorsByNodeName: { A: Set([]), B: Set([]), C: Set([]) }\n    // dependentsCountByNodeName: { B: 1, C: 2 }\n    const initializeMaps = (node: DependencyNode) => {\n        ancestorsByNodeName.set(node.name, new Set([]));\n        for (const dependencyValue of Object.values(node.dependencies)) {\n            const inDegree = dependentCountByNodeName.get(dependencyValue.name) || 0;\n            dependentCountByNodeName.set(dependencyValue.name, inDegree + 1);\n            if (!ancestorsByNodeName.has(dependencyValue.name)) {\n                initializeMaps(dependencyValue);\n            }\n        }\n    };\n    initializeMaps(node);\n\n    // topological sorted bfs exploration\n    // induction by level, initial level has correct initial state, build level + 1\n    // bfs is used to build ancestry correctly\n    // this should actually be a queue, but its probably fine for now\n    let queue = [prehandler(node)];\n    while (queue.length > 0) {\n        const curNode = queue.shift()!;\n\n        // add the new processable dependencies to the queue, update their state.\n        for (const dependencyValue of Object.values(curNode.dependencies)) {\n            const inDegree = dependentCountByNodeName.get(dependencyValue.name)!;\n            // We are the last edge missing in the graph for this dependency -> we can process it after us.\n            if (inDegree === 1) {\n                const preHandledDependency = prehandler(dependencyValue);\n                queue.push(preHandledDependency);\n            }\n            // Reduce the in-degree of the dependency -> it basically means that this edge got removed from the graph.\n            dependentCountByNodeName.set(dependencyValue.name, inDegree - 1);\n\n            // add our ancestry to them, js sets maintain order of insertion, this means their ancestors are in distance order due to BFS properties.\n            const childAncestry = ancestorsByNodeName.get(dependencyValue.name)!;\n            const nodeAncestry = ancestorsByNodeName.get(curNode.name)!;\n            childAncestry.add(curNode);\n            for (const ancestor of nodeAncestry) {\n                childAncestry.add(ancestor);\n            }\n        }\n    }\n\n    return ancestorsByNodeName;\n};\n\n/**\n * Performs a depth-first-search on a tree of dependency nodes, and returns a function\n * that will call the handler for each node in the tree, ordered s.t. the handler of N\n * will be called only after the handlers of dependencies(N) have been called.\n * The resolver function will only call the handler once for each unique definition node.\n * The resolver function returns an object whose keys are the keys defined\n * by each of the handlers, and whose values are objects whose keys are the names\n * of the nodes resolved and whose values are the values defined by the handlers.\n * @param node the root node of the tree\n * @param handler a function that accepts a node and registers it\n * @param prehandler a function that accepts a node and returns a node. will be use to pre-process the graph\n * @returns a resolver function\n */\nexport const dfs = <ReturnTypes>(\n    node: DependencyNode,\n    handler: NodeHandlerFunction,\n    prehandler: NodePreHandlerFunction = (node) => node,\n    _returns: ReturnTypes = {} as any,\n): (() => Promise<ReturnTypes>) => {\n    const ancestorsByNodeName = buildAncestorsByNodeName(node, prehandler);\n\n    // Maintains Map<node.name, Promise<void>> -> the promise to resolve the node, for all nodes.\n    const nodeResolverPromises = new Map<string, Promise<void>>();\n    const resolveNode = async (node: DependencyNode) => {\n        const prehandledNode = prehandler(node);\n        // first wait for all its children\n        const childrenPromises = [];\n        for (const dependencyValue of Object.values(prehandledNode.dependencies)) {\n            // Grab the cached promise or create it, we want to have only 1 handler promise for each node.\n            if (!nodeResolverPromises.has(dependencyValue.name)) {\n                nodeResolverPromises.set(dependencyValue.name, resolveNode(dependencyValue));\n            }\n            childrenPromises.push(nodeResolverPromises.get(dependencyValue.name)!);\n        }\n        await Promise.all(childrenPromises);\n\n        // Then, you can process yourself\n        const ancestry = ancestorsByNodeName.get(prehandledNode.name)!;\n        const regRes = await handler(node, [...ancestry]);\n        if (regRes) {\n            ((_returns as any)[regRes.key] ??= {})[prehandledNode.name] = regRes.value;\n        }\n    };\n\n    return async () => {\n        await resolveNode(node);\n        return _returns;\n    };\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/dfs",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -14,13 +14,13 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "@layerzerolabs/dependency-graph": "0.0.19"
+    "@layerzerolabs/dependency-graph": "0.0.21"
   },
   "devDependencies": {
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/typescript-configuration": "0.0.19",
-    "@layerzerolabs/tsup-configuration": "0.0.19"
+    "@layerzerolabs/tsup-configuration": "0.0.21",
+    "@layerzerolabs/typescript-configuration": "0.0.21"
   },
   "publishConfig": {
     "access": "restricted",

package/src/index.ts

@@ -1,4 +1,4 @@
-import type { Dependencies, DependencyNode } from '@layerzerolabs/dependency-graph';
+import type { DependencyNode } from '@layerzerolabs/dependency-graph';
 
 /**
  * A registrar is a simple interface for an object that provides the ability to traverse the dependency graph.
@@ -6,14 +6,64 @@ import type { Dependencies, DependencyNode } from '@layerzerolabs/dependency-gra
  * of the graph.
  */
 export interface Registrar<ReturnType> {
-    traverseDependencies: (rootNode: DependencyNode<any, any>) => Promise<ReturnType>;
+    traverseDependencies: (rootNode: DependencyNode) => Promise<ReturnType>;
 }
 export type NodeHandlerFunction = (
-    node: DependencyNode<any, Dependencies>,
+    node: DependencyNode,
+    ancestry: DependencyNode[],
 ) => Promise<{ key: string; value: any }>;
-export type NodePreHandlerFunction = (
-    node: DependencyNode<any, Dependencies>,
-) => DependencyNode<any, Dependencies>;
+export type NodePreHandlerFunction = (node: DependencyNode) => DependencyNode;
+
+const buildAncestorsByNodeName = (node: DependencyNode, prehandler: NodePreHandlerFunction) => {
+    const ancestorsByNodeName = new Map<string, Set<DependencyNode>>();
+    const dependentCountByNodeName = new Map<string, number>();
+
+    // If A depends on B and C, B depends on C, we initialize with:
+    // ancestorsByNodeName: { A: Set([]), B: Set([]), C: Set([]) }
+    // dependentsCountByNodeName: { B: 1, C: 2 }
+    const initializeMaps = (node: DependencyNode) => {
+        ancestorsByNodeName.set(node.name, new Set([]));
+        for (const dependencyValue of Object.values(node.dependencies)) {
+            const inDegree = dependentCountByNodeName.get(dependencyValue.name) || 0;
+            dependentCountByNodeName.set(dependencyValue.name, inDegree + 1);
+            if (!ancestorsByNodeName.has(dependencyValue.name)) {
+                initializeMaps(dependencyValue);
+            }
+        }
+    };
+    initializeMaps(node);
+
+    // topological sorted bfs exploration
+    // induction by level, initial level has correct initial state, build level + 1
+    // bfs is used to build ancestry correctly
+    // this should actually be a queue, but its probably fine for now
+    let queue = [prehandler(node)];
+    while (queue.length > 0) {
+        const curNode = queue.shift()!;
+
+        // add the new processable dependencies to the queue, update their state.
+        for (const dependencyValue of Object.values(curNode.dependencies)) {
+            const inDegree = dependentCountByNodeName.get(dependencyValue.name)!;
+            // We are the last edge missing in the graph for this dependency -> we can process it after us.
+            if (inDegree === 1) {
+                const preHandledDependency = prehandler(dependencyValue);
+                queue.push(preHandledDependency);
+            }
+            // Reduce the in-degree of the dependency -> it basically means that this edge got removed from the graph.
+            dependentCountByNodeName.set(dependencyValue.name, inDegree - 1);
+
+            // add our ancestry to them, js sets maintain order of insertion, this means their ancestors are in distance order due to BFS properties.
+            const childAncestry = ancestorsByNodeName.get(dependencyValue.name)!;
+            const nodeAncestry = ancestorsByNodeName.get(curNode.name)!;
+            childAncestry.add(curNode);
+            for (const ancestor of nodeAncestry) {
+                childAncestry.add(ancestor);
+            }
+        }
+    }
+
+    return ancestorsByNodeName;
+};
 
 /**
  * Performs a depth-first-search on a tree of dependency nodes, and returns a function
@@ -28,55 +78,39 @@ export type NodePreHandlerFunction = (
  * @param prehandler a function that accepts a node and returns a node. will be use to pre-process the graph
  * @returns a resolver function
  */
-export const dfs = <DependencyName extends string, ReturnTypes>(
-    node: DependencyNode<DependencyName, Dependencies>,
+export const dfs = <ReturnTypes>(
+    node: DependencyNode,
     handler: NodeHandlerFunction,
     prehandler: NodePreHandlerFunction = (node) => node,
-    _visited: Map<string, Promise<void>> = new Map(),
     _returns: ReturnTypes = {} as any,
-    _backtrack: DependencyNode<DependencyName, Dependencies>[] = [],
 ): (() => Promise<ReturnTypes>) => {
-    const _node = prehandler(node);
-    if (_visited.has(_node.name)) {
-        return async () => {
-            await _visited.get(_node.name);
-            return _returns;
-        };
-    }
-    let resolver: (value: void | PromiseLike<void>) => void;
+    const ancestorsByNodeName = buildAncestorsByNodeName(node, prehandler);
 
-    _visited.set(
-        _node.name,
-        new Promise<void>((res) => {
-            resolver = res;
-        }),
-    );
+    // Maintains Map<node.name, Promise<void>> -> the promise to resolve the node, for all nodes.
+    const nodeResolverPromises = new Map<string, Promise<void>>();
+    const resolveNode = async (node: DependencyNode) => {
+        const prehandledNode = prehandler(node);
+        // first wait for all its children
+        const childrenPromises = [];
+        for (const dependencyValue of Object.values(prehandledNode.dependencies)) {
+            // Grab the cached promise or create it, we want to have only 1 handler promise for each node.
+            if (!nodeResolverPromises.has(dependencyValue.name)) {
+                nodeResolverPromises.set(dependencyValue.name, resolveNode(dependencyValue));
+            }
+            childrenPromises.push(nodeResolverPromises.get(dependencyValue.name)!);
+        }
+        await Promise.all(childrenPromises);
 
-    // Resolve dependencies first
-    const resolverFunctions: (() => Promise<any>)[] = [];
-    if (_node.dependencies) {
-        const nextBacktrack = [..._backtrack, _node];
-        for (const [_, dependencyValue] of Object.entries(_node.dependencies)) {
-            resolverFunctions.push(
-                dfs(dependencyValue, handler, prehandler, _visited, _returns, nextBacktrack),
-            );
+        // Then, you can process yourself
+        const ancestry = ancestorsByNodeName.get(prehandledNode.name)!;
+        const regRes = await handler(node, [...ancestry]);
+        if (regRes) {
+            ((_returns as any)[regRes.key] ??= {})[prehandledNode.name] = regRes.value;
         }
-    }
+    };
 
     return async () => {
-        try {
-            await Promise.all(resolverFunctions.map((f) => f()));
-            const regRes = await handler(_node);
-            if (regRes) {
-                ((_returns as any)[regRes.key] ??= {})[_node.name] = regRes.value;
-            }
-            resolver();
-            return _returns;
-        } catch (error: any) {
-            console.error(
-                `Failed at ${_backtrack.map((n) => n.name).join('/')}\n${error?.message}`,
-            );
-            throw error;
-        }
+        await resolveNode(node);
+        return _returns;
     };
 };

package/test/dfs.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from 'vitest';
 
 import { Dependencies, DependencyNode } from '@layerzerolabs/dependency-graph';
 
-import { dfs } from '../src/';
+import { dfs } from '../src';
 
 const SimpleClassA = class<
     Name extends string,