@layerzerolabs/dfs 0.0.20 → 0.0.22

package/.turbo/turbo-build.log

@@ -10,9 +10,9 @@
 CLI Cleaning output folder
 CJS Build start
 ESM Build start
-CJS dist/index.cjs     2.75 KB
-CJS dist/index.cjs.map 8.89 KB
-CJS ⚡️ Build success in 88ms
-ESM dist/index.js     2.73 KB
-ESM dist/index.js.map 8.88 KB
-ESM ⚡️ Build success in 88ms
+CJS dist/index.cjs     3.27 KB
+CJS dist/index.cjs.map 11.45 KB
+CJS ⚡️ Build success in 86ms
+ESM dist/index.js     3.25 KB
+ESM dist/index.js.map 11.45 KB
+ESM ⚡️ Build success in 86ms

package/.turbo/turbo-test.log

@@ -5,11 +5,12 @@
 
  RUN  v3.2.3 /home/runner/work/monorepo-internal/monorepo-internal/packages/framework/dfs
 
- ✓ test/dfs.test.ts (3 tests) 307ms
-   ✓ DI Depth-first-search > The handlers for each of a node's dependencies should be completed before that node  303ms
+ ✓ test/dfs.test.ts (7 tests) 644ms
+   ✓ DI Depth-first-search > The handlers for each of a node's dependencies should be completed before that node  304ms
+   ✓ DI Ancestry - randomized DAG property > random DAGs: ancestry includes all ancestors and distances are non-decreasing  319ms
 
  Test Files  1 passed (1)
-      Tests  3 passed (3)
-   Start at  22:36:00
-   Duration  927ms (transform 80ms, setup 0ms, collect 70ms, tests 307ms, environment 0ms, prepare 139ms)
+      Tests  7 passed (7)
+   Start at  13:52:03
+   Duration  1.51s (transform 286ms, setup 0ms, collect 376ms, tests 644ms, environment 0ms, prepare 199ms)
 

package/dist/index.cjs

@@ -4,17 +4,22 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/index.ts
-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);
-      }
+var mergeAncestorDistances = /* @__PURE__ */ __name((parentDistances, childDistances) => {
+  for (const [ancestor, parentDist] of parentDistances) {
+    const candidate = parentDist + 1;
+    const current = childDistances.get(ancestor) || Infinity;
+    childDistances.set(ancestor, Math.min(current, candidate));
+  }
+}, "mergeAncestorDistances");
+var buildAncestryDistanceIndex = /* @__PURE__ */ __name((node, prehandler) => {
+  const ancestryDistanceIndex = /* @__PURE__ */ new Map();
+  const inDegreeByNodeName = /* @__PURE__ */ new Map();
+  const initializeMaps = /* @__PURE__ */ __name((cur) => {
+    ancestryDistanceIndex.set(cur.name, /* @__PURE__ */ new Map());
+    for (const dep of Object.values(cur.dependencies)) {
+      const inDegree = inDegreeByNodeName.get(dep.name) || 0;
+      inDegreeByNodeName.set(dep.name, inDegree + 1);
+      if (!ancestryDistanceIndex.has(dep.name)) initializeMaps(dep);
     }
   }, "initializeMaps");
   initializeMaps(node);
@@ -23,24 +28,32 @@ var buildAncestorsByNodeName = /* @__PURE__ */ __name((node, prehandler) => {
   ];
   while (queue.length > 0) {
     const curNode = queue.shift();
-    for (const dependencyValue of Object.values(curNode.dependencies)) {
-      const inDegree = dependentCountByNodeName.get(dependencyValue.name);
+    const currentMinimalDistances = new Map([
+      [
+        curNode,
+        0
+      ],
+      ...ancestryDistanceIndex.get(curNode.name)
+    ]);
+    for (const dep of Object.values(curNode.dependencies)) {
+      const inDegree = inDegreeByNodeName.get(dep.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);
-      for (const ancestor of nodeAncestry) {
-        childAncestry.add(ancestor);
+        queue.push(prehandler(dep));
       }
+      inDegreeByNodeName.set(dep.name, inDegree - 1);
+      const childDistances = ancestryDistanceIndex.get(dep.name);
+      mergeAncestorDistances(currentMinimalDistances, childDistances);
     }
   }
-  return ancestorsByNodeName;
-}, "buildAncestorsByNodeName");
+  for (const [nodeName, inDegree] of inDegreeByNodeName) {
+    if (inDegree !== 0) {
+      throw new Error(`node ${nodeName} has in-degree ${inDegree}, this indicates a cycle in the graph containing the node`);
+    }
+  }
+  return ancestryDistanceIndex;
+}, "buildAncestryDistanceIndex");
 var dfs = /* @__PURE__ */ __name((node, handler, prehandler = (node2) => node2, _returns = {}) => {
-  const ancestorsByNodeName = buildAncestorsByNodeName(node, prehandler);
+  const ancestryDistanceIndex = buildAncestryDistanceIndex(node, prehandler);
   const nodeResolverPromises = /* @__PURE__ */ new Map();
   const resolveNode = /* @__PURE__ */ __name(async (node2) => {
     const prehandledNode = prehandler(node2);
@@ -52,10 +65,9 @@ var dfs = /* @__PURE__ */ __name((node, handler, prehandler = (node2) => node2,
       childrenPromises.push(nodeResolverPromises.get(dependencyValue.name));
     }
     await Promise.all(childrenPromises);
-    const ancestry = ancestorsByNodeName.get(prehandledNode.name);
-    const regRes = await handler(node2, [
-      ...ancestry
-    ]);
+    const minimalDistances = ancestryDistanceIndex.get(prehandledNode.name);
+    const sortedAncestors = Array.from(minimalDistances.entries()).sort((a, b) => a[1] - b[1]);
+    const regRes = await handler(node2, sortedAncestors.map(([node3, _]) => node3));
     if (regRes) {
       (_returns[regRes.key] ??= {})[prehandledNode.name] = regRes.value;
     }

package/dist/index.cjs.map

@@ -1 +1 @@
-{"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","ancestor","add","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            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"]}
+{"version":3,"sources":["../src/index.ts"],"names":["mergeAncestorDistances","parentDistances","childDistances","ancestor","parentDist","candidate","current","get","Infinity","set","Math","min","buildAncestryDistanceIndex","node","prehandler","ancestryDistanceIndex","Map","inDegreeByNodeName","initializeMaps","cur","name","dep","Object","values","dependencies","inDegree","has","queue","length","curNode","shift","currentMinimalDistances","push","nodeName","Error","dfs","handler","_returns","nodeResolverPromises","resolveNode","prehandledNode","childrenPromises","dependencyValue","Promise","all","minimalDistances","sortedAncestors","Array","from","entries","sort","a","b","regRes","map","_","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\n// Map of ancestor node -> minimal hop distance\ntype AncestorDistanceByNode = Map<DependencyNode, number>;\n// Index from node name -> its ancestor distance map\ntype AncestryDistanceIndex = Map<string, AncestorDistanceByNode>;\n\n/**\n * In-place merge of minimal ancestry distances.\n *\n * childDistances holds minimal distances from the child to each ancestor (keyed by DependencyNode).\n * For every entry in parentDistances, we update the child's map with (parentDist + 1),\n * keeping the minimal value if the ancestor already exists.\n */\nconst mergeAncestorDistances = (\n    parentDistances: AncestorDistanceByNode,\n    childDistances: AncestorDistanceByNode,\n) => {\n    for (const [ancestor, parentDist] of parentDistances) {\n        const candidate = parentDist + 1;\n        const current = childDistances.get(ancestor) || Infinity;\n        childDistances.set(ancestor, Math.min(current, candidate));\n    }\n};\n\n/**\n * Builds a minimal ancestry distance index for all nodes reachable from the root.\n *\n * Returns a Map: node.name -> Map<DependencyNode, distance> where distance is the minimal hop count\n * from the node to that ancestor. We perform a Kahn-style BFS over the DAG, and for each edge\n * curNode -> dep we merge curNode's minimal distances into the dependency with +1 hop and take the minimum.\n */\nconst buildAncestryDistanceIndex = (\n    node: DependencyNode,\n    prehandler: NodePreHandlerFunction,\n): AncestryDistanceIndex => {\n    const ancestryDistanceIndex: AncestryDistanceIndex = new Map();\n    const inDegreeByNodeName = new Map<string, number>();\n\n    // If A depends on B and C, B depends on C, we initialize with:\n    // ancestryDistanceIndex: { A: Map(), B: Map(), C: Map() }\n    // inDegreeByNodeName: { B: 1, C: 2 }\n    const initializeMaps = (cur: DependencyNode) => {\n        ancestryDistanceIndex.set(cur.name, new Map());\n        for (const dep of Object.values(cur.dependencies)) {\n            const inDegree = inDegreeByNodeName.get(dep.name) || 0;\n            inDegreeByNodeName.set(dep.name, inDegree + 1);\n            if (!ancestryDistanceIndex.has(dep.name)) initializeMaps(dep);\n        }\n    };\n    initializeMaps(node);\n\n    // Kahn-style topological BFS accumulating minimal distance ancestors\n    let queue = [prehandler(node)];\n    while (queue.length > 0) {\n        const curNode = queue.shift()!;\n        // Include self with distance 0, then extend with the already known minimal distances\n        const currentMinimalDistances: AncestorDistanceByNode = new Map([\n            [curNode, 0],\n            ...ancestryDistanceIndex.get(curNode.name)!,\n        ]);\n        // Add the new processable dependencies to the queue, update their state.\n        for (const dep of Object.values(curNode.dependencies)) {\n            const inDegree = inDegreeByNodeName.get(dep.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                queue.push(prehandler(dep));\n            }\n            // Reduce the in-degree of the dependency -> it basically means that this edge got removed from the graph.\n            inDegreeByNodeName.set(dep.name, inDegree - 1);\n\n            // Merge curNode's minimal distances (+1 hop) into the dependency's minimal distances\n            const childDistances = ancestryDistanceIndex.get(dep.name)!;\n            mergeAncestorDistances(currentMinimalDistances, childDistances);\n        }\n    }\n\n    for (const [nodeName, inDegree] of inDegreeByNodeName) {\n        if (inDegree !== 0) {\n            throw new Error(\n                `node ${nodeName} has in-degree ${inDegree}, this indicates a cycle in the graph containing the node`,\n            );\n        }\n    }\n\n    return ancestryDistanceIndex;\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 node's ancestors are sorted by non-decreasing minimal distance.\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 used 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 ancestryDistanceIndex = buildAncestryDistanceIndex(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. Build ancestry sorted by non-decreasing minimal distance.\n        const minimalDistances = ancestryDistanceIndex.get(prehandledNode.name)!;\n        const sortedAncestors = Array.from(minimalDistances.entries()).sort((a, b) => a[1] - b[1]);\n        const regRes = await handler(\n            node,\n            sortedAncestors.map(([node, _]) => node),\n        );\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

@@ -16,13 +16,14 @@ 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
  * will be called only after the handlers of dependencies(N) have been called.
+ * The node's ancestors are sorted by non-decreasing minimal distance.
  * The resolver function will only call the handler once for each unique definition node.
  * The resolver function returns an object whose keys are the keys defined
  * by each of the handlers, and whose values are objects whose keys are the names
  * of the nodes resolved and whose values are the values defined by the handlers.
  * @param node the root node of the tree
  * @param handler a function that accepts a node and registers it
- * @param prehandler a function that accepts a node and returns a node. will be use to pre-process the graph
+ * @param prehandler a function that accepts a node and returns a node. Will be used to pre-process the graph
  * @returns a resolver function
  */
 export declare const dfs: <ReturnTypes>(node: DependencyNode, handler: NodeHandlerFunction, prehandler?: NodePreHandlerFunction, _returns?: ReturnTypes) => (() => Promise<ReturnTypes>);

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,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;AAoD9E;;;;;;;;;;;;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"}
+{"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;AAwF9E;;;;;;;;;;;;;GAaG;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,CAkC7B,CAAC"}

package/dist/index.js

@@ -2,17 +2,22 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/index.ts
-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);
-      }
+var mergeAncestorDistances = /* @__PURE__ */ __name((parentDistances, childDistances) => {
+  for (const [ancestor, parentDist] of parentDistances) {
+    const candidate = parentDist + 1;
+    const current = childDistances.get(ancestor) || Infinity;
+    childDistances.set(ancestor, Math.min(current, candidate));
+  }
+}, "mergeAncestorDistances");
+var buildAncestryDistanceIndex = /* @__PURE__ */ __name((node, prehandler) => {
+  const ancestryDistanceIndex = /* @__PURE__ */ new Map();
+  const inDegreeByNodeName = /* @__PURE__ */ new Map();
+  const initializeMaps = /* @__PURE__ */ __name((cur) => {
+    ancestryDistanceIndex.set(cur.name, /* @__PURE__ */ new Map());
+    for (const dep of Object.values(cur.dependencies)) {
+      const inDegree = inDegreeByNodeName.get(dep.name) || 0;
+      inDegreeByNodeName.set(dep.name, inDegree + 1);
+      if (!ancestryDistanceIndex.has(dep.name)) initializeMaps(dep);
     }
   }, "initializeMaps");
   initializeMaps(node);
@@ -21,24 +26,32 @@ var buildAncestorsByNodeName = /* @__PURE__ */ __name((node, prehandler) => {
   ];
   while (queue.length > 0) {
     const curNode = queue.shift();
-    for (const dependencyValue of Object.values(curNode.dependencies)) {
-      const inDegree = dependentCountByNodeName.get(dependencyValue.name);
+    const currentMinimalDistances = new Map([
+      [
+        curNode,
+        0
+      ],
+      ...ancestryDistanceIndex.get(curNode.name)
+    ]);
+    for (const dep of Object.values(curNode.dependencies)) {
+      const inDegree = inDegreeByNodeName.get(dep.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);
-      for (const ancestor of nodeAncestry) {
-        childAncestry.add(ancestor);
+        queue.push(prehandler(dep));
       }
+      inDegreeByNodeName.set(dep.name, inDegree - 1);
+      const childDistances = ancestryDistanceIndex.get(dep.name);
+      mergeAncestorDistances(currentMinimalDistances, childDistances);
     }
   }
-  return ancestorsByNodeName;
-}, "buildAncestorsByNodeName");
+  for (const [nodeName, inDegree] of inDegreeByNodeName) {
+    if (inDegree !== 0) {
+      throw new Error(`node ${nodeName} has in-degree ${inDegree}, this indicates a cycle in the graph containing the node`);
+    }
+  }
+  return ancestryDistanceIndex;
+}, "buildAncestryDistanceIndex");
 var dfs = /* @__PURE__ */ __name((node, handler, prehandler = (node2) => node2, _returns = {}) => {
-  const ancestorsByNodeName = buildAncestorsByNodeName(node, prehandler);
+  const ancestryDistanceIndex = buildAncestryDistanceIndex(node, prehandler);
   const nodeResolverPromises = /* @__PURE__ */ new Map();
   const resolveNode = /* @__PURE__ */ __name(async (node2) => {
     const prehandledNode = prehandler(node2);
@@ -50,10 +63,9 @@ var dfs = /* @__PURE__ */ __name((node, handler, prehandler = (node2) => node2,
       childrenPromises.push(nodeResolverPromises.get(dependencyValue.name));
     }
     await Promise.all(childrenPromises);
-    const ancestry = ancestorsByNodeName.get(prehandledNode.name);
-    const regRes = await handler(node2, [
-      ...ancestry
-    ]);
+    const minimalDistances = ancestryDistanceIndex.get(prehandledNode.name);
+    const sortedAncestors = Array.from(minimalDistances.entries()).sort((a, b) => a[1] - b[1]);
+    const regRes = await handler(node2, sortedAncestors.map(([node3, _]) => node3));
     if (regRes) {
       (_returns[regRes.key] ??= {})[prehandledNode.name] = regRes.value;
     }

package/dist/index.js.map

@@ -1 +1 @@
-{"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","ancestor","add","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            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"]}
+{"version":3,"sources":["../src/index.ts"],"names":["mergeAncestorDistances","parentDistances","childDistances","ancestor","parentDist","candidate","current","get","Infinity","set","Math","min","buildAncestryDistanceIndex","node","prehandler","ancestryDistanceIndex","Map","inDegreeByNodeName","initializeMaps","cur","name","dep","Object","values","dependencies","inDegree","has","queue","length","curNode","shift","currentMinimalDistances","push","nodeName","Error","dfs","handler","_returns","nodeResolverPromises","resolveNode","prehandledNode","childrenPromises","dependencyValue","Promise","all","minimalDistances","sortedAncestors","Array","from","entries","sort","a","b","regRes","map","_","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\n// Map of ancestor node -> minimal hop distance\ntype AncestorDistanceByNode = Map<DependencyNode, number>;\n// Index from node name -> its ancestor distance map\ntype AncestryDistanceIndex = Map<string, AncestorDistanceByNode>;\n\n/**\n * In-place merge of minimal ancestry distances.\n *\n * childDistances holds minimal distances from the child to each ancestor (keyed by DependencyNode).\n * For every entry in parentDistances, we update the child's map with (parentDist + 1),\n * keeping the minimal value if the ancestor already exists.\n */\nconst mergeAncestorDistances = (\n    parentDistances: AncestorDistanceByNode,\n    childDistances: AncestorDistanceByNode,\n) => {\n    for (const [ancestor, parentDist] of parentDistances) {\n        const candidate = parentDist + 1;\n        const current = childDistances.get(ancestor) || Infinity;\n        childDistances.set(ancestor, Math.min(current, candidate));\n    }\n};\n\n/**\n * Builds a minimal ancestry distance index for all nodes reachable from the root.\n *\n * Returns a Map: node.name -> Map<DependencyNode, distance> where distance is the minimal hop count\n * from the node to that ancestor. We perform a Kahn-style BFS over the DAG, and for each edge\n * curNode -> dep we merge curNode's minimal distances into the dependency with +1 hop and take the minimum.\n */\nconst buildAncestryDistanceIndex = (\n    node: DependencyNode,\n    prehandler: NodePreHandlerFunction,\n): AncestryDistanceIndex => {\n    const ancestryDistanceIndex: AncestryDistanceIndex = new Map();\n    const inDegreeByNodeName = new Map<string, number>();\n\n    // If A depends on B and C, B depends on C, we initialize with:\n    // ancestryDistanceIndex: { A: Map(), B: Map(), C: Map() }\n    // inDegreeByNodeName: { B: 1, C: 2 }\n    const initializeMaps = (cur: DependencyNode) => {\n        ancestryDistanceIndex.set(cur.name, new Map());\n        for (const dep of Object.values(cur.dependencies)) {\n            const inDegree = inDegreeByNodeName.get(dep.name) || 0;\n            inDegreeByNodeName.set(dep.name, inDegree + 1);\n            if (!ancestryDistanceIndex.has(dep.name)) initializeMaps(dep);\n        }\n    };\n    initializeMaps(node);\n\n    // Kahn-style topological BFS accumulating minimal distance ancestors\n    let queue = [prehandler(node)];\n    while (queue.length > 0) {\n        const curNode = queue.shift()!;\n        // Include self with distance 0, then extend with the already known minimal distances\n        const currentMinimalDistances: AncestorDistanceByNode = new Map([\n            [curNode, 0],\n            ...ancestryDistanceIndex.get(curNode.name)!,\n        ]);\n        // Add the new processable dependencies to the queue, update their state.\n        for (const dep of Object.values(curNode.dependencies)) {\n            const inDegree = inDegreeByNodeName.get(dep.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                queue.push(prehandler(dep));\n            }\n            // Reduce the in-degree of the dependency -> it basically means that this edge got removed from the graph.\n            inDegreeByNodeName.set(dep.name, inDegree - 1);\n\n            // Merge curNode's minimal distances (+1 hop) into the dependency's minimal distances\n            const childDistances = ancestryDistanceIndex.get(dep.name)!;\n            mergeAncestorDistances(currentMinimalDistances, childDistances);\n        }\n    }\n\n    for (const [nodeName, inDegree] of inDegreeByNodeName) {\n        if (inDegree !== 0) {\n            throw new Error(\n                `node ${nodeName} has in-degree ${inDegree}, this indicates a cycle in the graph containing the node`,\n            );\n        }\n    }\n\n    return ancestryDistanceIndex;\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 node's ancestors are sorted by non-decreasing minimal distance.\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 used 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 ancestryDistanceIndex = buildAncestryDistanceIndex(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. Build ancestry sorted by non-decreasing minimal distance.\n        const minimalDistances = ancestryDistanceIndex.get(prehandledNode.name)!;\n        const sortedAncestors = Array.from(minimalDistances.entries()).sort((a, b) => a[1] - b[1]);\n        const regRes = await handler(\n            node,\n            sortedAncestors.map(([node, _]) => node),\n        );\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.20",
+  "version": "0.0.22",
   "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.20"
+    "@layerzerolabs/dependency-graph": "0.0.22"
   },
   "devDependencies": {
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/typescript-configuration": "0.0.20",
-    "@layerzerolabs/tsup-configuration": "0.0.20"
+    "@layerzerolabs/tsup-configuration": "0.0.22",
+    "@layerzerolabs/typescript-configuration": "0.0.22"
   },
   "publishConfig": {
     "access": "restricted",

package/src/index.ts

@@ -14,67 +14,104 @@ export type NodeHandlerFunction = (
 ) => Promise<{ key: string; value: any }>;
 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>();
+// Map of ancestor node -> minimal hop distance
+type AncestorDistanceByNode = Map<DependencyNode, number>;
+// Index from node name -> its ancestor distance map
+type AncestryDistanceIndex = Map<string, AncestorDistanceByNode>;
+
+/**
+ * In-place merge of minimal ancestry distances.
+ *
+ * childDistances holds minimal distances from the child to each ancestor (keyed by DependencyNode).
+ * For every entry in parentDistances, we update the child's map with (parentDist + 1),
+ * keeping the minimal value if the ancestor already exists.
+ */
+const mergeAncestorDistances = (
+    parentDistances: AncestorDistanceByNode,
+    childDistances: AncestorDistanceByNode,
+) => {
+    for (const [ancestor, parentDist] of parentDistances) {
+        const candidate = parentDist + 1;
+        const current = childDistances.get(ancestor) || Infinity;
+        childDistances.set(ancestor, Math.min(current, candidate));
+    }
+};
+
+/**
+ * Builds a minimal ancestry distance index for all nodes reachable from the root.
+ *
+ * Returns a Map: node.name -> Map<DependencyNode, distance> where distance is the minimal hop count
+ * from the node to that ancestor. We perform a Kahn-style BFS over the DAG, and for each edge
+ * curNode -> dep we merge curNode's minimal distances into the dependency with +1 hop and take the minimum.
+ */
+const buildAncestryDistanceIndex = (
+    node: DependencyNode,
+    prehandler: NodePreHandlerFunction,
+): AncestryDistanceIndex => {
+    const ancestryDistanceIndex: AncestryDistanceIndex = new Map();
+    const inDegreeByNodeName = 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);
-            }
+    // ancestryDistanceIndex: { A: Map(), B: Map(), C: Map() }
+    // inDegreeByNodeName: { B: 1, C: 2 }
+    const initializeMaps = (cur: DependencyNode) => {
+        ancestryDistanceIndex.set(cur.name, new Map());
+        for (const dep of Object.values(cur.dependencies)) {
+            const inDegree = inDegreeByNodeName.get(dep.name) || 0;
+            inDegreeByNodeName.set(dep.name, inDegree + 1);
+            if (!ancestryDistanceIndex.has(dep.name)) initializeMaps(dep);
         }
     };
     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
+    // Kahn-style topological BFS accumulating minimal distance ancestors
     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)!;
+        // Include self with distance 0, then extend with the already known minimal distances
+        const currentMinimalDistances: AncestorDistanceByNode = new Map([
+            [curNode, 0],
+            ...ancestryDistanceIndex.get(curNode.name)!,
+        ]);
+        // Add the new processable dependencies to the queue, update their state.
+        for (const dep of Object.values(curNode.dependencies)) {
+            const inDegree = inDegreeByNodeName.get(dep.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);
+                queue.push(prehandler(dep));
             }
             // Reduce the in-degree of the dependency -> it basically means that this edge got removed from the graph.
-            dependentCountByNodeName.set(dependencyValue.name, inDegree - 1);
+            inDegreeByNodeName.set(dep.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)!;
-            for (const ancestor of nodeAncestry) {
-                childAncestry.add(ancestor);
-            }
+            // Merge curNode's minimal distances (+1 hop) into the dependency's minimal distances
+            const childDistances = ancestryDistanceIndex.get(dep.name)!;
+            mergeAncestorDistances(currentMinimalDistances, childDistances);
+        }
+    }
+
+    for (const [nodeName, inDegree] of inDegreeByNodeName) {
+        if (inDegree !== 0) {
+            throw new Error(
+                `node ${nodeName} has in-degree ${inDegree}, this indicates a cycle in the graph containing the node`,
+            );
         }
     }
 
-    return ancestorsByNodeName;
+    return ancestryDistanceIndex;
 };
 
 /**
  * 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
  * will be called only after the handlers of dependencies(N) have been called.
+ * The node's ancestors are sorted by non-decreasing minimal distance.
  * The resolver function will only call the handler once for each unique definition node.
  * The resolver function returns an object whose keys are the keys defined
  * by each of the handlers, and whose values are objects whose keys are the names
  * of the nodes resolved and whose values are the values defined by the handlers.
  * @param node the root node of the tree
  * @param handler a function that accepts a node and registers it
- * @param prehandler a function that accepts a node and returns a node. will be use to pre-process the graph
+ * @param prehandler a function that accepts a node and returns a node. Will be used to pre-process the graph
  * @returns a resolver function
  */
 export const dfs = <ReturnTypes>(
@@ -83,7 +120,7 @@ export const dfs = <ReturnTypes>(
     prehandler: NodePreHandlerFunction = (node) => node,
     _returns: ReturnTypes = {} as any,
 ): (() => Promise<ReturnTypes>) => {
-    const ancestorsByNodeName = buildAncestorsByNodeName(node, prehandler);
+    const ancestryDistanceIndex = buildAncestryDistanceIndex(node, prehandler);
 
     // Maintains Map<node.name, Promise<void>> -> the promise to resolve the node, for all nodes.
     const nodeResolverPromises = new Map<string, Promise<void>>();
@@ -100,9 +137,13 @@ export const dfs = <ReturnTypes>(
         }
         await Promise.all(childrenPromises);
 
-        // Then, you can process yourself
-        const ancestry = ancestorsByNodeName.get(prehandledNode.name)!;
-        const regRes = await handler(node, [...ancestry]);
+        // Then, you can process yourself. Build ancestry sorted by non-decreasing minimal distance.
+        const minimalDistances = ancestryDistanceIndex.get(prehandledNode.name)!;
+        const sortedAncestors = Array.from(minimalDistances.entries()).sort((a, b) => a[1] - b[1]);
+        const regRes = await handler(
+            node,
+            sortedAncestors.map(([node, _]) => node),
+        );
         if (regRes) {
             ((_returns as any)[regRes.key] ??= {})[prehandledNode.name] = regRes.value;
         }

package/test/dfs.test.ts

@@ -110,3 +110,221 @@ describe('DI Depth-first-search', () => {
         expect(count).toBe(4);
     });
 });
+
+describe('DI Ancestry - inclusion and distance order', () => {
+    test('C -> B -> A', async () => {
+        const { ancestry } = await dfs<{ ancestry: Record<string, string[]> }>(
+            mySimpleClassC,
+            async (_node, ancestry) => {
+                return { key: 'ancestry', value: ancestry.map((n) => n.name) };
+            },
+        )();
+
+        expect(ancestry.MySimpleClassC).toStrictEqual([]);
+        expect(ancestry.MySimpleClassB).toStrictEqual(['MySimpleClassC']);
+        expect(ancestry.MySimpleClassA).toStrictEqual(['MySimpleClassB', 'MySimpleClassC']);
+    });
+
+    test('D -> (C, B, A) with C -> B -> A', async () => {
+        const { ancestry } = await dfs<{ ancestry: Record<string, string[]> }>(
+            mySimpleClassD,
+            async (_node, ancestry) => {
+                return { key: 'ancestry', value: ancestry.map((n) => n.name) };
+            },
+        )();
+
+        // D is the root
+        expect(ancestry.MySimpleClassD).toStrictEqual([]);
+
+        // C has only D above it
+        expect(ancestry.MySimpleClassC).toStrictEqual(['MySimpleClassD']);
+
+        // B has both C and D at distance 1 (order between them is not asserted)
+        expect(new Set(ancestry.MySimpleClassB)).toStrictEqual(
+            new Set(['MySimpleClassC', 'MySimpleClassD']),
+        );
+        expect(ancestry.MySimpleClassB.length).toBe(2);
+
+        // A must include B and D (distance 1, order between them not asserted), then C (distance 2)
+        expect(new Set(ancestry.MySimpleClassA.slice(0, 2))).toStrictEqual(
+            new Set(['MySimpleClassB', 'MySimpleClassD']),
+        );
+        expect(ancestry.MySimpleClassA[2]).toBe('MySimpleClassC');
+    });
+
+    test('ancestry matches expected distance layers', async () => {
+        const { ancestry } = await dfs<{ ancestry: Record<string, string[]> }>(
+            mySimpleClassD,
+            async (_node, ancestry) => {
+                return { key: 'ancestry', value: ancestry.map((n) => n.name) };
+            },
+        )();
+
+        const expectedLayers: Record<string, string[][]> = {
+            MySimpleClassD: [],
+            MySimpleClassC: [['MySimpleClassD']],
+            MySimpleClassB: [['MySimpleClassC', 'MySimpleClassD']],
+            MySimpleClassA: [['MySimpleClassB', 'MySimpleClassD'], ['MySimpleClassC']],
+        };
+
+        for (const [nodeName, layers] of Object.entries(expectedLayers)) {
+            const actual = ancestry[nodeName];
+            let idx = 0;
+            for (const layer of layers) {
+                const segment = actual.slice(idx, idx + layer.length);
+                expect(new Set(segment)).toStrictEqual(new Set(layer));
+                idx += layer.length;
+            }
+            expect(idx).toBe(actual.length);
+        }
+    });
+});
+
+describe('DI Ancestry - randomized DAG property', () => {
+    const GNode = class<
+        Name extends string,
+        _Dependencies extends Dependencies,
+    > extends DependencyNode<Name, _Dependencies> {};
+
+    const makeRng = (seed: number) => {
+        let state = seed >>> 0;
+        return () => {
+            state = (state * 1664525 + 1013904223) >>> 0; // LCG
+            return state / 2 ** 32;
+        };
+    };
+
+    const buildRandomDag = (
+        numNodes: number,
+        edgeProbability: number,
+        seed: number,
+    ): DependencyNode<any, any>[] => {
+        const rng = makeRng(seed);
+        const nodes: DependencyNode<any, any>[] = [];
+        for (let i = 0; i < numNodes; i++) {
+            const deps: Record<string, DependencyNode<any, any>> = {};
+            for (let j = 0; j < i; j++) {
+                if (rng() < edgeProbability) {
+                    deps[`d${j}`] = nodes[j];
+                }
+            }
+            if (i > 0 && Object.keys(deps).length === 0) {
+                const j = Math.floor(rng() * i);
+                deps[`d${j}`] = nodes[j];
+            }
+            nodes.push(new GNode({ name: `N${i}`, dependencies: deps }));
+        }
+        return nodes;
+    };
+
+    const collectReachable = (root: DependencyNode<any, any>) => {
+        const map = new Map<string, DependencyNode<any, any>>();
+        const queue: DependencyNode<any, any>[] = [root];
+        while (queue.length > 0) {
+            const cur = queue.shift()!;
+            if (map.has(cur.name)) continue;
+            map.set(cur.name, cur);
+            for (const dep of Object.values(cur.dependencies) as DependencyNode<any, any>[]) {
+                queue.push(dep);
+            }
+        }
+        return map;
+    };
+
+    const buildDependentsIndex = (nodes: Map<string, DependencyNode<any, any>>) => {
+        const dependentsIndex = new Map<string, Set<string>>();
+        for (const node of nodes.values()) dependentsIndex.set(node.name, new Set());
+        for (const node of nodes.values()) {
+            for (const dep of Object.values(node.dependencies) as DependencyNode<any, any>[]) {
+                dependentsIndex.get(dep.name)!.add(node.name);
+            }
+        }
+        return dependentsIndex;
+    };
+
+    const computeDependentDistances = (
+        start: string,
+        dependentsIndex: Map<string, Set<string>>,
+    ) => {
+        const distances = new Map<string, number>();
+        const queue: Array<{ name: string; dist: number }> = [{ name: start, dist: 0 }];
+        distances.set(start, 0);
+        while (queue.length > 0) {
+            const { name, dist } = queue.shift()!;
+            for (const next of dependentsIndex.get(name) || [])
+                if (!distances.has(next)) {
+                    distances.set(next, dist + 1);
+                    queue.push({ name: next, dist: dist + 1 });
+                }
+        }
+        distances.delete(start);
+        return distances;
+    };
+
+    test('random DAGs: ancestry includes all ancestors and distances are non-decreasing', async () => {
+        // increase/play with these values if you're making changes :D
+        const iterations = 2;
+        const numNodes = 200;
+
+        // Edge probability p: node i has E[in-degree(i)] ≈ p*i (edges only to earlier nodes).
+        // Average per node ≈ p*(n-1)/2. For n=500 and p=0.25, avg ≈ 62; the last node ≈ 125.
+        const edgeProbability = 0.25;
+
+        // Sampling probability: fraction of reachable nodes validated.
+        // E[sampled] ≈ reachableCount * sampleProbability (≈100 if ~500 reachable).
+        const sampleProbability = 0.2;
+
+        const seeds = Array.from({ length: iterations }, () =>
+            Math.floor(Math.random() * 0x7fffffff),
+        );
+
+        for (const seed of seeds) {
+            try {
+                const nodes = buildRandomDag(numNodes, edgeProbability, seed);
+                const root = nodes[nodes.length - 1];
+                const res = await dfs<{ ancestry: Record<string, string[]> }>(
+                    root,
+                    async (_node, ancestry) => {
+                        return { key: 'ancestry', value: ancestry.map((n) => n.name) };
+                    },
+                )();
+                const reachable = collectReachable(root);
+                const dependentsIndex = buildDependentsIndex(reachable);
+
+                // dfs should traverse exactly the reachable set
+                expect(new Set(Object.keys(res.ancestry))).toStrictEqual(new Set(reachable.keys()));
+
+                const sample: { nodeName: string; list: string[] }[] = [];
+                for (const [nodeName, list] of Object.entries(res.ancestry)) {
+                    if (Math.random() < sampleProbability) {
+                        sample.push({ nodeName, list });
+                    }
+                }
+
+                for (const { nodeName, list } of sample) {
+                    // No self in ancestry
+                    expect(list.includes(nodeName)).toBe(false);
+                    // Inclusion: exactly the set of reachable dependents
+                    const distMap = computeDependentDistances(nodeName, dependentsIndex);
+                    expect(new Set(list)).toStrictEqual(new Set(distMap.keys()));
+
+                    // No duplicates
+                    expect(new Set(list).size).toBe(list.length);
+
+                    // Distance non-decreasing
+                    for (let i = 1; i < list.length; i++) {
+                        const prev = distMap.get(list[i - 1])!;
+                        const cur = distMap.get(list[i])!;
+                        expect(prev <= cur).toBe(true);
+                    }
+                }
+            } catch (err: any) {
+                if (err && typeof err === 'object' && 'message' in err) {
+                    err.message = `failed random dag test with seed ${seed}: ${err.message}`;
+                    throw err;
+                }
+                throw new Error(`failed random dag test with seed ${seed}: ${String(err)}`);
+            }
+        }
+    });
+});